Beispiel #1
0
		public ManifestTracker (Engine engine, string path) {
			this.path = path;

			if (!File.Exists (path)) {
				Manifest = new SyncManifest ();
				using (var output = new FileStream (path, FileMode.Create)) {
					SyncManifest.Write (Manifest, output);
				}
				foreach (Note note in engine.GetNotes ().Values) {
					Manifest.NoteRevisions [note.Guid] = Manifest.LastSyncRevision + 1;
				}
				Flush ();
			}

			using (var input = new FileStream (path, FileMode.Open)) {
				this.Manifest = SyncManifest.Read (input);
                		input.Close();
			}
			engine.NoteAdded += (Note note) => {
				Console.WriteLine ("Note added");
				Manifest.NoteRevisions [note.Guid] = Manifest.LastSyncRevision + 1;
			};

			engine.NoteUpdated += (Note note) => {
				Console.WriteLine ("Note updated");
				Manifest.NoteRevisions [note.Guid] = Manifest.LastSyncRevision + 1;
			};

			engine.NoteRemoved += (Note note) => {
				Console.WriteLine ("Note removed: " + note.Guid);
				Manifest.NoteDeletions.Add (note.Guid, note.Title);
			};
		}
        /// <summary>
        /// Will create a new sync client using a custom IStorage as data backend.
        /// When using different IStorage backend, multiple instances of ISyncClient
        /// are allowed to exist simultaneously.
        /// </summary>
        public FilesystemSyncClient(Engine engine, SyncManifest manifest)
        {
            this.manifest = manifest;
            this.Engine = engine;

            this.DeletedNotes = new List<Note> ();
        }
Beispiel #3
0
        public AppDelegate()
        {
            // TODO, set it in a generic way
            Tomboy.DiskStorage.Instance.SetPath ("/Users/jeremie/projects/MacBoy/test-notes");
            NoteEngine = new Engine (Tomboy.DiskStorage.Instance);
            Notes = NoteEngine.GetNotes ();

            // Create our cache directory
            if (!Directory.Exists (BaseUrlPath))
                Directory.CreateDirectory (BaseUrlPath);
        }
        public void SetUp()
        {
            var current_dir = Directory.GetCurrentDirectory ();
            serverStorageDir = Path.Combine (current_dir, "../../syncserver/");

            serverStorage = new DiskStorage (serverStorageDir);

            serverEngine = new Engine (serverStorage);

            manifest = new SyncManifest ();
            syncServer = new FilesystemSyncServer (serverEngine, manifest);

            CreateSomeSampleNotes ();
        }
        public FilesystemSyncServer(Engine engine, SyncManifest manifest)
        {
            this.engine = engine;
            this.manifest = manifest;

            // if not server id is set, set a new one
            if (string.IsNullOrEmpty (this.Id)) {
                this.Id = Guid.NewGuid ().ToString ();
            }
            newRevision = this.LatestRevision + 1;

            this.UploadedNotes = new List<Note> ();
            this.DeletedServerNotes = new List<string> ();
        }
        public DatabaseNoteRepository(IDbConnectionFactory factory, DbStorageFactory storageFactory, IUser user)
            : base(factory)
        {
            this.storage = storageFactory.GetDbStorage (user);
            engine = new Engine (storage);

            using (var db = connFactory.OpenDbConnection ()) {
                this.dbUser = db.Select<DBUser> (u => u.Username == user.Username)[0];
            }

            if (dbUser.Manifest == null || string.IsNullOrEmpty (dbUser.Manifest.ServerId)) {
                // the user may not yet have synced
                dbUser.Manifest.ServerId = Guid.NewGuid ().ToString ();
            }
        }
Beispiel #7
0
        public void BenchmarkNoteStorage()
        {
            var local_storage = new DiskStorage ("../../tmpstorage");
            var sample_notes = TestBase.GetSampleNotes ();
            var manifest = new SyncManifest ();
            var engine = new Engine (local_storage);
            sample_notes.ForEach(n => engine.SaveNote (n));

            var sync_client = new FilesystemSyncClient (engine, manifest);
            var access_token = WebSyncServer.PerformFastTokenExchange (listenUrl, "testuser", "testpass");
            var sync_server = new WebSyncServer (listenUrl, access_token);

            Action benchmark = () => new SyncManager (sync_client, sync_server).DoSync ();
            DbBenchmarks.RunBenchmark ("initial sync with 100 times no change at all", benchmark, 100);
        }
Beispiel #8
0
        public override void SetUp()
        {
            base.SetUp ();
            DTOUser user;
            List<DTONote> sample_notes;
            JsonServiceClient client = GetAdminServiceClient ();

            user = new DTOUser() {
                Username = "******",
                Password = "******",
                AdditionalData = "Its just john"
            };
            var user_url = new Rainy.WebService.Management.UserRequest ().ToUrl("POST");
            client.Post<DTOUser> (user_url, user);
            sampleUser.Add (user);

            // add sample notes
            sample_notes = AbstractSyncServerTests.GetSomeSampleNotes ()
                .Select (n => n.ToDTONote ()).ToList ();

            var syncServer = new WebSyncServer (testServer.RainyListenUrl, testServer.GetAccessToken ());

            var storage = new DiskStorage ();
            var tmpPath = "/tmp/sync1";
            storage.SetPath (tmpPath);
            var engine = new Engine (storage);
            var syncClient = new FilesystemSyncClient (engine, new SyncManifest ());

            var syncManager = new Tomboy.Sync.SyncManager (syncClient, syncServer);
            syncManager.DoSync ();

            sampleNotes[user.Username] = sample_notes;

            user = new DTOUser() {
                Username = "******",
                Password = "******",
                AdditionalData = "Jane, Johns wife"
            };
            client.Post<DTOUser> (user_url, user);
            sampleUser.Add (user);
            sampleNotes[user.Username] = AbstractSyncServerTests.GetSomeSampleNotes ()
                .Select (n => n.ToDTONote ()).ToList ();

            // add sample user data
        }
Beispiel #9
0
        private static void ProcessDirectory(string targetDirectory, Engine appEngine)
        {
            DiskStorage noteStorage = new DiskStorage (targetDirectory);
            Engine noteEngine = new Engine (noteStorage);
            Dictionary<string,Note> notes = new Dictionary<string,Note>();

            try {
                notes = noteEngine.GetNotes ();
            } catch (ArgumentException) {
                Console.WriteLine ("Found an exception with {0}",targetDirectory);
            }

            foreach (Note note in notes.Values) {

                Note newNote = appEngine.NewNote ();
                newNote.ChangeDate = note.ChangeDate;
                newNote.CreateDate = note.CreateDate;
                newNote.CursorPosition = note.CursorPosition;
                newNote.Height = note.Height;
                newNote.MetadataChangeDate = note.MetadataChangeDate;
                newNote.Notebook = note.Notebook;
                newNote.OpenOnStartup = note.OpenOnStartup;
                newNote.SelectionBoundPosition = note.SelectionBoundPosition;
                newNote.Tags = note.Tags;
                newNote.Text = note.Text;
                newNote.Title = note.Title;
                newNote.Width = note.Width;
                newNote.X = note.X;
                newNote.Y = note.Y;
                appEngine.SaveNote (newNote, false);

                Console.WriteLine ("Imported the Note {0}",newNote.Title);
            }

            string [] subdirectoryEntries = System.IO.Directory.GetDirectories(targetDirectory);
            foreach(string subdirectory in subdirectoryEntries)
                ProcessDirectory(subdirectory, appEngine);
        }
Beispiel #10
0
		/// <summary>
		/// Initializes a new instance of the <see cref="Tomboy.AppDelegate"/> class.
		/// </summary>
		public AppDelegate () {
			var storage_path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library", "Application Support", "Tomboy");
            		// TODO, set it in a generic way
            		noteStorage = new DiskStorage (storage_path);
            		noteStorage.SetBackupPath(backupPathUri);

            		if (!Directory.Exists(backupPathUri))
                		noteStorage.Backup(); //FIXME: Need to better handle status messages.

			Logger.Debug ("Backup Path set to {0}", backupPathUri);

			NoteEngine = new Engine (noteStorage);

			// keep track of note for syncing
			// TODO move this into an Add-in one day
			var manifest_path = Path.Combine (storage_path, "manifest.xml");
			manifestTracker = new ManifestTracker (NoteEngine, manifest_path);

			// Create our cache directory
			if (!Directory.Exists (BaseUrlPath))
				Directory.CreateDirectory (BaseUrlPath);

			// Currently lazy load because otherwise the Dock Menu throws an error about there being no notes.
			if (Notes == null)
				Notes = NoteEngine.GetNotes ();
			
			NoteEngine.NoteAdded += HandleNoteAdded;
			NoteEngine.NoteRemoved += HandleNoteRemoved;
			NoteEngine.NoteUpdated += HandleNoteUpdated;

			settings = SettingsSync.Read();

            		Notebooks = new List<string>();
            		currentNotebook = "All Notebooks";
            		PopulateNotebookList();
		}
Beispiel #11
0
		/// <summary>
		/// Syncs the notes.
		/// </summary>
		/// <param name="sender">Sender.</param>
		partial void SyncNotes(NSObject sender) {
			var dest_manifest_path = Path.Combine (settings.syncURL, "manifest.xml");
			SyncManifest dest_manifest;
			if (!File.Exists (dest_manifest_path)) {
				using (var output = new FileStream (dest_manifest_path, FileMode.Create)) {
					SyncManifest.Write (new SyncManifest (), output);
				}
			}
			using (var input = new FileStream (dest_manifest_path, FileMode.Open)) {
				dest_manifest = SyncManifest.Read (input);
			}
			var dest_storage = new DiskStorage (settings.syncURL);
			var dest_engine = new Engine (dest_storage);

			var client = new FilesystemSyncClient (NoteEngine, manifestTracker.Manifest);
			var server = new FilesystemSyncServer (dest_engine, dest_manifest);
			var sync_manager = new SyncManager(client, server);
			sync_manager.DoSync ();
			RefreshNotesWindowController();
			// write back the dest manifest
		        using (var output = new FileStream (dest_manifest_path, FileMode.Create)) {
				SyncManifest.Write (dest_manifest, output);
			}

        	}
Beispiel #12
0
        public void Init()
        {
            IPortableIoC container = new PortableIoc ();
            container.Register<DiskStorage> (c => {
                return new DiskStorage ("../../test_notes/proper_notes") {
                    Logger = new ConsoleLogger ()
                };
            });
            diskStorage = container.Resolve<DiskStorage> ();

            engine = new Engine (diskStorage);
            // get a new note instance
            note = engine.NewNote ();
            note.Title = "Unit Test Note";
            note.Text = "Unit test note by NewNote() method";
            engine.SaveNote (note);
            NOTE_PATH = Path.Combine ("../../test_notes/proper_notes", Utils.GetNoteFileNameFromURI (note));
        }
Beispiel #13
0
 public void Init()
 {
     IStorage storage = new DiskStorage ("../../test_notes/proper_notes");
     engine = new Engine (storage);
 }
Beispiel #14
0
        public DatabaseNoteRepository(string username)
        {
            dbConnection = DbConfig.GetConnection ();
            dbUser = dbConnection.First<DBUser> (u => u.Username == username);

            storage = new DbStorage (dbUser);
            engine = new Engine (storage);

            if (dbUser.Manifest == null || string.IsNullOrEmpty (dbUser.Manifest.ServerId)) {
                // the user may not yet have synced
                dbUser.Manifest.ServerId = Guid.NewGuid ().ToString ();
            }
        }
 protected override void ClearServer(bool reset = false)
 {
     if (reset) {
         serverManifest = new SyncManifest ();
         CleanupServerDirectory ();
     }
     serverStorage = new DiskStorage ();
     serverStorage.SetPath (serverStorageDir);
     serverEngine = new Engine (serverStorage);
     syncServer = new FilesystemSyncServer (serverEngine, serverManifest);
 }
Beispiel #16
0
        public DatabaseNoteRepository(string username)
        {
            username = username;

            dbConnection = DbConfig.GetConnection ();
            storage = new DbStorage (username);
            engine = new Engine (storage);

            var db_user = dbConnection.Select <DBUser> ("Username = {0}", username);
            if (db_user.Count == 0) {
                dbUser = new DBUser () { Username = username };
            }
            else
                dbUser = db_user[0];

            if (dbUser.Manifest == null || string.IsNullOrEmpty (dbUser.Manifest.ServerId)) {
                // the user may not yet have synced
                dbUser.Manifest = new SyncManifest ();
                dbUser.Manifest.ServerId = Guid.NewGuid ().ToString ();
            }
        }
Beispiel #17
0
		/// <summary>
		/// Syncs the notes.
		/// </summary>
		/// <param name="sender">Sender.</param>
		partial void SyncNotes(NSObject sender) {

			bool success = false;

			if (!String.IsNullOrEmpty (settings.syncURL) || !String.IsNullOrWhiteSpace (settings.syncURL)) {

				var dest_manifest_path = Path.Combine (settings.syncURL, "manifest.xml");
				SyncManifest dest_manifest;
				if (!File.Exists (dest_manifest_path)) {
					using (var output = new FileStream (dest_manifest_path, FileMode.Create)) {
						SyncManifest.Write (new SyncManifest (), output);
					}
				}
				using (var input = new FileStream (dest_manifest_path, FileMode.Open)) {
					dest_manifest = SyncManifest.Read (input);
				}
				var dest_storage = new DiskStorage (settings.syncURL);
				var dest_engine = new Engine (dest_storage);

				var client = new FilesystemSyncClient (NoteEngine, manifestTracker.Manifest);
				var server = new FilesystemSyncServer (dest_engine, dest_manifest);
				new SyncManager(client, server).DoSync ();

				// write back the dest manifest
		        	using (var output = new FileStream (dest_manifest_path, FileMode.Create)) {
					SyncManifest.Write (dest_manifest, output);
				}

				PopulateNotebookList (false);
				RefreshNotesWindowController ();

				success = true;
			}

			else if (!String.IsNullOrEmpty (settings.webSyncURL) ||!String.IsNullOrWhiteSpace (settings.webSyncURL)) {

				ServicePointManager.CertificatePolicy = new DummyCertificateManager();

				OAuthToken reused_token = new OAuthToken { Token = settings.token, Secret = settings.secret };


				ISyncClient client = new FilesystemSyncClient (NoteEngine, manifestTracker.Manifest);
				ISyncServer server = new WebSyncServer (settings.webSyncURL, reused_token);

				new SyncManager (client, server).DoSync ();

				PopulateNotebookList (false);
				RefreshNotesWindowController ();

				success = true;
			}

			if (success) {
				NSAlert alert = new NSAlert () {
					MessageText = "Sync Successful",
					InformativeText = "The sync was successful",
					AlertStyle = NSAlertStyle.Warning
				};
				alert.AddButton ("OK");
				alert.BeginSheet (null);
				alert.Window.Title = "Sync Successful";
			} else {
				NSAlert alert = new NSAlert () {
					MessageText = "Sync Failed",
					InformativeText = "The sync was not successful. Please check the Sync Settings.",
					AlertStyle = NSAlertStyle.Warning
				};
				alert.AddButton ("OK");
				alert.BeginSheet (null);
				alert.Window.Title = "Sync Failed";
			}
        	}
Beispiel #18
0
 public static void Export(string rootDirectory, Engine appEngine)
 {
     ProcessDirectory(rootDirectory, appEngine);
 }
 private void InitServer()
 {
     serverStorage = new DiskStorage ();
     serverStorage.SetPath (serverStorageDir);
     serverEngine = new Engine (serverStorage);
     serverManifest = new SyncManifest ();
     syncServer = new FilesystemSyncServer (serverEngine, serverManifest);
 }
 public void Init()
 {
     IStorage storage = DiskStorage.Instance;
     storage.SetPath ("../../test_notes/proper_notes");
     engine = new Engine (storage);
 }
Beispiel #21
0
 public void Init()
 {
     //TODO: The storage instance needs swapping with a stub/mock!
     DiskStorage.Instance.SetPath ("../../test_notes/proper_notes");
     engine = new Engine (DiskStorage.Instance);
     // get a new note instance
     note = engine.NewNote ();
     note.Title = "Unit Test Note";
     note.Text = "Unit test note by NewNote() method";
     engine.SaveNote (note);
     NOTE_PATH = Path.Combine ("../../test_notes/proper_notes", Utils.GetNoteFileNameFromURI (note));
 }
Beispiel #22
0
            public DirectoryBasedNoteRepository(string username, string notes_base_path)
            {
                this.Username = username;
                this.notesBasePath = notes_base_path;

                lock (userLocks) {
                    if (!userLocks.ContainsKey (Username))
                        userLocks [Username] = new Semaphore (1, 10);
                }
                // if another instance for this user exists, wait until it is freed
                userLocks [username].WaitOne ();

                storagePath = this.notesBasePath + "/" + Username;
                if (!Directory.Exists (storagePath)) {
                    Directory.CreateDirectory (storagePath);
                }

                storage = new DiskStorage ();
                storage.SetPath (storagePath);
                Engine = new Engine (storage);

                // read in data from "manifest" file
                manifestPath = Path.Combine (storagePath, "manifest.xml");
                if (File.Exists (manifestPath)) {
                    string manifest_xml = File.ReadAllText (manifestPath);
                    var textreader = new StringReader (manifest_xml);
                    var xmlreader = new XmlTextReader (textreader);
                    Manifest = SyncManifest.Read (xmlreader);
                } else {
                    Manifest = new SyncManifest ();
                    Manifest.ServerId = Guid.NewGuid ().ToString ();
                }
            }
Beispiel #23
0
 public void Init()
 {
     //TODO: The storage instance needs swapping with a stub/mock!
     DiskStorage.Instance.SetPath ("../../test_notes/proper_notes");
     engine = new Engine (DiskStorage.Instance);
 }