def _get_crypto_info(self):
self._lookup_recipients()
self.crypto = FileUpdateCrypto(
self.gpg, self.src_path, self.escaped_recipients)
self.crypto.hash_file_path()
class LocalFileShepherd(threading.Thread):
def __init__(self, mediator, gpg, blob_store, metadata_store):
threading.Thread.__init__(self)
self.mediator = mediator
self.gpg = gpg
self.blob_store = blob_store
self.metadata_store = metadata_store
self.state = SHEPHERD_STATE_READY
def shutdown(self):
# TODO(tierney): Call the MultiPartUpload cancel.
logging.info('Shutdown not fully implemented.')
self.state = SHEPHERD_STATE_SHUTDOWN
def _lookup_previous(self):
logging.info('Looking up local view of previous (%s).' %
self.crypto.hash_of_file_path)
self.previous = self.metadata_store.local_view_of_previous(
self.crypto.hash_of_file_path)
logging.info('Previous set to (%s).' % self.previous)
def _lookup_recipients(self):
logging.warning('_lookup_recipients not implemented yet.')
logging.warning('Must escape recipients.')
self.escaped_recipients = ['\"Matt Tierney\"']
def _get_crypto_info(self):
self._lookup_recipients()
self.crypto = FileUpdateCrypto(
self.gpg, self.src_path, self.escaped_recipients)
self.crypto.hash_file_path()
def _run_encryption(self):
self.crypto.run()
self.metadata_store.set_signature(self.crypto.hash_of_encrypted_blob,
self.crypto.ascii_signature)
def _update_cloud_file(self):
"""Should already have set self.crypto."""
self.updater = UpdateCloudFile(self.blob_store, self.metadata_store,
self.crypto, self.previous)
logging.info('Sending metadata.')
if not self.updater.update_metadata():
logging.warning('Could not update the metadata.')
return False
logging.info('Updated metadata.')
logging.info('Sending blobdata.')
if self.event_type == EVENT_TYPE_CREATED:
self.updater.update_path()
self.updater.update_blob()
logging.info('Updated blobdata.')
def assign(self, status_id, timestamp, state, event_type, src_path,
dest_path):
self.state = SHEPHERD_STATE_ASSIGNED
self.status_id = status_id
self.timestamp = timestamp
self.state = state
self.event_type = event_type
self.src_path = src_path
self.dest_path = dest_path
self.state = _SHEPHERD_STATE_ASSIGNED_AND_READY
def get_state(self):
return self.state
def _clear(self):
del self.status_id, self.timestamp, self.state, self.event_type, \
self.src_path, self.dest_path, self.crypto, self.previous
def _modified(self):
# Look up the signature of the previous whole file (from the src_path index?)
logging.info('Getting local view of previous.')
latest = self.metadata_store.local_view_of_previous(
hash_string(self.src_path))
if not latest:
logging.error('Have not seen this file before (%s), yet '
'we are shepherding a modification.' % self.src_path)
return False
logging.info('Getting signature of hash_of_blob (%s).' % latest)
latest_signature = self.metadata_store.lookup_signature(latest)
if not latest_signature:
logging.error('We do not have the latest signature.')
return False
logging.info('Computing the delta.')
# compute_cleartext_delta(prev_sig, latest_filename)
delta_file_name = self.crypto.compute_cleartext_delta(
latest_signature, self.src_path)
logging.info('Updating crypto file path to delta file (%s).' %
delta_file_name)
logging.info('Encrypting.')
# encrypt delta (get back the hash_of_encrypted_blob)
self.crypto.rsync_signature()
self.crypto.encrypt_delta_file()
# Locally store: hash(gpg(delta)) -> signature(file)
logging.info('Setting new signature (%s) : (%s).' %
(self.crypto.hash_of_encrypted_blob,
self.crypto.ascii_signature))
self.metadata_store.set_signature(self.crypto.hash_of_encrypted_blob,
self.crypto.ascii_signature)
def run(self):
while self.state is not SHEPHERD_STATE_SHUTDOWN:
if self.state is SHEPHERD_STATE_READY:
time.sleep(1)
continue
if self.state is _SHEPHERD_STATE_ASSIGNED_AND_READY:
logging.info('Got event (%d, %f, %s, %s, %s, %s).'
% (self.status_id, self.timestamp, self.state,
self.event_type, self.src_path, self.dest_path))
logging.info('Time to encrypt.')
self.mediator.update(self.status_id, STATUS_ENCRYPTING)
self.state = SHEPHERD_STATE_ENCRYPTING
if self.state is SHEPHERD_STATE_ENCRYPTING:
logging.info('Encrypting.')
self._get_crypto_info()
self._lookup_previous()
if self.event_type == EVENT_TYPE_CREATED:
self._run_encryption()
elif self.event_type == EVENT_TYPE_MODIFIED:
logging.warning('EVENT_TYPE_MODIFIED encryption not implemented yet.')
self._modified()
logging.info('Finished encrypting.')
self.mediator.update(self.status_id, STATUS_UPLOADING)
self.state = SHEPHERD_STATE_UPLOADING
if self.state is SHEPHERD_STATE_UPLOADING:
logging.info('Uploading.')
try:
self._update_cloud_file()
except VersioningError:
logging.error('Got a VersioningError so did not upload (%s).' %
self.src_path)
logging.info('Done.')
self.mediator.update(self.status_id, STATUS_COMPLETED)
self.mediator.done(self.src_path, self.ident)
self._clear()
self.state = SHEPHERD_STATE_READY