name = 'magic-folder'
def __init__(self, client, upload_dircap, collective_dircap, local_path_u, dbfile,
- pending_delay=1.0, clock=reactor):
+ pending_delay=1.0, clock=None):
precondition_abspath(local_path_u)
service.MultiService.__init__(self)
+ immediate = clock is not None
+ clock = clock or reactor
db = magicfolderdb.get_magicfolderdb(dbfile, create_version=(magicfolderdb.SCHEMA_v1, 1))
if db is None:
return Failure(Exception('ERROR: Unable to load magic folder db.'))
upload_dirnode = self._client.create_node_from_uri(upload_dircap)
collective_dirnode = self._client.create_node_from_uri(collective_dircap)
- self.uploader = Uploader(client, local_path_u, db, upload_dirnode, pending_delay, clock)
+ self.uploader = Uploader(client, local_path_u, db, upload_dirnode, pending_delay, clock, immediate)
self.downloader = Downloader(client, local_path_u, db, collective_dirnode, upload_dirnode.get_readonly_uri(), clock)
def startService(self):
print s
#open("events", "ab+").write(msg)
- def _append_to_deque(self, relpath_u):
- self._log("_append_to_deque(%r)" % (relpath_u,))
- if relpath_u in self._pending or magicpath.should_ignore_file(relpath_u):
- return
- self._deque.append(relpath_u)
- self._pending.add(relpath_u)
- self._count('objects_queued')
- if self.is_ready:
- self._clock.callLater(0, self._turn_deque)
-
def _turn_deque(self):
self._log("_turn_deque")
if self._stopped:
class Uploader(QueueMixin):
- def __init__(self, client, local_path_u, db, upload_dirnode, pending_delay, clock):
+ def __init__(self, client, local_path_u, db, upload_dirnode, pending_delay, clock,
+ immediate=False):
QueueMixin.__init__(self, client, local_path_u, db, 'uploader', clock)
self.is_ready = False
+ self._immediate = immediate
if not IDirectoryNode.providedBy(upload_dirnode):
raise AssertionError("The URI in '%s' does not refer to a directory."
if hasattr(self._notifier, 'set_pending_delay'):
self._notifier.set_pending_delay(pending_delay)
- # TODO: what about IN_MOVE_SELF, IN_MOVED_FROM, or IN_UNMOUNT?
+ # TODO: what about IN_MOVE_SELF and IN_UNMOUNT?
#
self.mask = ( self._inotify.IN_CREATE
| self._inotify.IN_CLOSE_WRITE
def _notify(self, opaque, path, events_mask):
self._log("inotify event %r, %r, %r\n" % (opaque, path, ', '.join(self._inotify.humanReadableMask(events_mask))))
+ relpath_u = self._get_relpath(path)
# We filter out IN_CREATE events not associated with a directory.
# Acting on IN_CREATE for files could cause us to read and upload
if ((events_mask & self._inotify.IN_CREATE) != 0 and
(events_mask & self._inotify.IN_ISDIR) == 0):
- self._log("ignoring inotify event for creation of file %r\n" % (path,))
+ self._log("ignoring event for %r (creation of non-directory)\n" % (relpath_u,))
+ return
+ if relpath_u in self._pending:
+ self._log("ignoring event for %r (already pending)" % (relpath_u,))
+ return
+ if magicpath.should_ignore_file(relpath_u):
+ self._log("ignoring event for %r (ignorable path)" % (relpath_u,))
return
- relpath_u = self._get_relpath(path)
- self._append_to_deque(relpath_u)
+ self._log("appending %r to deque" % (relpath_u,))
+ self._deque.append(relpath_u)
+ self._pending.add(relpath_u)
+ self._count('objects_queued')
+ if self.is_ready:
+ if self._immediate: # for tests
+ self._turn_deque()
+ else:
+ self._clock.callLater(0, self._turn_deque)
def _when_queue_is_empty(self):
return defer.succeed(None)
def _process(self, relpath_u):
+ # Uploader
self._log("_process(%r)" % (relpath_u,))
if relpath_u is None:
return
fp = self._get_filepath(relpath_u)
pathinfo = get_pathinfo(unicode_from_filepath(fp))
- self._log("pending = %r, about to remove %r" % (self._pending, relpath_u))
+ self._log("about to remove %r from pending set %r" %
+ (relpath_u, self._pending))
self._pending.remove(relpath_u)
encoded_path_u = magicpath.path2magic(relpath_u)
self._upload_readonly_dircap = upload_readonly_dircap
self._turn_delay = self.REMOTE_SCAN_INTERVAL
- self._download_scan_batch = {} # path -> [(filenode, metadata)]
def start_scanning(self):
self._log("start_scanning")
collective_dirmap_d.addCallback(highest_version)
return collective_dirmap_d
- def _append_to_batch(self, name, file_node, metadata):
- if self._download_scan_batch.has_key(name):
- self._download_scan_batch[name] += [(file_node, metadata)]
- else:
- self._download_scan_batch[name] = [(file_node, metadata)]
-
- def _scan_remote(self, nickname, dirnode):
- self._log("_scan_remote nickname %r" % (nickname,))
+ def _scan_remote_dmd(self, nickname, dirnode, scan_batch):
+ self._log("_scan_remote_dmd nickname %r" % (nickname,))
d = dirnode.list()
def scan_listing(listing_map):
for encoded_relpath_u in listing_map.keys():
local_version = self._get_local_latest(relpath_u)
remote_version = metadata.get('version', None)
self._log("%r has local version %r, remote version %r" % (relpath_u, local_version, remote_version))
+
if local_version is None or remote_version is None or local_version < remote_version:
self._log("%r added to download queue" % (relpath_u,))
- self._append_to_batch(relpath_u, file_node, metadata)
+ if scan_batch.has_key(relpath_u):
+ scan_batch[relpath_u] += [(file_node, metadata)]
+ else:
+ scan_batch[relpath_u] = [(file_node, metadata)]
+
d.addCallback(scan_listing)
- d.addBoth(self._logcb, "end of _scan_remote")
+ d.addBoth(self._logcb, "end of _scan_remote_dmd")
return d
def _scan_remote_collective(self):
self._log("_scan_remote_collective")
- self._download_scan_batch = {} # XXX
+ scan_batch = {} # path -> [(filenode, metadata)]
d = self._collective_dirnode.list()
def scan_collective(dirmap):
for dir_name in dirmap:
(dirnode, metadata) = dirmap[dir_name]
if dirnode.get_readonly_uri() != self._upload_readonly_dircap:
- d2.addCallback(lambda ign, dir_name=dir_name: self._scan_remote(dir_name, dirnode))
- def _err(f):
+ d2.addCallback(lambda ign, dir_name=dir_name, dirnode=dirnode:
+ self._scan_remote_dmd(dir_name, dirnode, scan_batch))
+ def _err(f, dir_name=dir_name):
self._log("failed to scan DMD for client %r: %s" % (dir_name, f))
# XXX what should we do to make this failure more visible to users?
d2.addErrback(_err)
+
return d2
d.addCallback(scan_collective)
- d.addCallback(self._filter_scan_batch)
- d.addCallback(self._add_batch_to_download_queue)
- return d
- def _add_batch_to_download_queue(self, result):
- self._log("result = %r" % (result,))
- self._log("deque = %r" % (self._deque,))
- self._deque.extend(result)
- self._log("deque after = %r" % (self._deque,))
- self._count('objects_queued', len(result))
-
- def _filter_scan_batch(self, result):
- self._log("_filter_scan_batch")
- extension = [] # consider whether this should be a dict
- for relpath_u in self._download_scan_batch.keys():
- if relpath_u in self._pending:
- continue
- file_node, metadata = max(self._download_scan_batch[relpath_u], key=lambda x: x[1]['version'])
- if self._should_download(relpath_u, metadata['version']):
- extension += [(relpath_u, file_node, metadata)]
- else:
- self._log("Excluding %r" % (relpath_u,))
- self._count('objects_excluded')
- self._call_hook(None, 'processed')
- return extension
+ def _filter_batch_to_deque(ign):
+ self._log("deque = %r, scan_batch = %r" % (self._deque, scan_batch))
+ for relpath_u in scan_batch.keys():
+ file_node, metadata = max(scan_batch[relpath_u], key=lambda x: x[1]['version'])
+
+ if self._should_download(relpath_u, metadata['version']):
+ self._deque.append( (relpath_u, file_node, metadata) )
+ else:
+ self._log("Excluding %r" % (relpath_u,))
+ self._count('objects_excluded')
+ self._call_hook(None, 'processed')
+
+ self._log("deque after = %r" % (self._deque,))
+ d.addCallback(_filter_batch_to_deque)
+ return d
def _when_queue_is_empty(self):
d = task.deferLater(self._clock, self._turn_delay, self._scan_remote_collective)
return d
def _process(self, item, now=None):
+ # Downloader
self._log("_process(%r)" % (item,))
if now is None:
now = time.time()
fp = self._get_filepath(relpath_u)
abspath_u = unicode_from_filepath(fp)
conflict_path_u = self._get_conflicted_filename(abspath_u)
+
d = defer.succeed(None)
def do_update_db(written_abspath_u):
if dmd_last_downloaded_uri != local_last_downloaded_uri:
is_conflict = True
self._count('objects_conflicted')
-
- #dmd_last_uploaded_uri = metadata.get('last_uploaded_uri', None)
- #local_last_uploaded_uri = ...
-
+ else:
+ dmd_last_uploaded_uri = metadata.get('last_uploaded_uri', None)
+ local_last_uploaded_uri = self._db.get_last_uploaded_uri(relpath_u)
+ print ">>>> if %r != %r" % (dmd_last_uploaded_uri, local_last_uploaded_uri)
+ if dmd_last_uploaded_uri != local_last_uploaded_uri:
+ is_conflict = True
+ self._count('objects_conflicted')
if relpath_u.endswith(u"/"):
if metadata.get('deleted', False):
self._log("rmdir(%r) ignored" % (abspath_u,))