def file_download_start_v1(self, request):
data = _request_data(request, mandatory_keys=['remote_path', ])
return api.file_download_start(
remote_path=data['remote_path'],
destination_path=data.get('destination_folder', None),
wait_result=bool(data.get('wait_result', '0') in ['1', 'true', ]),
open_share=bool(data.get('open_share', '1') in ['1', 'true', ]), )
def ftp_RETR(self, path):
if self.dtpInstance is None:
raise BadCmdSequenceError('PORT or PASV required before RETR')
try:
newsegs = toSegments(self.workingDirectory, path)
except InvalidPath:
return defer.fail(FileNotFoundError(path))
# XXX For now, just disable the timeout. Later we'll want to
# leave it active and have the DTP connection reset it
# periodically.
self.setTimeout(None)
# Put it back later
# And away she goes
if not self.binary:
consumer = ASCIIConsumerWrapper(self.dtpInstance)
else:
consumer = self.dtpInstance
pth = '/'.join(newsegs)
restore_dir = tmpfile.make_dir('restore', prefix=('_'.join(newsegs) + '_'))
ret = api.file_download_start(pth, restore_dir, wait_result=True)
d = Deferred()
d.addCallback(self._cbReadOpened, consumer)
d.addErrback(self._ebReadOpened, newsegs)
d.addBoth(self._enableTimeoutLater)
if isinstance(ret, dict):
# if ret['status'] != 'OK':
# return defer.fail(FileNotFoundError(path))
self._cbRestoreDone(ret, newsegs, d)
return d
ret.addCallback(self._cbRestoreDone, newsegs, d)
ret.addErrback(lambda err: lg.exc(err))
return d
def do_restore_key(key_id, is_private, keys_folder=None, wait_result=False):
"""
Restore given key from my suppliers if I do not have it locally.
"""
if _Debug:
lg.out(_DebugLevel, 'key_ring.do_restore_key key_id=%r is_private=%r' % (key_id, is_private, ))
if my_keys.is_key_registered(key_id):
lg.err('local key already exist: "%s"' % key_id)
if wait_result:
return fail(Exception('local key already exist: "%s"' % key_id))
return False
if not keys_folder:
keys_folder = settings.KeyStoreDir()
if is_private:
remote_path_for_key = '.keys/%s.private' % key_id
else:
remote_path_for_key = '.keys/%s.public' % key_id
global_key_path = global_id.MakeGlobalID(
key_alias='master', customer=my_id.getGlobalID(), path=remote_path_for_key)
ret = api.file_download_start(
remote_path=global_key_path,
destination_path=keys_folder,
wait_result=True,
open_share=False,
)
if not isinstance(ret, Deferred):
lg.err('failed to download key "%s": %s' % (key_id, ret))
if wait_result:
return fail(Exception('failed to download key "%s": %s' % (key_id, ret)))
return False
result = Deferred()
def _on_result(res):
if not isinstance(res, dict):
lg.err('failed to download key "%s": %s' % (key_id, res))
if wait_result:
result.errback(Exception('failed to download key "%s": %s' % (key_id, res)))
return None
if res['status'] != 'OK':
lg.err('failed to download key "%s": %r' % (key_id, res))
if wait_result:
result.errback(Exception('failed to download key "%s": %r' % (key_id, res)))
return None
if not my_keys.load_key(key_id, keys_folder):
lg.err('failed to read key "%s" from local folder "%s"' % (key_id, keys_folder))
if wait_result:
result.errback(Exception('failed to read key "%s" from local folder "%s"' % (key_id, keys_folder)))
return None
if _Debug:
lg.out(_DebugLevel, 'key_ring.do_restore_key._on_result key_id=%s is_private=%r : %r' % (key_id, is_private, res))
if wait_result:
result.callback(res)
return None
ret.addBoth(_on_result)
if not wait_result:
return True
return result
def jsonrpc_file_download_start(self,
remote_path,
destination_path=None,
wait_result=False,
open_share=True):
return api.file_download_start(remote_path,
destination_path=destination_path,
wait_result=wait_result,
open_share=open_share)
def jsonrpc_file_download_start(self, remote_path, destination_path=None):
return api.file_download_start(remote_path, destination_path=destination_path)
