119
115
:return: The created connection and its associated credentials.
121
The input credentials are only the password as it may have been
122
entered interactively by the user and may be different from the one
123
provided in base url at transport creation time. The returned
124
credentials are username, password.
117
The credentials are only the password as it may have been entered
118
interactively by the user and may be different from the one provided
119
in base url at transport creation time.
126
121
if credentials is None:
127
user, password = self._user, self._password
122
password = self._password
129
user, password = credentials
124
password = credentials
131
auth = config.AuthenticationConfig()
133
user = auth.get_user('ftp', self._host, port=self._port,
134
default=getpass.getuser())
135
126
mutter("Constructing FTP instance against %r" %
136
((self._host, self._port, user, '********',
127
((self._host, self._port, self._user, '********',
137
128
self.is_active),))
139
connection = self.connection_class()
130
connection = ftplib.FTP()
140
131
connection.connect(host=self._host, port=self._port)
141
self._login(connection, auth, user, password)
132
if self._user and self._user != 'anonymous' and \
133
password is not None: # '' is a valid password
134
get_password = bzrlib.ui.ui_factory.get_password
135
password = get_password(prompt='FTP %(user)s@%(host)s password',
136
user=self._user, host=self._host)
137
connection.login(user=self._user, passwd=password)
142
138
connection.set_pasv(not self.is_active)
143
# binary mode is the default
144
connection.voidcmd('TYPE I')
145
except socket.error, e:
146
raise errors.SocketConnectionError(self._host, self._port,
147
msg='Unable to connect to',
149
139
except ftplib.error_perm, e:
150
140
raise errors.TransportError(msg="Error setting up connection:"
151
141
" %s" % str(e), orig_error=e)
152
return connection, (user, password)
154
def _login(self, connection, auth, user, password):
155
# '' is a valid password
156
if user and user != 'anonymous' and password is None:
157
password = auth.get_password('ftp', self._host,
158
user, port=self._port)
159
connection.login(user=user, passwd=password)
142
return connection, password
161
144
def _reconnect(self):
162
145
"""Create a new connection with the previously used credentials"""
163
credentials = self._get_credentials()
146
credentials = self.get_credentials()
164
147
connection, credentials = self._create_connection(credentials)
165
148
self._set_connection(connection, credentials)
167
def _translate_ftp_error(self, err, path, extra=None,
150
def _translate_perm_error(self, err, path, extra=None,
168
151
unknown_exc=FtpPathError):
169
"""Try to translate an ftplib exception to a bzrlib exception.
152
"""Try to translate an ftplib.error_perm exception.
171
154
:param err: The error to translate into a bzr error
172
155
:param path: The path which had problems
187
167
or 'no such dir' in s
188
168
or 'could not create file' in s # vsftpd
189
169
or 'file doesn\'t exist' in s
190
or 'rnfr command failed.' in s # vsftpd RNFR reply if file not found
191
or 'file/directory not found' in s # filezilla server
192
# Microsoft FTP-Service RNFR reply if file not found
193
or (s.startswith('550 ') and 'unable to rename to' in extra)
195
171
raise errors.NoSuchFile(path, extra=extra)
196
elif ('file exists' in s):
172
if ('file exists' in s):
197
173
raise errors.FileExists(path, extra=extra)
198
elif ('not a directory' in s):
174
if ('not a directory' in s):
199
175
raise errors.PathError(path, extra=extra)
200
elif 'directory not empty' in s:
201
raise errors.DirectoryNotEmpty(path, extra=extra)
203
177
mutter('unable to understand error for path: %s: %s', path, err)
206
180
raise unknown_exc(path, extra=extra)
207
# TODO: jam 20060516 Consider re-raising the error wrapped in
181
# TODO: jam 20060516 Consider re-raising the error wrapped in
208
182
# something like TransportError, but this loses the traceback
209
183
# Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
210
184
# to handle. Consider doing something like that here.
211
185
#raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
188
def _remote_path(self, relpath):
189
# XXX: It seems that ftplib does not handle Unicode paths
190
# at the same time, medusa won't handle utf8 paths So if
191
# we .encode(utf8) here (see ConnectedTransport
192
# implementation), then we get a Server failure. while
193
# if we use str(), we get a UnicodeError, and the test
194
# suite just skips testing UnicodePaths.
195
relative = str(urlutils.unescape(relpath))
196
remote_path = self._combine_paths(self._path, relative)
214
199
def has(self, relpath):
215
200
"""Does the target location exist?"""
216
201
# FIXME jam 20060516 We *do* ask about directories in the test suite
411
390
abspath = self._remote_path(relpath)
412
391
mutter("FTP appe (try %d) to %s", retries, abspath)
413
392
ftp = self._get_FTP()
393
ftp.voidcmd("TYPE I")
414
394
cmd = "APPE %s" % abspath
415
395
conn = ftp.transfercmd(cmd)
416
396
conn.sendall(text)
418
self._setmode(relpath, mode)
399
self._setmode(relpath, mode)
420
401
except ftplib.error_perm, e:
421
# Check whether the command is not supported (reply code 502)
422
if str(e).startswith('502 '):
423
warning("FTP server does not support file appending natively. "
424
"Performance may be severely degraded! (%s)", e)
425
self._has_append = False
426
self._fallback_append(relpath, text, mode)
428
self._translate_ftp_error(e, abspath, extra='error appending',
429
unknown_exc=errors.NoSuchFile)
402
self._translate_perm_error(e, abspath, extra='error appending',
403
unknown_exc=errors.NoSuchFile)
430
404
except ftplib.error_temp, e:
431
405
if retries > _number_of_retries:
432
raise errors.TransportError(
433
"FTP temporary error during APPEND %s. Aborting."
434
% abspath, orig_error=e)
406
raise errors.TransportError("FTP temporary error during APPEND %s." \
407
"Aborting." % abspath, orig_error=e)
436
409
warning("FTP temporary error: %s. Retrying.", str(e))
437
410
self._reconnect()
438
411
self._try_append(relpath, text, mode, retries+1)
440
def _fallback_append(self, relpath, text, mode = None):
441
remote = self.get(relpath)
442
remote.seek(0, os.SEEK_END)
445
return self.put_file(relpath, remote, mode)
447
413
def _setmode(self, relpath, mode):
448
414
"""Set permissions on a path.
450
416
Only set permissions if the FTP server supports the 'SITE CHMOD'
455
mutter("FTP site chmod: setting permissions to %s on %s",
456
oct(mode), self._remote_path(relpath))
457
ftp = self._get_FTP()
458
cmd = "SITE CHMOD %s %s" % (oct(mode),
459
self._remote_path(relpath))
461
except ftplib.error_perm, e:
462
# Command probably not available on this server
463
warning("FTP Could not set permissions to %s on %s. %s",
464
oct(mode), self._remote_path(relpath), str(e))
420
mutter("FTP site chmod: setting permissions to %s on %s",
421
str(mode), self._remote_path(relpath))
422
ftp = self._get_FTP()
423
cmd = "SITE CHMOD %s %s" % (self._remote_path(relpath), str(mode))
425
except ftplib.error_perm, e:
426
# Command probably not available on this server
427
warning("FTP Could not set permissions to %s on %s. %s",
428
str(mode), self._remote_path(relpath), str(e))
466
430
# TODO: jam 20060516 I believe ftp allows you to tell an ftp server
467
431
# to copy something to another machine. And you may be able
609
556
return self.lock_read(relpath)
559
class FtpServer(Server):
560
"""Common code for FTP server facilities."""
564
self._ftp_server = None
566
self._async_thread = None
571
"""Calculate an ftp url to this server."""
572
return 'ftp://foo:bar@localhost:%d/' % (self._port)
574
# def get_bogus_url(self):
575
# """Return a URL which cannot be connected to."""
576
# return 'ftp://127.0.0.1:1'
578
def log(self, message):
579
"""This is used by medusa.ftp_server to log connections, etc."""
580
self.logs.append(message)
582
def setUp(self, vfs_server=None):
584
raise RuntimeError('Must have medusa to run the FtpServer')
586
assert vfs_server is None or isinstance(vfs_server, LocalURLServer), \
587
"FtpServer currently assumes local transport, got %s" % vfs_server
589
self._root = os.getcwdu()
590
self._ftp_server = _ftp_server(
591
authorizer=_test_authorizer(root=self._root),
593
port=0, # bind to a random port
595
logger_object=self # Use FtpServer.log() for messages
597
self._port = self._ftp_server.getsockname()[1]
598
# Don't let it loop forever, or handle an infinite number of requests.
599
# In this case it will run for 1000s, or 10000 requests
600
self._async_thread = threading.Thread(
601
target=FtpServer._asyncore_loop_ignore_EBADF,
602
kwargs={'timeout':0.1, 'count':10000})
603
self._async_thread.setDaemon(True)
604
self._async_thread.start()
607
"""See bzrlib.transport.Server.tearDown."""
608
# have asyncore release the channel
609
self._ftp_server.del_channel()
611
self._async_thread.join()
614
def _asyncore_loop_ignore_EBADF(*args, **kwargs):
615
"""Ignore EBADF during server shutdown.
617
We close the socket to get the server to shutdown, but this causes
618
select.select() to raise EBADF.
621
asyncore.loop(*args, **kwargs)
622
# FIXME: If we reach that point, we should raise an exception
623
# explaining that the 'count' parameter in setUp is too low or
624
# testers may wonder why their test just sits there waiting for a
625
# server that is already dead. Note that if the tester waits too
626
# long under pdb the server will also die.
627
except select.error, e:
628
if e.args[0] != errno.EBADF:
634
_test_authorizer = None
638
global _have_medusa, _ftp_channel, _ftp_server, _test_authorizer
641
import medusa.filesys
642
import medusa.ftp_server
648
class test_authorizer(object):
649
"""A custom Authorizer object for running the test suite.
651
The reason we cannot use dummy_authorizer, is because it sets the
652
channel to readonly, which we don't always want to do.
655
def __init__(self, root):
658
def authorize(self, channel, username, password):
659
"""Return (success, reply_string, filesystem)"""
661
return 0, 'No Medusa.', None
663
channel.persona = -1, -1
664
if username == 'anonymous':
665
channel.read_only = 1
667
channel.read_only = 0
669
return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
672
class ftp_channel(medusa.ftp_server.ftp_channel):
673
"""Customized ftp channel"""
675
def log(self, message):
676
"""Redirect logging requests."""
677
mutter('_ftp_channel: %s', message)
679
def log_info(self, message, type='info'):
680
"""Redirect logging requests."""
681
mutter('_ftp_channel %s: %s', type, message)
683
def cmd_rnfr(self, line):
684
"""Prepare for renaming a file."""
685
self._renaming = line[1]
686
self.respond('350 Ready for RNTO')
687
# TODO: jam 20060516 in testing, the ftp server seems to
688
# check that the file already exists, or it sends
689
# 550 RNFR command failed
691
def cmd_rnto(self, line):
692
"""Rename a file based on the target given.
694
rnto must be called after calling rnfr.
696
if not self._renaming:
697
self.respond('503 RNFR required first.')
698
pfrom = self.filesystem.translate(self._renaming)
699
self._renaming = None
700
pto = self.filesystem.translate(line[1])
701
if os.path.exists(pto):
702
self.respond('550 RNTO failed: file exists')
705
os.rename(pfrom, pto)
706
except (IOError, OSError), e:
707
# TODO: jam 20060516 return custom responses based on
708
# why the command failed
709
# (bialix 20070418) str(e) on Python 2.5 @ Windows
710
# sometimes don't provide expected error message;
711
# so we obtain such message via os.strerror()
712
self.respond('550 RNTO failed: %s' % os.strerror(e.errno))
714
self.respond('550 RNTO failed')
715
# For a test server, we will go ahead and just die
718
self.respond('250 Rename successful.')
720
def cmd_size(self, line):
721
"""Return the size of a file
723
This is overloaded to help the test suite determine if the
724
target is a directory.
727
if not self.filesystem.isfile(filename):
728
if self.filesystem.isdir(filename):
729
self.respond('550 "%s" is a directory' % (filename,))
731
self.respond('550 "%s" is not a file' % (filename,))
733
self.respond('213 %d'
734
% (self.filesystem.stat(filename)[stat.ST_SIZE]),)
736
def cmd_mkd(self, line):
737
"""Create a directory.
739
Overloaded because default implementation does not distinguish
740
*why* it cannot make a directory.
743
self.command_not_understood(''.join(line))
747
self.filesystem.mkdir (path)
748
self.respond ('257 MKD command successful.')
749
except (IOError, OSError), e:
750
# (bialix 20070418) str(e) on Python 2.5 @ Windows
751
# sometimes don't provide expected error message;
752
# so we obtain such message via os.strerror()
753
self.respond ('550 error creating directory: %s' %
754
os.strerror(e.errno))
756
self.respond ('550 error creating directory.')
759
class ftp_server(medusa.ftp_server.ftp_server):
760
"""Customize the behavior of the Medusa ftp_server.
762
There are a few warts on the ftp_server, based on how it expects
766
ftp_channel_class = ftp_channel
768
def __init__(self, *args, **kwargs):
769
mutter('Initializing _ftp_server: %r, %r', args, kwargs)
770
medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
772
def log(self, message):
773
"""Redirect logging requests."""
774
mutter('_ftp_server: %s', message)
776
def log_info(self, message, type='info'):
777
"""Override the asyncore.log_info so we don't stipple the screen."""
778
mutter('_ftp_server %s: %s', type, message)
780
_test_authorizer = test_authorizer
781
_ftp_channel = ftp_channel
782
_ftp_server = ftp_server
612
787
def get_test_permutations():
613
788
"""Return the permutations to be used in testing."""
614
from bzrlib.tests import ftp_server
615
return [(FtpTransport, ftp_server.FTPTestServer)]
789
if not _setup_medusa():
790
warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
793
return [(FtpTransport, FtpServer)]
added
removed
bzrlib/transport/ftp.py
