~launchpad-pqm/launchpad/devel

# Copyright 2009 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""An SFTP server that backs on to a special kind of Bazaar Transport.

The Bazaar Transport is special in two ways:

 1. It implements two methods `writeChunk` and `local_realPath` (see the

    `FatLocalTransport` class for a description of these)

 2. Every transport method returns Deferreds and does not block.

We call such a transport a "Twisted Transport".

"""

__metaclass__ = type

__all__ = [

    'avatar_to_sftp_server',

    'TransportSFTPServer',

    ]

from copy import copy

import errno

import os

import stat

from bzrlib import (

    errors as bzr_errors,

    osutils,

    urlutils,

    )

from bzrlib.transport.local import LocalTransport

from twisted.conch.interfaces import (

    ISFTPFile,

    ISFTPServer,

    )

from twisted.conch.ls import lsLine

from twisted.conch.ssh import filetransfer

from twisted.internet import defer

from twisted.python import util

from zope.interface import implements

from lp.codehosting.vfs import (

    AsyncLaunchpadTransport,

    LaunchpadServer,

    )

from lp.services.config import config

from lp.services.sshserver.sftp import FileIsADirectory

from lp.services.twistedsupport import gatherResults

class FatLocalTransport(LocalTransport):

    """A Bazaar transport that also implements writeChunk and local_realPath.

    We need these so that we can implement SFTP over a Bazaar transport.

    """

    def clone(self, offset=None):

        if offset is None:

            abspath = self.base

        else:

            abspath = self.abspath(offset)

        return FatLocalTransport(abspath)

    def writeChunk(self, name, offset, data):

        """Write a chunk of data to file `name` at `offset`."""

        abspath = self._abspath(name)

        osutils.check_legal_path(abspath)

        try:

            chunk_file = os.open(abspath, os.O_CREAT | os.O_WRONLY)

        except OSError, e:

            if e.errno != errno.EISDIR:

                raise

            raise FileIsADirectory(name)

        os.lseek(chunk_file, offset, 0)

        os.write(chunk_file, data)

        os.close(chunk_file)

    def local_realPath(self, path):

        """Return the absolute path to `path`."""

        abspath = self._abspath(path)

        return urlutils.escape(os.path.realpath(abspath))

def with_sftp_error(func):

    """Decorator used to translate Bazaar errors into SFTP errors.

    This assumes that the function being decorated returns a Deferred.

    See `TransportSFTPServer.translateError` for the details of the

    translation.

    """

    def decorator(*args, **kwargs):

        deferred = func(*args, **kwargs)

        return deferred.addErrback(TransportSFTPServer.translateError,

                                   func.__name__)

    return util.mergeFunctionMetadata(func, decorator)

class DirectoryListing:

    """Class to satisfy openDirectory return interface.

    openDirectory returns an iterator -- with a `close` method.  Hence

    this class.

    """

    def __init__(self, entries):

        self.iter = iter(entries)

    def __iter__(self):

        return self

    def next(self):

        return self.iter.next()

    def close(self):

        # I can't believe we had to implement a whole class just to

        # have this do-nothing method (abentley).

        pass

class TransportSFTPFile:

    """An implementation of `ISFTPFile` that backs onto a Bazaar transport.

    The transport must be a Twisted Transport.

    """

    implements(ISFTPFile)

    def __init__(self, transport, name, flags, server):

        self._unescaped_relpath = name

        self._escaped_path = urlutils.escape(self._unescaped_relpath)

        self._flags = flags

        self.transport = transport

        self._written = False

        self._server = server

    def _shouldAppend(self):

        """Is this file opened append?"""

        return bool(self._flags & filetransfer.FXF_APPEND)

    def _shouldCreate(self):

        """Should we create a file?"""

        # The Twisted VFS adapter creates a file when any of these flags are

        # set. It's possible that we only need to check for FXF_CREAT.

        create_mask = (

            filetransfer.FXF_WRITE | filetransfer.FXF_APPEND |

            filetransfer.FXF_CREAT)

        return bool(self._flags & create_mask)

    def _shouldTruncate(self):

        """Should we truncate the file?"""

        return (bool(self._flags & filetransfer.FXF_TRUNC)

                and not self._written)

    def _shouldWrite(self):

        """Is this file opened writable?"""

        write_mask = (filetransfer.FXF_WRITE | filetransfer.FXF_APPEND)

        return bool(self._flags & write_mask)

    def _truncateFile(self):

        """Truncate this file."""

        self._written = True

        return self.transport.put_bytes(self._escaped_path, '')

    @with_sftp_error

    def writeChunk(self, offset, data):

        """See `ISFTPFile`."""

        if not self._shouldWrite():

            raise filetransfer.SFTPError(

                filetransfer.FX_PERMISSION_DENIED,

                "%r was opened read-only." % self._unescaped_relpath)

        if self._shouldTruncate():

            deferred = self._truncateFile()

        else:

            deferred = defer.succeed(None)

        self._written = True

        if self._shouldAppend():

            deferred.addCallback(

                lambda ignored:

                self.transport.append_bytes(self._escaped_path, data))

        else:

            deferred.addCallback(

                lambda ignored:

                self.transport.writeChunk(self._escaped_path, offset, data))

        return deferred

    @with_sftp_error

    def readChunk(self, offset, length):

        """See `ISFTPFile`."""

        deferred = self.transport.readv(

            self._escaped_path, [(offset, length)])

        def get_first_chunk(read_things):

            return read_things.next()[1]

        def handle_short_read(failure):

            """Handle short reads by reading what was available.

            Doing things this way around, by trying to read all the data

            requested and then handling the short read error, might be a bit

            inefficient, but the bzrlib sftp transport doesn't read past the

            end of files, so we don't need to worry too much about performance

            here.

            """

            failure.trap(bzr_errors.ShortReadvError)

            return self.readChunk(failure.value.offset, failure.value.actual)

        deferred.addCallback(get_first_chunk)

        return deferred.addErrback(handle_short_read)

    def setAttrs(self, attrs):

        """See `ISFTPFile`.

        The Transport interface does not allow setting any attributes.

        """

        # XXX 2008-05-09 JonathanLange: This should at least raise an error,

        # not do nothing silently.

        return self._server.setAttrs(self._unescaped_relpath, attrs)

    @with_sftp_error

    def getAttrs(self):

        """See `ISFTPFile`."""

        return self._server.getAttrs(self._unescaped_relpath, False)

    def close(self):

        """See `ISFTPFile`."""

        if self._written or not self._shouldCreate():

            return defer.succeed(None)

        if self._shouldTruncate():

            return self._truncateFile()

        deferred = self.transport.has(self._escaped_path)

        def maybe_create_file(already_exists):

            if not already_exists:

                return self._truncateFile()

        return deferred.addCallback(maybe_create_file)

def _get_transport_for_dir(directory):

    url = urlutils.local_path_to_url(directory)

    return FatLocalTransport(url)

def avatar_to_sftp_server(avatar):

    user_id = avatar.user_id

    branch_transport = _get_transport_for_dir(

        config.codehosting.mirrored_branches_root)

    server = LaunchpadServer(

        avatar.codehosting_proxy, user_id, branch_transport)

    server.start_server()

    transport = AsyncLaunchpadTransport(server, server.get_url())

    return TransportSFTPServer(transport)

class TransportSFTPServer:

    """An implementation of `ISFTPServer` that backs onto a Bazaar transport.

    The transport must be a Twisted Transport.

    """

    implements(ISFTPServer)

    def __init__(self, transport):

        self.transport = transport

    def extendedRequest(self, extendedName, extendedData):

        """See `ISFTPServer`."""

        raise NotImplementedError

    def makeLink(self, src, dest):

        """See `ISFTPServer`."""

        raise NotImplementedError()

    def _stat_files_in_list(self, file_list, escaped_dir_path):

        """Stat the a list of files.

        :param file_list: The list of escaped file names.

        :param escaped_dir_path: The escaped path of the directory containing

            the files.

        :return: A Deferred which will be called back with the list of all the

            stat results.

        """

        deferreds = []

        for filename in file_list:

            escaped_file_path = os.path.join(escaped_dir_path, filename)

            deferreds.append(

                self.transport.stat(escaped_file_path))

        return gatherResults(deferreds)

    def _format_directory_entries(self, stat_results, filenames):

        """Produce entries suitable for returning from `openDirectory`.

        :param stat_results: A list of the results of calling `stat` on each

            file in filenames.

        :param filenames: The list of filenames to produce entries for.

        :return: An iterator of ``(shortname, longname, attributes)``.

        """

        for stat_result, filename in zip(stat_results, filenames):

            shortname = urlutils.unescape(filename).encode('utf-8')

            stat_result = copy(stat_result)

            for attribute in ['st_uid', 'st_gid', 'st_mtime', 'st_nlink']:

                if getattr(stat_result, attribute, None) is None:

                    setattr(stat_result, attribute, 0)

            longname = lsLine(shortname, stat_result)

            attr_dict = self._translate_stat(stat_result)

            yield (shortname, longname, attr_dict)

    @with_sftp_error

    def openDirectory(self, path):

        """See `ISFTPServer`."""

        escaped_path = urlutils.escape(path)

        deferred = self.transport.list_dir(escaped_path)

        def produce_entries_from_file_list(file_list):

            stats_deferred = self._stat_files_in_list(file_list, escaped_path)

            stats_deferred.addCallback(

                self._format_directory_entries, file_list)

            return stats_deferred

        return deferred.addCallback(

            produce_entries_from_file_list).addCallback(DirectoryListing)

    @with_sftp_error

    def openFile(self, path, flags, attrs):

        """See `ISFTPServer`."""

        directory = os.path.dirname(path)

        deferred = self.transport.stat(directory)

        def open_file(stat_result):

            if stat.S_ISDIR(stat_result.st_mode):

                return TransportSFTPFile(self.transport, path, flags, self)

            else:

                raise filetransfer.SFTPError(

                    filetransfer.FX_NO_SUCH_FILE, directory)

        return deferred.addCallback(open_file)

    def readLink(self, path):

        """See `ISFTPServer`."""

        raise NotImplementedError()

    def realPath(self, relpath):

        """See `ISFTPServer`."""

        deferred = self.transport.local_realPath(urlutils.escape(relpath))

        def unescape_path(path):

            unescaped_path = urlutils.unescape(path)

            return unescaped_path.encode('utf-8')

        return deferred.addCallback(unescape_path)

    def setAttrs(self, path, attrs):

        """See `ISFTPServer`.

        This just delegates to TransportSFTPFile's implementation.

        """

        return defer.succeed(None)

    def _translate_stat(self, stat_val):

        """Translate the stat result `stat_val` into an attributes dict.

        This is very like conch.ssh.unix.SFTPServerForUnixConchUser._getAttrs,

        but (a) that is private and (b) we use getattr() to access the

        attributes as not all the Bazaar transports return full stat results.

        """

        return {

            'size': getattr(stat_val, 'st_size', 0),

            'uid': getattr(stat_val, 'st_uid', 0),

            'gid': getattr(stat_val, 'st_gid', 0),

            'permissions': getattr(stat_val, 'st_mode', 0),

            'atime': getattr(stat_val, 'st_atime', 0),

            'mtime': getattr(stat_val, 'st_mtime', 0),

        }

    @with_sftp_error

    def getAttrs(self, path, followLinks):

        """See `ISFTPServer`.

        This just delegates to TransportSFTPFile's implementation.

        """

        deferred = self.transport.stat(urlutils.escape(path))

        return deferred.addCallback(self._translate_stat)

    def gotVersion(self, otherVersion, extensionData):

        """See `ISFTPServer`."""

        return {}

    @with_sftp_error

    def makeDirectory(self, path, attrs):

        """See `ISFTPServer`."""

        return self.transport.mkdir(

            urlutils.escape(path), attrs['permissions'])

    @with_sftp_error

    def removeDirectory(self, path):

        """See `ISFTPServer`."""

        return self.transport.rmdir(urlutils.escape(path))

    @with_sftp_error

    def removeFile(self, path):

        """See `ISFTPServer`."""

        return self.transport.delete(urlutils.escape(path))

    @with_sftp_error

    def renameFile(self, oldpath, newpath):

        """See `ISFTPServer`."""

        return self.transport.rename(

            urlutils.escape(oldpath), urlutils.escape(newpath))

    @staticmethod

    def translateError(failure, func_name):

        """Translate Bazaar errors to `filetransfer.SFTPError` instances."""

        types_to_codes = {

            bzr_errors.PermissionDenied: filetransfer.FX_PERMISSION_DENIED,

            bzr_errors.TransportNotPossible:

                filetransfer.FX_PERMISSION_DENIED,

            bzr_errors.NoSuchFile: filetransfer.FX_NO_SUCH_FILE,

            bzr_errors.FileExists: filetransfer.FX_FILE_ALREADY_EXISTS,

            bzr_errors.DirectoryNotEmpty: filetransfer.FX_FAILURE,

            bzr_errors.TransportError: filetransfer.FX_FAILURE,

            FileIsADirectory: filetransfer.FX_FILE_IS_A_DIRECTORY,

            }

        # Bazaar expects makeDirectory to fail with exactly the string "mkdir

        # failed".

        names_to_messages = {

            'makeDirectory': 'mkdir failed',

            }

        try:

            sftp_code = types_to_codes[failure.type]

        except KeyError:

            failure.raiseException()

        message = names_to_messages.get(func_name, failure.getErrorMessage())

        raise filetransfer.SFTPError(sftp_code, message)