/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp/__init__.py

• browse files at revision 4913.4.3
• compare with another revision
• compare with revision 0.200.155
• download diff
• download tarball
• view history from revision 4913.4.3

Show diffs side-by-side

added

removed

bzrlib/transport/ftp/__init__.py

1

 

# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd

 

1

# Copyright (C) 2005-2010 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

13

13

# You should have received a copy of the GNU General Public License

14

14

# along with this program; if not, write to the Free Software

15

15

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 

16

 

16

17

"""Implementation of Transport over ftp.

17

18

 

18

19

Written by Daniel Silverstone <dsilvers@digital-scurf.org> with serious

163

164

        connection, credentials = self._create_connection(credentials)

164

165

        self._set_connection(connection, credentials)

165

166

 

166

 

    def _translate_perm_error(self, err, path, extra=None,

 

167

    def _translate_ftp_error(self, err, path, extra=None,

167

168

                              unknown_exc=FtpPathError):

168

 

        """Try to translate an ftplib.error_perm exception.

 

169

        """Try to translate an ftplib exception to a bzrlib exception.

169

170

 

170

171

        :param err: The error to translate into a bzr error

171

172

        :param path: The path which had problems

173

174

        :param unknown_exc: If None, we will just raise the original exception

174

175

                    otherwise we raise unknown_exc(path, extra=extra)

175

176

        """

 

177

        # ftp error numbers are very generic, like "451: Requested action aborted,

 

178

        # local error in processing" so unfortunately we have to match by

 

179

        # strings.

176

180

        s = str(err).lower()

177

181

        if not extra:

178

182

            extra = str(err)

189

193

            or (s.startswith('550 ') and 'unable to rename to' in extra)

190

194

            ):

191

195

            raise errors.NoSuchFile(path, extra=extra)

192

 

        if ('file exists' in s):

 

196

        elif ('file exists' in s):

193

197

            raise errors.FileExists(path, extra=extra)

194

 

        if ('not a directory' in s):

 

198

        elif ('not a directory' in s):

195

199

            raise errors.PathError(path, extra=extra)

 

200

        elif 'directory not empty' in s:

 

201

            raise errors.DirectoryNotEmpty(path, extra=extra)

196

202

 

197

203

        mutter('unable to understand error for path: %s: %s', path, err)

198

204

 

205

211

        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)

206

212

        raise

207

213

 

208

 

    def _remote_path(self, relpath):

209

 

        # XXX: It seems that ftplib does not handle Unicode paths

210

 

        # at the same time, medusa won't handle utf8 paths So if

211

 

        # we .encode(utf8) here (see ConnectedTransport

212

 

        # implementation), then we get a Server failure.  while

213

 

        # if we use str(), we get a UnicodeError, and the test

214

 

        # suite just skips testing UnicodePaths.

215

 

        relative = str(urlutils.unescape(relpath))

216

 

        remote_path = self._combine_paths(self._path, relative)

217

 

        return remote_path

218

 

 

219

214

    def has(self, relpath):

220

215

        """Does the target location exist?"""

221

216

        # FIXME jam 20060516 We *do* ask about directories in the test suite

329

324

                    raise e

330

325

                raise

331

326

        except ftplib.error_perm, e:

332

 

            self._translate_perm_error(e, abspath, extra='could not store',

 

327

            self._translate_ftp_error(e, abspath, extra='could not store',

333

328

                                       unknown_exc=errors.NoSuchFile)

334

329

        except ftplib.error_temp, e:

335

330

            if retries > _number_of_retries:

358

353

            f.mkd(abspath)

359

354

            self._setmode(relpath, mode)

360

355

        except ftplib.error_perm, e:

361

 

            self._translate_perm_error(e, abspath,

 

356

            self._translate_ftp_error(e, abspath,

362

357

                unknown_exc=errors.FileExists)

363

358

 

364

359

    def open_write_stream(self, relpath, mode=None):

384

379

            f = self._get_FTP()

385

380

            f.rmd(abspath)

386

381

        except ftplib.error_perm, e:

387

 

            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)

 

382

            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)

388

383

 

389

384

    def append_file(self, relpath, f, mode=None):

390

385

        """Append the text in the file-like object into the final

430

425

                self._has_append = False

431

426

                self._fallback_append(relpath, text, mode)

432

427

            else:

433

 

                self._translate_perm_error(e, abspath, extra='error appending',

 

428

                self._translate_ftp_error(e, abspath, extra='error appending',

434

429

                    unknown_exc=errors.NoSuchFile)

435

430

        except ftplib.error_temp, e:

436

431

            if retries > _number_of_retries:

483

478

    def _rename(self, abs_from, abs_to, f):

484

479

        try:

485

480

            f.rename(abs_from, abs_to)

486

 

        except ftplib.error_perm, e:

487

 

            self._translate_perm_error(e, abs_from,

 

481

        except (ftplib.error_temp, ftplib.error_perm), e:

 

482

            self._translate_ftp_error(e, abs_from,

488

483

                ': unable to rename to %r' % (abs_to))

489

484

 

490

485

    def move(self, rel_from, rel_to):

496

491

            f = self._get_FTP()

497

492

            self._rename_and_overwrite(abs_from, abs_to, f)

498

493

        except ftplib.error_perm, e:

499

 

            self._translate_perm_error(e, abs_from,

 

494

            self._translate_ftp_error(e, abs_from,

500

495

                extra='unable to rename to %r' % (rel_to,),

501

496

                unknown_exc=errors.PathError)

502

497

 

520

515

            mutter("FTP rm: %s", abspath)

521

516

            f.delete(abspath)

522

517

        except ftplib.error_perm, e:

523

 

            self._translate_perm_error(e, abspath, 'error deleting',

 

518

            self._translate_ftp_error(e, abspath, 'error deleting',

524

519

                unknown_exc=errors.NoSuchFile)

525

520

 

526

521

    def external_url(self):

541

536

            try:

542

537

                paths = f.nlst(basepath)

543

538

            except ftplib.error_perm, e:

544

 

                self._translate_perm_error(e, relpath,

 

539

                self._translate_ftp_error(e, relpath,

545

540

                                           extra='error with list_dir')

546

541

            except ftplib.error_temp, e:

547

542

                # xs4all's ftp server raises a 450 temp error when listing an

590

585

            f = self._get_FTP()

591

586

            return FtpStatResult(f, abspath)

592

587

        except ftplib.error_perm, e:

593

 

            self._translate_perm_error(e, abspath, extra='error w/ stat')

 

588

            self._translate_ftp_error(e, abspath, extra='error w/ stat')

594

589

 

595

590

    def lock_read(self, relpath):

596

591

        """Lock the given file for shared (read) access.

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0