Removed unused class MediaSyncer

src/ankisyncd/sync.py

@@ -669,148 +669,6 @@ class FullSyncer(HttpSyncer):
             return False
         return True
 
-# Media syncing
-##########################################################################
-#
-# About conflicts:
-# - to minimize data loss, if both sides are marked for sending and one
-#   side has been deleted, favour the add
-# - if added/changed on both sides, favour the server version on the
-#   assumption other syncers are in sync with the server
-#
-
-class MediaSyncer(object):
-    def __init__(self, col, server=None):
-        self.col = col
-        self.server = server
-
-    def sync(self):
-        # check if there have been any changes
-        runHook("sync", "findMedia")
-        self.col.log("findChanges")
-        try:
-            self.col.media.findChanges()
-        except DBError:
-            return "corruptMediaDB"
-
-        # begin session and check if in sync
-        lastUsn = self.col.media.lastUsn()
-        ret = self.server.begin()
-        srvUsn = ret['usn']
-        if lastUsn == srvUsn:
-            return "noChanges"
-
-        # loop through and process changes from server
-        self.col.log("last local usn is %s"%lastUsn)
-        self.downloadCount = 0
-        while True:
-            data = self.server.mediaChanges(lastUsn=lastUsn)
-
-            self.col.log("mediaChanges resp count %d"%len(data))
-            if not data:
-                break
-
-            need = []
-            lastUsn = data[-1][1]
-            for fname, rusn, rsum in data:
-                lsum, ldirty = self.col.media.syncInfo(fname)
-                self.col.log(
-                    "check: lsum=%s rsum=%s ldirty=%d rusn=%d fname=%s"%(
-                        (lsum and lsum[0:4]),
-                        (rsum and rsum[0:4]),
-                        ldirty,
-                        rusn,
-                        fname))
-
-                if rsum:
-                    # added/changed remotely
-                    if not lsum or lsum != rsum:
-                        self.col.log("will fetch")
-                        need.append(fname)
-                    else:
-                        self.col.log("have same already")
-                    if ldirty:
-                        self.col.media.markClean([fname])
-                elif lsum:
-                    # deleted remotely
-                    if not ldirty:
-                        self.col.log("delete local")
-                        self.col.media.syncDelete(fname)
-                    else:
-                        # conflict; local add overrides remote delete
-                        self.col.log("conflict; will send")
-                else:
-                    # deleted both sides
-                    self.col.log("both sides deleted")
-                    if ldirty:
-                        self.col.media.markClean([fname])
-
-            self._downloadFiles(need)
-
-            self.col.log("update last usn to %d"%lastUsn)
-            self.col.media.setLastUsn(lastUsn) # commits
-
-        # at this point we're all up to date with the server's changes,
-        # and we need to send our own
-
-        updateConflict = False
-        toSend = self.col.media.dirtyCount()
-        while True:
-            zip, fnames = self.col.media.mediaChangesZip()
-            if not fnames:
-                break
-
-            runHook("syncMsg", ngettext(
-                "%d media change to upload", "%d media changes to upload", toSend)
-                    % toSend)
-
-            processedCnt, serverLastUsn = self.server.uploadChanges(zip)
-            self.col.media.markClean(fnames[0:processedCnt])
-
-            self.col.log("processed %d, serverUsn %d, clientUsn %d" % (
-                processedCnt, serverLastUsn, lastUsn
-            ))
-
-            if serverLastUsn - processedCnt == lastUsn:
-                self.col.log("lastUsn in sync, updating local")
-                lastUsn = serverLastUsn
-                self.col.media.setLastUsn(serverLastUsn) # commits
-            else:
-                self.col.log("concurrent update, skipping usn update")
-                # commit for markClean
-                self.col.media.db.commit()
-                updateConflict = True
-
-            toSend -= processedCnt
-
-        if updateConflict:
-            self.col.log("restart sync due to concurrent update")
-            return self.sync()
-
-        lcnt = self.col.media.mediaCount()
-        ret = self.server.mediaSanity(local=lcnt)
-        if ret == "OK":
-            return "OK"
-        else:
-            self.col.media.forceResync()
-            return ret
-
-    def _downloadFiles(self, fnames):
-        self.col.log("%d files to fetch"%len(fnames))
-        while fnames:
-            top = fnames[0:SYNC_ZIP_COUNT]
-            self.col.log("fetch %s"%top)
-            zipData = self.server.downloadFiles(files=top)
-            cnt = self.col.media.addFilesFromZip(zipData)
-            self.downloadCount += cnt
-            self.col.log("received %d files"%cnt)
-            fnames = fnames[cnt:]
-
-            n = self.downloadCount
-            runHook("syncMsg", ngettext(
-                "%d media file downloaded", "%d media files downloaded", n)
-                    % n)
-
 # Remote media syncing
 ##########################################################################