Mercurial > libervia-backend
view src/plugins/plugin_misc_file.py @ 1727:68e498b3367e
reverted revision 2ebe66a96d05
author | souliane <souliane@mailoo.org> |
---|---|
date | Tue, 08 Dec 2015 16:55:54 +0100 |
parents | 518a42587600 |
children | d17772b0fe22 |
line wrap: on
line source
#!/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.""") } SENDING = D_(u'Please select a file to send to {peer}') SENDING_TITLE = D_(u'File sending') 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') SECURITY_LIMIT = 30 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, auto_end_signals=True, 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 @param auto_end_signals(bool): if True, progressFinished and progressError signals are automatically sent if False, you'll have to call self.progressFinished and self.progressError yourself progressStarted signal is always sent automatically """ 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.auto_end_signals = auto_end_signals metadata = self.getProgressMetadata() self.host.registerProgressCb(self.uid, self.getProgress, metadata, profile=profile) self.host.bridge.progressStarted(self.uid, metadata, self.profile) def checkSize(self): """Check that current size correspond to given size must be used when the transfer is supposed to be finished @return (bool): True if the position is the same as given size @raise exceptions.NotFound: size has not be specified """ position = self._file.tell() if self.size is None: raise exceptions.NotFound return position == self.size def close(self, progress_metadata=None, error=None): """Close the current file @param progress_metadata(None, dict): metadata to send with _onProgressFinished message @param error(None, unicode): set to an error message if progress was not successful mutually exclusive with progress_metadata error can happen even if error is None, if current size differ from given size """ if self._file.closed: return # avoid double close (which is allowed) error if error is None: try: size_ok = self.checkSize() except exceptions.NotFound: size_ok = True if not size_ok: error = u'declared and actual size mismatch' log.warning(error) progress_metadata = None self._file.close() if self.auto_end_signals: if error is None: self.progressFinished(progress_metadata) else: assert progress_metadata is None self.progressError(error) self.host.removeProgressCb(self.uid, self.profile) def progressFinished(self, metadata=None): if metadata is None: metadata = {} self.host.bridge.progressFinished(self.uid, metadata, self.profile) def progressError(self, error): self.host.bridge.progressError(self.uid, error, 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 mode(self): return self._file.mode() def getProgressMetadata(self): """Return progression metadata as given to progressStarted @return (dict): metadata (check bridge for documentation) """ metadata = {'type': C.META_TYPE_FILE} mode = self._file.mode if '+' in mode: pass # we have no direction in read/write modes elif mode in ('r', 'rb'): metadata['direction'] = 'out' elif mode in ('w', 'wb'): metadata['direction'] = 'in' elif 'U' in mode: metadata['direction'] = 'out' else: raise exceptions.InternalError metadata['name'] = self._file.name return metadata 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 = [] host.importMenu((D_("Action"), D_("send file")), self._fileSendMenu, security_limit=10, help_string=D_("Send a file"), type_=C.MENU_SINGLE) 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 _onFileChoosed(self, peer_jid, data, profile): cancelled = C.bool(data.get("cancelled", C.BOOL_FALSE)) if cancelled: return path=data['path'] return self.fileSend(peer_jid, path, profile=profile) def _fileSendMenu(self, data, profile): """ XMLUI activated by menu: return file sending UI @param profile: %(doc_profile)s """ try: jid_ = jid.JID(data['jid']) except RuntimeError: raise exceptions.DataError(_("Invalid JID")) file_choosed_id = self.host.registerCallback(lambda data, profile: self._onFileChoosed(jid_, data, profile), with_data=True, one_shot=True) xml_ui = xml_tools.XMLUI( C.XMLUI_DIALOG, dialog_opt = { C.XMLUI_DATA_TYPE: C.XMLUI_DIALOG_FILE, C.XMLUI_DATA_MESS: _(SENDING).format(peer=jid_.full())}, title = _(SENDING_TITLE), submit_id = file_choosed_id) return {'xmlui': xml_ui.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] }, security_limit=SECURITY_LIMIT, 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] }, security_limit=SECURITY_LIMIT, profile=profile) d.addCallback(self._gotConfirmation, peer_jid, transfer_data, file_data, profile) return d