269 lines
11 KiB
Python
269 lines
11 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# SAT plugin for file tansfer
|
|
# Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from sat.core.i18n import _, D_
|
|
from sat.core.constants import Const as C
|
|
from sat.core.log import getLogger
|
|
log = getLogger(__name__)
|
|
from sat.core import exceptions
|
|
from sat.tools import xml_tools
|
|
from twisted.internet import defer
|
|
from twisted.words.protocols.jabber import jid
|
|
import os
|
|
import os.path
|
|
import uuid
|
|
|
|
|
|
PLUGIN_INFO = {
|
|
"name": "File Tansfer",
|
|
"import_name": "FILE",
|
|
"type": C.PLUG_TYPE_MISC,
|
|
"main": "FilePlugin",
|
|
"handler": "no",
|
|
"description": _("""File Tansfer Management:
|
|
This plugin manage the various ways of sending a file, and choose the best one.""")
|
|
}
|
|
|
|
|
|
CONFIRM = D_(u'{peer} wants to send the file "{name}" to you:\n{desc}\n\nThe file has a size of {size_human}\n\nDo you accept ?')
|
|
CONFIRM_TITLE = D_(u'Confirm file transfer')
|
|
CONFIRM_OVERWRITE = D_(u'File {} already exists, are you sure you want to overwrite ?')
|
|
CONFIRM_OVERWRITE_TITLE = D_(u'File exists')
|
|
|
|
PROGRESS_ID_KEY = 'progress_id'
|
|
|
|
|
|
class SatFile(object):
|
|
"""A file-like object to have high level files manipulation"""
|
|
# TODO: manage "with" statement
|
|
|
|
def __init__(self, host, path, mode='rb', uid=None, size=None, data_cb=None, profile=C.PROF_KEY_NONE):
|
|
"""
|
|
@param host: %(doc_host)s
|
|
@param path(str): path of the file to get
|
|
@param mode(str): same as for built-in "open" function
|
|
@param uid(unicode, None): unique id identifing this progressing element
|
|
This uid will be used with self.host.progressGet
|
|
will be automaticaly generated if None
|
|
@param size(None, int): size of the file
|
|
@param data_cb(None, callable): method to call on each data read/write
|
|
mainly useful to do things like calculating hash
|
|
"""
|
|
self.host = host
|
|
self.uid = uid or unicode(uuid.uuid4())
|
|
self._file = open(path, mode)
|
|
self.size = size
|
|
self.data_cb = data_cb
|
|
self.profile = profile
|
|
self.host.registerProgressCb(self.uid, self.getProgress, profile)
|
|
self.host.bridge.progressStarted(self.uid, self.profile)
|
|
|
|
def close(self):
|
|
position = self._file.tell()
|
|
self._file.close()
|
|
if not self.size or self.size == position:
|
|
self.host.bridge.progressFinished(self.uid, self.profile)
|
|
else:
|
|
self.host.bridge.progressError(self.uid, u"size doesn't match", self.profile)
|
|
self.host.removeProgressCb(self.uid, self.profile)
|
|
|
|
def flush(self):
|
|
self._file.flush()
|
|
|
|
def write(self, buf):
|
|
self._file.write(buf)
|
|
if self.data_cb is not None:
|
|
return self.data_cb(buf)
|
|
|
|
def read(self, size=-1):
|
|
read = self._file.read(size)
|
|
if self.data_cb is not None and read:
|
|
self.data_cb(read)
|
|
return read
|
|
|
|
def seek(self, offset, whence=os.SEEK_SET):
|
|
self._file.seek(offset, whence)
|
|
|
|
def tell(self):
|
|
return self._file.tell()
|
|
|
|
def getProgress(self, progress_id, profile):
|
|
ret = {'position': self._file.tell()}
|
|
if self.size:
|
|
ret['size'] = self.size
|
|
return ret
|
|
|
|
|
|
class FilePlugin(object):
|
|
File=SatFile
|
|
|
|
def __init__(self, host):
|
|
log.info(_("plugin File initialization"))
|
|
self.host = host
|
|
host.bridge.addMethod("fileSend", ".plugin", in_sign='sssss', out_sign='a{ss}', method=self._fileSend, async=True)
|
|
self._file_callbacks = []
|
|
|
|
def _fileSend(self, peer_jid_s, filepath, name="", file_desc="", profile=C.PROF_KEY_NONE):
|
|
return self.fileSend(jid.JID(peer_jid_s), filepath, name or None, file_desc or None, profile)
|
|
|
|
@defer.inlineCallbacks
|
|
def fileSend(self, peer_jid, filepath, filename=None, file_desc=None, profile=C.PROF_KEY_NONE):
|
|
"""Send a file using best available method
|
|
|
|
@param peer_jid(jid.JID): jid of the destinee
|
|
@param filepath(str): absolute path to the file
|
|
@param filename(unicode, None): name to use, or None to find it from filepath
|
|
@param file_desc(unicode, None): description of the file
|
|
@param profile: %(doc_profile)s
|
|
@return (dict): action dictionary, with progress id in case of success, else xmlui message
|
|
"""
|
|
if not os.path.isfile(filepath):
|
|
raise exceptions.DataError(u"The given path doesn't link to a file")
|
|
if not filename:
|
|
filename = os.path.basename(filepath) or '_'
|
|
for namespace, callback, priority, method_name in self._file_callbacks:
|
|
has_feature = yield self.host.hasFeature(namespace, peer_jid, profile)
|
|
if has_feature:
|
|
log.info(u"{name} method will be used to send the file".format(name=method_name))
|
|
progress_id = yield defer.maybeDeferred(callback, peer_jid, filepath, filename, file_desc, profile)
|
|
defer.returnValue({'progress': progress_id})
|
|
msg = u"Can't find any method to send file to {jid}".format(jid=peer_jid.full())
|
|
log.warning(msg)
|
|
defer.returnValue({'xmlui': xml_tools.note(u"Can't transfer file", msg, C.XMLUI_DATA_LVL_WARNING).toXml()})
|
|
|
|
def register(self, namespace, callback, priority=0, method_name=None):
|
|
"""Register a fileSending method
|
|
|
|
@param namespace(unicode): XEP namespace
|
|
@param callback(callable): method to call (must have the same signature as [fileSend])
|
|
@param priority(int): pririoty of this method, the higher available will be used
|
|
@param method_name(unicode): short name for the method, namespace will be used if None
|
|
"""
|
|
for data in self._file_callbacks:
|
|
if namespace == data[0]:
|
|
raise exceptions.ConflictError(u'A method with this namespace is already registered')
|
|
self._file_callbacks.append((namespace, callback, priority, method_name or namespace))
|
|
self._file_callbacks.sort(key=lambda data: data[2], reverse=True)
|
|
|
|
def unregister(self, namespace):
|
|
for idx, data in enumerate(self._file_callbacks):
|
|
if data[0] == namespace:
|
|
del [idx]
|
|
return
|
|
raise exceptions.NotFound(u"The namespace to unregister doesn't exist")
|
|
|
|
# Dialogs with user
|
|
# the overwrite check is done here
|
|
|
|
def _openFileWrite(self, file_path, transfer_data, file_data, profile):
|
|
assert 'file_obj' not in transfer_data
|
|
transfer_data['file_obj'] = SatFile(
|
|
self.host,
|
|
file_path,
|
|
'wb',
|
|
uid=file_data[PROGRESS_ID_KEY],
|
|
size=file_data['size'],
|
|
data_cb = file_data.get('data_cb'),
|
|
profile=profile,
|
|
)
|
|
|
|
def _gotConfirmation(self, data, peer_jid, transfer_data, file_data, profile):
|
|
"""Called when the permission and dest path have been received
|
|
|
|
@param peer_jid(jid.JID): jid of the file sender
|
|
@param transfer_data(dict): same as for [self.getDestDir]
|
|
@param file_data(dict): same as for [self.getDestDir]
|
|
@param profile: %(doc_profile)s
|
|
return (bool): True if copy is wanted and OK
|
|
False if user wants to cancel
|
|
if file exists ask confirmation and call again self._getDestDir if needed
|
|
"""
|
|
if data.get('cancelled', False):
|
|
return False
|
|
path = data['path']
|
|
file_data['file_path'] = file_path = os.path.join(path, file_data['name'])
|
|
log.debug(u'destination file path set to {}'.format(file_path))
|
|
|
|
# we manage case where file already exists
|
|
if os.path.exists(file_path):
|
|
def check_overwrite(overwrite):
|
|
if overwrite:
|
|
self._openFileWrite(file_path, transfer_data, file_data, profile)
|
|
return True
|
|
else:
|
|
return self.getDestDir(peer_jid, transfer_data, file_data, profile)
|
|
|
|
exists_d = xml_tools.deferConfirm(
|
|
self.host,
|
|
_(CONFIRM_OVERWRITE).format(file_path),
|
|
_(CONFIRM_OVERWRITE_TITLE),
|
|
action_extra={'meta_from_jid': peer_jid.full(),
|
|
'meta_type': C.META_TYPE_OVERWRITE,
|
|
'meta_progress_id': file_data[PROGRESS_ID_KEY]
|
|
},
|
|
profile=profile)
|
|
exists_d.addCallback(check_overwrite)
|
|
return exists_d
|
|
|
|
self._openFileWrite(file_path, transfer_data, file_data, profile)
|
|
return True
|
|
|
|
def getDestDir(self, peer_jid, transfer_data, file_data, profile):
|
|
"""Request confirmation and destination dir to user
|
|
|
|
Overwrite confirmation is managed.
|
|
if transfer is confirmed, 'file_obj' is added to transfer_data
|
|
@param peer_jid(jid.JID): jid of the file sender
|
|
@param filename(unicode): name of the file
|
|
@param transfer_data(dict): data of the transfer session,
|
|
it will be only used to store the file_obj.
|
|
"file_obj" key *MUST NOT* exist before using getDestDir
|
|
@param file_data(dict): information about the file to be transfered
|
|
It MUST contain the following keys:
|
|
- peer_jid (jid.JID): other peer jid
|
|
- name (unicode): name of the file to trasnsfer
|
|
the name must not be empty or contain a "/" character
|
|
- size (int): size of the file
|
|
- desc (unicode): description of the file
|
|
- progress_id (unicode): id to use for progression
|
|
It *MUST NOT* contain the "peer" key
|
|
It may contain:
|
|
- data_cb (callable): method called on each data read/write
|
|
"file_path" will be added to this dict once destination selected
|
|
"size_human" will also be added with human readable file size
|
|
@param profile: %(doc_profile)s
|
|
return (defer.Deferred): True if transfer is accepted
|
|
"""
|
|
filename = file_data['name']
|
|
assert filename and not '/' in filename
|
|
assert PROGRESS_ID_KEY in file_data
|
|
# human readable size
|
|
file_data['size_human'] = u'{:.6n} Mio'.format(float(file_data['size'])/(1024**2))
|
|
d = xml_tools.deferDialog(self.host,
|
|
_(CONFIRM).format(peer=peer_jid.full(), **file_data),
|
|
_(CONFIRM_TITLE),
|
|
type_=C.XMLUI_DIALOG_FILE,
|
|
options={C.XMLUI_DATA_FILETYPE: C.XMLUI_DATA_FILETYPE_DIR},
|
|
action_extra={'meta_from_jid': peer_jid.full(),
|
|
'meta_type': C.META_TYPE_FILE,
|
|
'meta_progress_id': file_data[PROGRESS_ID_KEY]
|
|
},
|
|
profile=profile)
|
|
d.addCallback(self._gotConfirmation, peer_jid, transfer_data, file_data, profile)
|
|
return d
|