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 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
self._ftp_server.close()
610
self._async_thread.join()
613
def _asyncore_loop_ignore_EBADF(*args, **kwargs):
614
"""Ignore EBADF during server shutdown.
616
We close the socket to get the server to shutdown, but this causes
617
select.select() to raise EBADF.
620
asyncore.loop(*args, **kwargs)
621
# FIXME: If we reach that point, we should raise an exception
622
# explaining that the 'count' parameter in setUp is too low or
623
# testers may wonder why their test just sits there waiting for a
624
# server that is already dead. Note that if the tester waits too
625
# long under pdb the server will also die.
626
except select.error, e:
627
if e.args[0] != errno.EBADF:
633
_test_authorizer = None
637
global _have_medusa, _ftp_channel, _ftp_server, _test_authorizer
640
import medusa.filesys
641
import medusa.ftp_server
647
class test_authorizer(object):
648
"""A custom Authorizer object for running the test suite.
650
The reason we cannot use dummy_authorizer, is because it sets the
651
channel to readonly, which we don't always want to do.
654
def __init__(self, root):
656
# If secured_user is set secured_password will be checked
657
self.secured_user = None
658
self.secured_password = None
660
def authorize(self, channel, username, password):
661
"""Return (success, reply_string, filesystem)"""
663
return 0, 'No Medusa.', None
665
channel.persona = -1, -1
666
if username == 'anonymous':
667
channel.read_only = 1
669
channel.read_only = 0
671
# Check secured_user if set
672
if (self.secured_user is not None
673
and username == self.secured_user
674
and password != self.secured_password):
675
return 0, 'Password invalid.', None
677
return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
680
class ftp_channel(medusa.ftp_server.ftp_channel):
681
"""Customized ftp channel"""
683
def log(self, message):
684
"""Redirect logging requests."""
685
mutter('_ftp_channel: %s', message)
687
def log_info(self, message, type='info'):
688
"""Redirect logging requests."""
689
mutter('_ftp_channel %s: %s', type, message)
691
def cmd_rnfr(self, line):
692
"""Prepare for renaming a file."""
693
self._renaming = line[1]
694
self.respond('350 Ready for RNTO')
695
# TODO: jam 20060516 in testing, the ftp server seems to
696
# check that the file already exists, or it sends
697
# 550 RNFR command failed
699
def cmd_rnto(self, line):
700
"""Rename a file based on the target given.
702
rnto must be called after calling rnfr.
704
if not self._renaming:
705
self.respond('503 RNFR required first.')
706
pfrom = self.filesystem.translate(self._renaming)
707
self._renaming = None
708
pto = self.filesystem.translate(line[1])
709
if os.path.exists(pto):
710
self.respond('550 RNTO failed: file exists')
713
os.rename(pfrom, pto)
714
except (IOError, OSError), e:
715
# TODO: jam 20060516 return custom responses based on
716
# why the command failed
717
# (bialix 20070418) str(e) on Python 2.5 @ Windows
718
# sometimes don't provide expected error message;
719
# so we obtain such message via os.strerror()
720
self.respond('550 RNTO failed: %s' % os.strerror(e.errno))
722
self.respond('550 RNTO failed')
723
# For a test server, we will go ahead and just die
726
self.respond('250 Rename successful.')
728
def cmd_size(self, line):
729
"""Return the size of a file
731
This is overloaded to help the test suite determine if the
732
target is a directory.
735
if not self.filesystem.isfile(filename):
736
if self.filesystem.isdir(filename):
737
self.respond('550 "%s" is a directory' % (filename,))
739
self.respond('550 "%s" is not a file' % (filename,))
741
self.respond('213 %d'
742
% (self.filesystem.stat(filename)[stat.ST_SIZE]),)
744
def cmd_mkd(self, line):
745
"""Create a directory.
747
Overloaded because default implementation does not distinguish
748
*why* it cannot make a directory.
751
self.command_not_understood(''.join(line))
755
self.filesystem.mkdir (path)
756
self.respond ('257 MKD command successful.')
757
except (IOError, OSError), e:
758
# (bialix 20070418) str(e) on Python 2.5 @ Windows
759
# sometimes don't provide expected error message;
760
# so we obtain such message via os.strerror()
761
self.respond ('550 error creating directory: %s' %
762
os.strerror(e.errno))
764
self.respond ('550 error creating directory.')
767
class ftp_server(medusa.ftp_server.ftp_server):
768
"""Customize the behavior of the Medusa ftp_server.
770
There are a few warts on the ftp_server, based on how it expects
774
ftp_channel_class = ftp_channel
776
def __init__(self, *args, **kwargs):
777
mutter('Initializing _ftp_server: %r, %r', args, kwargs)
778
medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
780
def log(self, message):
781
"""Redirect logging requests."""
782
mutter('_ftp_server: %s', message)
784
def log_info(self, message, type='info'):
785
"""Override the asyncore.log_info so we don't stipple the screen."""
786
mutter('_ftp_server %s: %s', type, message)
788
_test_authorizer = test_authorizer
789
_ftp_channel = ftp_channel
790
_ftp_server = ftp_server
612
795
def get_test_permutations():
613
796
"""Return the permutations to be used in testing."""
614
from bzrlib.tests import ftp_server
615
return [(FtpTransport, ftp_server.FTPTestServer)]
797
if not _setup_medusa():
798
warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
801
return [(FtpTransport, FtpServer)]
added
removed
bzrlib/transport/ftp.py
