/// <summary> /// Constructor /// </summary> /// <param name="replication">The replication to observe</param> public OneShotCouchbaseResponseState(Replication replication) { if (replication == null) { throw new ArgumentNullException("replication"); } _replication = replication; _replication.Changed += ReplicationChanged; }
/// <summary> /// Constructor /// </summary> /// <param name="replication">The replication to observe</param> public OneShotCouchbaseResponseState(Replication replication) { if (replication == null) { Log.To.Listener.E(Tag, "replication cannot be null in ctor, throwing..."); throw new ArgumentNullException("replication"); } _replication = replication; _replication.Changed += ReplicationChanged; }
public RavenConfiguration Initialize() { Core.Initialize(Settings); Replication.Initialize(Settings); Queries.Initialize(Settings); Patching.Initialize(Settings); BulkInsert.Initialize(Settings); Server.Initialize(Settings); Memory.Initialize(Settings); Indexing.Initialize(Settings); Prefetcher.Initialize(Settings); Storage.Initialize(Settings); Encryption.Initialize(Settings); Cluster.Initialize(Settings); Monitoring.Initialize(Settings); FileSystem.Initialize(Settings); Counter.Initialize(Settings); TimeSeries.Initialize(Settings); Expiration.Initialize(Settings); Versioning.Initialize(Settings); Studio.Initialize(Settings); Tenants.Initialize(Settings); Licensing.Initialize(Settings); Quotas.Initialize(Settings); if (Settings["Raven/MaxServicePointIdleTime"] != null) { ServicePointManager.MaxServicePointIdleTime = Convert.ToInt32(Settings["Raven/MaxServicePointIdleTime"]); } if (ConcurrentMultiGetRequests == null) { ConcurrentMultiGetRequests = new SemaphoreSlim(Server.MaxConcurrentMultiGetRequests); } PostInit(); initialized = true; return(this); }
/// <exception cref="System.Exception"></exception> public virtual void TestReplicatorErrorStatus() { Assert.Fail(); // NOTE.ZJG: Need to remove FB & Persona login stuff. // register bogus fb token IDictionary <string, object> facebookTokenInfo = new Dictionary <string, object>(); facebookTokenInfo.Put("email", "*****@*****.**"); facebookTokenInfo.Put("remote_url", GetReplicationURL().ToExternalForm()); facebookTokenInfo.Put("access_token", "fake_access_token"); string destUrl = string.Format("/_facebook_token", DefaultTestDb); IDictionary <string, object> result = (IDictionary <string, object>)SendBody("POST" , destUrl, facebookTokenInfo, Status.Ok, null); Log.V(Tag, string.Format("result %s", result)); // start a replicator IDictionary <string, object> properties = GetPullReplicationParsedJson(); Replication replicator = manager.GetReplicator(properties); replicator.Start(); bool foundError = false; for (int i = 0; i < 10; i++) { // wait a few seconds Sharpen.Thread.Sleep(5 * 1000); // expect an error since it will try to contact the sync gateway with this bogus login, // and the sync gateway will reject it. AList <object> activeTasks = (AList <object>)Send("GET", "/_active_tasks", Status.Ok , null); Log.D(Tag, "activeTasks: " + activeTasks); IDictionary <string, object> activeTaskReplication = (IDictionary <string, object>) activeTasks[0]; foundError = (activeTaskReplication.Get("error") != null); if (foundError == true) { break; } } NUnit.Framework.Assert.IsTrue(foundError); }
/// <summary> /// Request, configure, or stop, a replication operation. /// </summary> /// <returns>The response state for further HTTP processing</returns> /// <param name="context">The context of the Couchbase Lite HTTP request</param> /// <remarks> /// http://docs.couchdb.org/en/latest/api/server/common.html#post--_replicate /// <remarks> public static ICouchbaseResponseState ManageReplicationSession(ICouchbaseListenerContext context) { byte[] buffer = new byte[context.ContentLength]; context.BodyStream.Read(buffer, 0, buffer.Length); var body = new Body(buffer).GetProperties() ?? new Dictionary <string, object>(); Replication rep = context.DbManager.ReplicationWithProperties(body); var response = context.CreateResponse(); bool cancel = body.Get("cancel") is bool && (bool)body.Get("cancel"); if (cancel) { if (!rep.IsRunning) { response.InternalStatus = StatusCode.NotFound; } else { rep.Stop(); } } else { rep.Start(); if (rep.Continuous || body.GetCast <bool>("async", false)) { response.JsonBody = new Body(new Dictionary <string, object> { { "session_id", rep.sessionID } }); } else { return(new OneShotCouchbaseResponseState(rep) { Response = response }); } } return(response.AsDefaultState()); }
public void StartSyncGateway(string scheme = "https", string hostname = "localhost", int port = 4984, string dbname = "beer", string username = "******", string password = "******") { Uri uri = CreateSyncUri(scheme, hostname, port, dbname); pull = _database.CreatePullReplication(uri); push = _database.CreatePushReplication(uri); var authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, password); pull.Authenticator = authenticator; push.Authenticator = authenticator; pull.Continuous = true; push.Continuous = true; pull.Changed += Pull_Changed; push.Changed += Push_Changed; pull.Start(); push.Start(); }
private async void OnSaveClick() { Dictionary <string, object> data = RunData.CreateDictionary( new DateTimeOffset(mStartTime).ToUnixTimeMilliseconds(), (long)mDuration.TotalMilliseconds, mDistance, mStartCoordinate, mFinishCoordinate); Database database = Couchbase.Lite.Manager.SharedInstance.GetDatabase(RunData.LOCAL_DB_NAME); Document document = database.CreateDocument(); document.PutProperties(data); Replication uploader = database.CreatePushReplication(new Uri(DATABASE_URL + "/" + DATABASE_NAME)); uploader.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(USERNAME, PASSWORD); uploader.Start(); await Navigation.PushAsync(new DetailPage(new RunData(data))); //Navigation.RemovePage(this); }
public virtual void TestReplicatorErrorStatus() { Assert.Fail(); // TODO.ZJG: Needs FB login stuff removed. // register bogus fb token IDictionary <string, object> facebookTokenInfo = new Dictionary <string, object>(); facebookTokenInfo["email"] = "*****@*****.**"; facebookTokenInfo.Put("remote_url", GetReplicationURL().ToString()); facebookTokenInfo["access_token"] = "fake_access_token"; var destUrl = string.Format("{0}/_facebook_token", DefaultTestDb); var result = (IDictionary <string, object>)SendBody("POST", destUrl, facebookTokenInfo, (int)StatusCode.Ok, null); Log.V(Tag, string.Format("result {0}", result)); // start a replicator IDictionary <string, object> properties = GetPullReplicationParsedJson(); Replication replicator = manager.GetExistingDatabase(DefaultTestDb).CreatePushReplication(new Uri(destUrl)); replicator.Start(); bool foundError = false; for (int i = 0; i < 10; i++) { // wait a few seconds Sharpen.Thread.Sleep(5 * 1000); // expect an error since it will try to contact the sync gateway with this bogus login, // and the sync gateway will reject it. var activeTasks = (AList <object>)Send("GET", "/_active_tasks", HttpStatusCode.OK, null); Log.D(Tag, "activeTasks: " + activeTasks); IDictionary <string, object> activeTaskReplication = (IDictionary <string, object>) activeTasks[0]; foundError = (activeTaskReplication["error"] != null); if (foundError == true) { break; } } NUnit.Framework.Assert.IsTrue(foundError); }
/// <summary> /// Prepares writeback settings to write to Hive /// </summary> /// <param name="request"></param> /// <param name="context"></param> /// <returns></returns> public override async Task <PrepareWriteResponse> PrepareWrite(PrepareWriteRequest request, ServerCallContext context) { // Logger.SetLogLevel(Logger.LogLevel.Debug); Logger.SetLogPrefix(request.DataVersions.JobId); Logger.Info("Preparing write..."); _server.WriteConfigured = false; _server.WriteSettings = new WriteSettings { CommitSLA = request.CommitSlaSeconds, Schema = request.Schema, Replication = request.Replication, DataVersions = request.DataVersions, }; if (_server.WriteSettings.IsReplication()) { // reconcile job Logger.Info($"Starting to reconcile Replication Job {request.DataVersions.JobId}"); try { await Replication.ReconcileReplicationJobAsync(_connectionFactory, request); } catch (Exception e) { Logger.Error(e, e.Message, context); return(new PrepareWriteResponse()); } Logger.Info($"Finished reconciling Replication Job {request.DataVersions.JobId}"); } _server.WriteConfigured = true; // Logger.Debug(JsonConvert.SerializeObject(_server.WriteSettings, Formatting.Indented)); Logger.Info("Write prepared."); return(new PrepareWriteResponse()); }
private void ReplicateTransformerDeletionIfNeeded(List <JsonDocument> transformerTombstones, ReplicationStrategy destination, Dictionary <string, int> replicatedTransformerTombstones) { if (transformerTombstones.Count == 0) { return; } foreach (var tombstone in transformerTombstones) { try { int value; if (Database.Transformers.GetTransformerDefinition(tombstone.Key) != null) //if in the meantime the transformer was recreated under the same name { replicatedTransformerTombstones.TryGetValue(tombstone.Key, out value); replicatedTransformerTombstones[tombstone.Key] = value + 1; continue; } var url = string.Format("{0}/transformers/{1}?{2}&{3}", destination.ConnectionStringOptions.Url, Uri.EscapeUriString(tombstone.Key), GetTombstoneVersion(tombstone, IndexDefinitionStorage.TransformerVersionKey, Constants.TransformerVersion), GetDebugInformation()); var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethods.Delete, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination)); replicationRequest.Write(RavenJObject.FromObject(EmptyRequestBody)); replicationRequest.ExecuteRequest(); Log.Info("Replicated transformer deletion (transformer name = {0})", tombstone.Key); replicatedTransformerTombstones.TryGetValue(tombstone.Key, out value); replicatedTransformerTombstones[tombstone.Key] = value + 1; } catch (Exception e) { Replication.HandleRequestBufferingErrors(e, destination); Log.ErrorException(string.Format("Failed to replicate transformer deletion (transformer name = {0})", tombstone.Key), e); } } }
public void RefreshSync() { var stored = Settings.SyncURL; if (String.IsNullOrEmpty(stored)) { _pull?.Stop(); _push?.Stop(); } else if (stored != _syncURL?.AbsoluteUri) { _syncURL = new Uri(stored); _pull?.Stop(); _push?.Stop(); _pull = _database.CreatePullReplication(_syncURL); _push = _database.CreatePushReplication(_syncURL); _pull.Continuous = true; _push.Continuous = true; _pull.Start(); _push.Start(); } }
public RavenConfiguration Initialize() { var settingsNames = Settings.AsEnumerable().Select(pair => pair.Key).ToHashSet(StringComparer.OrdinalIgnoreCase); var serverWideSettingsNames = ServerWideSettings?.AsEnumerable().Select(pair => pair.Key).ToHashSet(StringComparer.OrdinalIgnoreCase); Http.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Embedded.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Server.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Core.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Replication.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Cluster.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Etl.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Queries.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Patching.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Logs.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Memory.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Storage.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Security.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Backup.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Indexing.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Monitoring.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Studio.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Databases.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); PerformanceHints.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Licensing.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Tombstones.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Subscriptions.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); TransactionMergerConfiguration.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Notifications.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Updates.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Migration.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); Integrations.Initialize(Settings, settingsNames, ServerWideSettings, serverWideSettingsNames, ResourceType, ResourceName); PostInit(); Initialized = true; return(this); }
private static void MigrationOnTheFly() { DeleteDatabases(); IObjectContainer desktopDatabaseWithoutUUID = Db4oEmbedded.OpenFile(DesktopDatabaseName); desktopDatabaseWithoutUUID.Store(new Car(new Pilot("Max"), "Max's Car")); desktopDatabaseWithoutUUID.Store(new Car(new Pilot("Joe"), "Joe's Car")); desktopDatabaseWithoutUUID.Commit(); desktopDatabaseWithoutUUID.Close(); IObjectContainer desktopDatabase = OpenDatabase(DesktopDatabaseName); IObjectContainer mobileDatabase = OpenDatabase(MobileDatabaseName); IReplicationProvider desktopRelicationPartner = new Db4oEmbeddedReplicationProvider(desktopDatabase); IReplicationProvider mobileRelicationPartner = new Db4oEmbeddedReplicationProvider(mobileDatabase); // #example: Migrate on the fly IReplicationSession replicationSession = Replication.Begin(desktopRelicationPartner, mobileRelicationPartner); IList <Car> initialReplication = desktopDatabase.Query <Car>(); foreach (Car changedObjectOnDesktop in initialReplication) { IObjectInfo infoAboutObject = desktopDatabase.Ext().GetObjectInfo(changedObjectOnDesktop); if (null == infoAboutObject.GetUUID()) { desktopDatabase.Ext().Store(changedObjectOnDesktop, 2); } replicationSession.Replicate(changedObjectOnDesktop); } replicationSession.Commit(); // #end example PrintCars(mobileDatabase); CloseDBs(desktopDatabase, mobileDatabase); }
private static void SelectiveReplicationWithCondition() { DeleteDatabases(); StoreObjectsIn(DesktopDatabaseName); IObjectContainer desktopDatabase = OpenDatabase(DesktopDatabaseName); IObjectContainer mobileDatabase = OpenDatabase(MobileDatabaseName); IReplicationProvider dektopReplicationProvider = new Db4oEmbeddedReplicationProvider(desktopDatabase); IReplicationProvider mobileReplicationProvider = new Db4oEmbeddedReplicationProvider(mobileDatabase); IReplicationSession replicationSession = Replication.Begin(dektopReplicationProvider, mobileReplicationProvider); // #example: Selective replication with a condition IObjectSet changesOnDesktop = replicationSession.ProviderA().ObjectsChangedSinceLastReplication(); foreach (object changedObjectOnDesktop in changesOnDesktop) { if (changedObjectOnDesktop is Car) { if (((Car)changedObjectOnDesktop).Name.StartsWith("M")) { replicationSession.Replicate(changedObjectOnDesktop); } } } replicationSession.Commit(); // #end example // now only the cars which names start with "M" are replicated PrintCars(mobileDatabase); CloseDBs(desktopDatabase, mobileDatabase); }
private void ReplicateIndexDeletionIfNeeded(List <JsonDocument> indexTombstones, ReplicationStrategy destination, Dictionary <string, int> replicatedIndexTombstones) { if (indexTombstones.Count == 0) { return; } foreach (var tombstone in indexTombstones) { try { int value; //In case the index was recreated under the same name we will increase the destination count for this tombstone //As if we sent the delete request but without actually sending the request, ending with a NOOP and deleting the index tombstone. if (Database.IndexStorage.HasIndex(tombstone.Key)) { replicatedIndexTombstones.TryGetValue(tombstone.Key, out value); replicatedIndexTombstones[tombstone.Key] = value + 1; continue; } var url = string.Format("{0}/indexes/{1}?{2}", destination.ConnectionStringOptions.Url, Uri.EscapeUriString(tombstone.Key), GetDebugInformation()); var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethods.Delete, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination)); replicationRequest.Write(RavenJObject.FromObject(EmptyRequestBody)); replicationRequest.ExecuteRequest(); Log.Info("Replicated index deletion (index name = {0})", tombstone.Key); replicatedIndexTombstones.TryGetValue(tombstone.Key, out value); replicatedIndexTombstones[tombstone.Key] = value + 1; } catch (Exception e) { Replication.HandleRequestBufferingErrors(e, destination); Log.ErrorException(string.Format("Failed to replicate index deletion (index name = {0})", tombstone.Key), e); } } }
private void StopReplication(Replication replication) { var str = "" + replication.ActiveTaskInfo; replication.Continuous = false; replication.Stop(); str += "\n" + replication.ActiveTaskInfo; int retry = 100; while (replication.IsRunning && retry-- > 0) { replication.Stop(); Thread.Sleep(10); } str += "\n" + replication.ActiveTaskInfo; try { Replication dbRep = null; // prevent the "Not starting because identical puller already exists" bug while (dbRep == null && retry-- > 0) { foreach (var rep in replication.LocalDatabase.AllReplications) { if (rep == replication) { dbRep = rep; Thread.Sleep(10); } } } } catch { // ignore } }
/// <summary> /// Configures replication writebacks to Sisense /// </summary> /// <param name="request"></param> /// <param name="context"></param> /// <returns></returns> public override Task <ConfigureReplicationResponse> ConfigureReplication(ConfigureReplicationRequest request, ServerCallContext context) { Logger.Info("Configuring write..."); var schemaJson = Replication.GetSchemaJson(); var uiJson = Replication.GetUIJson(); try { return(Task.FromResult(new ConfigureReplicationResponse { Form = new ConfigurationFormResponse { DataJson = request.Form.DataJson, Errors = { }, SchemaJson = schemaJson, UiJson = uiJson, StateJson = request.Form.StateJson } })); } catch (Exception e) { Logger.Error(e.Message); return(Task.FromResult(new ConfigureReplicationResponse { Form = new ConfigurationFormResponse { DataJson = request.Form.DataJson, Errors = { e.Message }, SchemaJson = schemaJson, UiJson = uiJson, StateJson = request.Form.StateJson } })); } }
/// <exception cref="System.Exception"></exception> public virtual void TestGetReplicator() { IDictionary <string, object> properties = new Dictionary <string, object>(); properties.Put("source", DefaultTestDb); properties.Put("target", GetReplicationURL().ToExternalForm()); Replication replicator = manager.GetReplicator(properties); NUnit.Framework.Assert.IsNotNull(replicator); NUnit.Framework.Assert.AreEqual(GetReplicationURL().ToExternalForm(), replicator. GetRemoteUrl().ToExternalForm()); NUnit.Framework.Assert.IsTrue(!replicator.IsPull()); NUnit.Framework.Assert.IsFalse(replicator.IsContinuous()); NUnit.Framework.Assert.IsFalse(replicator.IsRunning()); // start the replicator replicator.Start(); // now lets lookup existing replicator and stop it properties.Put("cancel", true); Replication activeReplicator = manager.GetReplicator(properties); activeReplicator.Stop(); NUnit.Framework.Assert.IsFalse(activeReplicator.IsRunning()); }
protected void Replicate(string localDbName, string remoteDbName, List <string> channels) { var url = new Uri(syncGateway + "/" + remoteDbName + "/"); database = Manager.SharedInstance.GetDatabase(localDbName); pull = database.CreatePullReplication(url); push = database.CreatePushReplication(url); var auth = AuthenticatorFactory.CreateBasicAuthenticator(this.username, this.password); //Pull process pull.Channels = channels; pull.Authenticator = auth; pull.Continuous = true; pull.Changed += PullChanged; pull.Start(); //Push process push.Authenticator = auth; push.Continuous = true; push.Start(); }
public virtual Replication[] CreateReplications() { Uri syncUrl; try { syncUrl = new Uri(SyncUrl); } catch (UriFormatException e) { Log.E(Tag, "Invalid Sync Url", e); throw new RuntimeException(e); } Replication pullRep = database.CreatePullReplication(syncUrl); pullRep.SetContinuous(true); pullRep.AddChangeListener(GetReplicationChangeListener()); Replication pushRep = database.CreatePushReplication(syncUrl); pushRep.SetContinuous(true); pushRep.AddChangeListener(GetReplicationChangeListener()); return(new Replication[] { pullRep, pushRep }); }
private static void EventExample() { DeleteDatabases(); StoreObjectsIn(DesktopDatabaseName); IObjectContainer desktopDatabase = OpenDatabase(DesktopDatabaseName); IObjectContainer mobileDatabase = OpenDatabase(MobileDatabaseName); IReplicationProvider desktopRelicationPartner = new Db4oEmbeddedReplicationProvider(desktopDatabase); IReplicationProvider mobileRelicationPartner = new Db4oEmbeddedReplicationProvider(mobileDatabase); // #example: Register a listener for information about the replication process IReplicationSession replicationSession = Replication.Begin(desktopRelicationPartner, mobileRelicationPartner, new LogReplicationListener()); // #end example ReplicateBidirectional(replicationSession); replicationSession.Commit(); CloseDBs(desktopDatabase, mobileDatabase); }
/// <summary>创建HttpBuilder /// </summary> public override HttpBuilder CreateBuilder() { var builder = new HttpBuilder(Resource, Method.GET); builder.AddParameter("count", Count, ParameterType.QueryString); if (!DataCenter.IsNullOrWhiteSpace()) { builder.AddParameter("dataCenter", DataCenter, ParameterType.QueryString); } if (!Replication.IsNullOrWhiteSpace()) { builder.AddParameter("replication", Replication, ParameterType.QueryString); } if (!Collection.IsNullOrWhiteSpace()) { builder.AddParameter("collection", Collection, ParameterType.QueryString); } if (!Ttl.IsNullOrWhiteSpace()) { builder.AddParameter("ttl", Ttl, ParameterType.QueryString); } return(builder); }
public void PushSync(Credentials credentials) { if (credentials == null) { return; } var opts = new DatabaseOptions(); // To use this feature, add the Couchbase.Lite.Storage.ForestDB nuget package opts.StorageType = StorageEngineTypes.ForestDB; Database = Manager.SharedInstance.OpenDatabase(credentials.DatabaseName, opts); if (Database == null) { return; } ForgetSync(); if (!string.IsNullOrEmpty(credentials.SyncGatewayUrl)) { try { var uri = new System.Uri(credentials.SyncGatewayUrl); Push = Database.CreatePushReplication(uri); Push.Continuous = true; Push.Changed += ReplicationChanged; Push.Start(); } catch (Java.Lang.Throwable th) { Log.Debug(Tag, th, "UpdateSync Error"); } } }
private void cmbDatasets_SelectedIndexChanged(object sender, EventArgs e) { lstFeatureclasses.Items.Clear(); if (cmbDatasets.SelectedIndex == -1) { return; } IFeatureDataset dataset = ((DatasetItem)cmbDatasets.SelectedItem).Dataset; if (dataset == null || !(dataset.Database is IFeatureDatabaseReplication)) { return; } IFeatureDatabaseReplication db = (IFeatureDatabaseReplication)dataset.Database; foreach (IDatasetElement element in dataset.Elements) { if (element == null || !(element.Class is IFeatureClass)) { continue; } IFeatureClass fc = (IFeatureClass)element.Class; //List<Guid> SessionGuids = Replication.FeatureClassSessions(fc); //if (SessionGuids == null) continue; int generation = Replication.FeatureClassGeneration(fc); if (generation < 1) { continue; } lstFeatureclasses.Items.Add(new FeatureClassItem(fc)); } }
public override void Update(float diff) { base.Update(diff); if (!IsDead) { if (IsDashing || _aiPaused) { return; } if (ScanForTargets()) // returns true if we have a target { if (!RecalculateAttackPosition()) { KeepFocussingTarget(); // attack target } } else { WalkToDestination(); // walk to destination (or target) } } Replication.Update(); }
private void RunReplication(Replication replication) { // var replicationDoneSignal = new CountDownLatch(1); var replicationDoneSignalPolling = ReplicationWatcherThread(replication); replication.Changed += (sender, e) => replicationDoneSignalPolling.CountDown(); replication.Start(); Log.D(Tag, "Waiting for replicator to finish"); try { var success = replicationDoneSignalPolling.Await(TimeSpan.FromSeconds(15)); Assert.IsTrue(success); Sharpen.Thread.Sleep(5000); replication.Stop(); Log.D(Tag, "replicator finished"); } catch (Exception e) { Runtime.PrintStackTrace(e); } }
void UpdateSyncUrl() { if (Database == null) return; NSUrl newRemoteUrl = null; var syncPoint = NSUserDefaults.StandardUserDefaults.StringForKey (ConfigViewController.SyncUrlKey); if (!String.IsNullOrWhiteSpace (syncPoint)) newRemoteUrl = new NSUrl (syncPoint); ForgetSync (); var repls = Database.ReplicateWithURL (newRemoteUrl, true); if (repls != null) { pull = repls [0]; push = repls [1]; pull.Continuous = push.Continuous = true; pull.Persistent = push.Persistent = true; var nctr = NSNotificationCenter.DefaultCenter; nctr.AddObserver ((NSString)ReplicationChangeNotification, ReplicationProgress, pull); nctr.AddObserver ((NSString)ReplicationChangeNotification, ReplicationProgress, push); } }
void ReplicationProgress(NSNotification notification) { var active = notification.Object as Replication; Debug.WriteLine (String.Format ("Push: {0}, Pull: {1}", push.Mode, pull.Mode)); uint lastTotal = 0; if (_leader == null) { if (active.Pull && (pull.Mode == ReplicationMode.Active && push.Mode != ReplicationMode.Active)) { _leader = pull; } else if (!active.Pull && (push.Mode == ReplicationMode.Active && pull.Mode != ReplicationMode.Active)) { _leader = push; } else { _leader = null; } } if (active == pull) { lastTotal = _lastPullCompleted; } else { lastTotal = _lastPushCompleted; } Debug.WriteLine (String.Format ("Sync: {2} Progress: {0}/{1};", active.Completed - lastTotal, active.Total - lastTotal, active == push ? "Push" : "Pull")); var progress = (float)(active.Completed - lastTotal) / (float)(Math.Max (active.Total - lastTotal, 1)); if (AppDelegate.CurrentSystemVersion < AppDelegate.iOS7) { ShowSyncStatusLegacy (); } else { ShowSyncStatus (); } Debug.WriteLine (String.Format ("({0})", progress)); if (active == pull) { if (AppDelegate.CurrentSystemVersion >= AppDelegate.iOS7) Progress.TintColor = UIColor.White; } else { if (AppDelegate.CurrentSystemVersion >= AppDelegate.iOS7) Progress.TintColor = UIColor.LightGray; } Progress.Hidden = false; if (progress < Progress.Progress) Progress.SetProgress (progress, false); else Progress.SetProgress (progress, false); if (!(pull.Mode != ReplicationMode.Active && push.Mode != ReplicationMode.Active)) return; if (active == null) return; var initiatorName = _leader.Pull ? "Pull" : "Push"; _lastPushCompleted = push.Completed; _lastPullCompleted = pull.Completed; if (Progress == null) return; Progress.Hidden = false; Progress.SetProgress (1f, false); var t = new System.Timers.Timer (300); t.Elapsed += (sender, e) => { InvokeOnMainThread (() => { t.Dispose (); Progress.Hidden = true; Progress.SetProgress (0f, false); Debug.WriteLine (String.Format ("{0} Sync Session Finished.", initiatorName)); ShowSyncButton (); }); }; t.Start (); }
void ForgetSync() { var nctr = NSNotificationCenter.DefaultCenter; if (pull != null) { nctr.RemoveObserver (this, null, pull); pull = null; } if (push != null) { nctr.RemoveObserver (this, null, push); push = null; } }
public async Task ShouldSendCounterChangeMadeInCluster() { var srcDb = "13288-src"; var dstDb = "13288-dst"; var(_, srcRaft) = await CreateRaftCluster(2); var(_, dstRaft) = await CreateRaftCluster(1); var srcNodes = await CreateDatabaseInCluster(srcDb, 2, srcRaft.WebUrl); var destNode = await CreateDatabaseInCluster(dstDb, 1, dstRaft.WebUrl); using (var src = new DocumentStore { Urls = srcNodes.Servers.Select(s => s.WebUrl).ToArray(), Database = srcDb, }.Initialize()) using (var dest = new DocumentStore { Urls = new[] { destNode.Servers[0].WebUrl }, Database = dstDb, }.Initialize()) { var connectionStringName = "my-etl"; var urls = new[] { destNode.Servers[0].WebUrl }; var config = new RavenEtlConfiguration() { Name = connectionStringName, ConnectionStringName = connectionStringName, Transforms = { new Transformation { Name = $"ETL : {connectionStringName}", Collections = new List <string>(new[] { "Users" }), Script = null, ApplyToAllDocuments = false, Disabled = false } }, LoadRequestTimeoutInSec = 30, MentorNode = "A" }; var connectionString = new RavenConnectionString { Name = connectionStringName, Database = dest.Database, TopologyDiscoveryUrls = urls, }; var result = src.Maintenance.Send(new PutConnectionStringOperation <RavenConnectionString>(connectionString)); Assert.NotNull(result.RaftCommandIndex); src.Maintenance.Send(new AddEtlOperation <RavenConnectionString>(config)); var aNode = srcNodes.Servers.Single(s => s.ServerStore.NodeTag == "A"); var bNode = srcNodes.Servers.Single(s => s.ServerStore.NodeTag == "B"); // modify counter on A node (mentor of ETL task) using (var aSrc = new DocumentStore { Urls = new[] { aNode.WebUrl }, Database = srcDb, Conventions = new DocumentConventions { DisableTopologyUpdates = true } }.Initialize()) { using (var session = aSrc.OpenSession()) { session.Store(new User() { Name = "Joe Doe" }, "users/1"); session.CountersFor("users/1").Increment("likes"); session.Advanced.WaitForReplicationAfterSaveChanges(); session.SaveChanges(); } } Assert.True(WaitForDocument <User>(dest, "users/1", u => u.Name == "Joe Doe", 30_000)); using (var session = dest.OpenSession()) { var user = session.Load <User>("users/1"); Assert.NotNull(user); Assert.Equal("Joe Doe", user.Name); var counter = session.CountersFor("users/1").Get("likes"); Assert.NotNull(counter); Assert.Equal(1, counter.Value); } // modify counter on B node (not mentor) using (var bSrc = new DocumentStore { Urls = new[] { bNode.WebUrl }, Database = srcDb, Conventions = new DocumentConventions { DisableTopologyUpdates = true } }.Initialize()) { using (var session = bSrc.OpenSession()) { session.CountersFor("users/1").Increment("likes"); session.SaveChanges(); } } Assert.True(Replication.WaitForCounterReplication(new List <IDocumentStore> { dest }, "users/1", "likes", 2, TimeSpan.FromSeconds(60))); } }
public void SendLastQueried() { if (Database.Disposed) { return; } try { using (CultureHelper.EnsureInvariantCulture()) { var relevantIndexLastQueries = new Dictionary <string, DateTime>(); var relevantIndexes = Database.Statistics.Indexes.Where(indexStats => indexStats.IsInvalidIndex == false && indexStats.Priority != IndexingPriority.Error && indexStats.Priority != IndexingPriority.Disabled && indexStats.LastQueryTimestamp.HasValue); foreach (var relevantIndex in relevantIndexes) { relevantIndexLastQueries[relevantIndex.Name] = relevantIndex.LastQueryTimestamp.GetValueOrDefault(); } if (relevantIndexLastQueries.Count == 0) { return; } var destinations = GetReplicationDestinations(x => x.SkipIndexReplication == false); foreach (var destination in destinations) { try { string url = destination.ConnectionStringOptions.Url + "/indexes/last-queried"; var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethods.Post, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination)); replicationRequest.Write(RavenJObject.FromObject(relevantIndexLastQueries)); replicationRequest.ExecuteRequest(); } catch (Exception e) { Replication.HandleRequestBufferingErrors(e, destination); Log.WarnException("Could not update last query time of " + destination.ConnectionStringOptions.Url, e); } } } } catch (Exception e) { Log.ErrorException("Failed to send last queried timestamp of indexes", e); } }
private void ReplicateSingleSideBySideIndex(ReplicationStrategy destination, IndexDefinition indexDefinition, IndexDefinition sideBySideIndexDefinition) { var url = $"{destination.ConnectionStringOptions.Url}/replication/side-by-side?{GetDebugInformation()}"; IndexReplaceDocument indexReplaceDocument; try { indexReplaceDocument = Database.Documents.Get(Constants.IndexReplacePrefix + sideBySideIndexDefinition.Name, null).DataAsJson.JsonDeserialization <IndexReplaceDocument>(); } catch (Exception e) { Log.Warn("Cannot get side-by-side index replacement document. Aborting operation. (this exception should not happen and the cause should be investigated)", e); return; } var sideBySideReplicationInfo = new SideBySideReplicationInfo { Index = indexDefinition, SideBySideIndex = sideBySideIndexDefinition, OriginDatabaseId = destination.CurrentDatabaseId, IndexReplaceDocument = indexReplaceDocument }; var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethod.Post, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination)); replicationRequest.Write(RavenJObject.FromObject(sideBySideReplicationInfo)); replicationRequest.ExecuteRequest(); }
private void ReplicateSideBySideIndexesMultiPut(ReplicationStrategy destination, List <IndexToAdd> indexes) { var sideBySideIndexes = new SideBySideIndexes { IndexesToAdd = indexes.ToArray() }; var serializedIndexDefinitions = RavenJToken.FromObject(sideBySideIndexes); var url = $"{destination.ConnectionStringOptions.Url}/side-by-side-indexes?{GetDebugInformation()}"; var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethods.Put, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination)); replicationRequest.Write(serializedIndexDefinitions); replicationRequest.ExecuteRequest(); }
public DigitalReplication(Replication.Type t = Replication.Type.Central, double gap = 1e-4) { gap_ = gap; replicationType_ = t; }
/// <summary> /// Writes records to Sisense /// </summary> /// <param name="requestStream"></param> /// <param name="responseStream"></param> /// <param name="context"></param> /// <returns></returns> public override async Task WriteStream(IAsyncStreamReader <Record> requestStream, IServerStreamWriter <RecordAck> responseStream, ServerCallContext context) { try { Logger.Info("Writing records to Sisense..."); Logger.Info($"API Route: {GetBindingHostedService.ServerAddresses.Addresses.FirstOrDefault()}"); var schema = _server.WriteSettings.Schema; var sla = _server.WriteSettings.CommitSLA; var inCount = 0; var outCount = 0; // get next record to publish while connected and configured while (await requestStream.MoveNext(context.CancellationToken) && _server.Connected && _server.WriteConfigured) { var record = requestStream.Current; inCount++; Logger.Debug($"Got record: {record.DataJson}"); if (_server.WriteSettings.IsReplication()) { var config = JsonConvert.DeserializeObject <ConfigureReplicationFormData>(_server.WriteSettings.Replication.SettingsJson); // send record to source system // timeout if it takes longer than the sla var task = Task.Run(() => Replication.WriteRecord(schema, record, config)); if (task.Wait(TimeSpan.FromSeconds(sla))) { // send ack var ack = new RecordAck { CorrelationId = record.CorrelationId, Error = task.Result }; await responseStream.WriteAsync(ack); if (String.IsNullOrEmpty(task.Result)) { outCount++; } } else { // send timeout ack var ack = new RecordAck { CorrelationId = record.CorrelationId, Error = "timed out" }; await responseStream.WriteAsync(ack); } } else { throw new Exception("Only replication writebacks are supported"); } } Logger.Info($"Wrote {outCount} of {inCount} records to Sisense."); } catch (Exception e) { Logger.Error(e.Message); throw; } }
void ReplicationProgress(object replication, ReplicationChangeEventArgs args) { var active = args.Source; Debug.WriteLine(String.Format("Push: {0}, Pull: {1}", push.Status, pull.Status)); int lastTotal = 0; if (_leader == null) { if (active.IsPull && (pull.Status == ReplicationStatus.Active && push.Status != ReplicationStatus.Active)) { _leader = pull; } else if (!active.IsPull && (push.Status == ReplicationStatus.Active && pull.Status != ReplicationStatus.Active)) { _leader = push; } else { _leader = null; } } if (active == pull) { lastTotal = _lastPullCompleted; } else { lastTotal = _lastPushCompleted; } Debug.WriteLine(String.Format("Sync: {2} Progress: {0}/{1};", active.CompletedChangesCount - lastTotal, active.ChangesCount - lastTotal, active == push ? "Push" : "Pull")); var progress = (float)(active.CompletedChangesCount - lastTotal) / (float)(Math.Max(active.ChangesCount - lastTotal, 1)); ShowSyncStatus(); Debug.WriteLine(String.Format("({0:F})", progress)); if (active == pull) { Progress.TintColor = UIColor.White; } else { Progress.TintColor = UIColor.LightGray; } Progress.Hidden = false; if (progress < Progress.Progress) { Progress.SetProgress(progress, false); } else { Progress.SetProgress(progress, false); } if (!(pull.Status != ReplicationStatus.Active && push.Status != ReplicationStatus.Active)) { if (progress < 1f) { return; } } if (active == null) { return; } var initiatorName = active.IsPull ? "Pull" : "Push"; _lastPushCompleted = push.ChangesCount; _lastPullCompleted = pull.ChangesCount; if (Progress == null) { return; } Progress.Hidden = false; Progress.SetProgress(1f, false); var t = new System.Timers.Timer(300); t.Elapsed += (sender, e) => { InvokeOnMainThread(() => { t.Dispose(); Progress.Hidden = true; Progress.SetProgress(0f, false); Debug.WriteLine(String.Format("{0} Sync Session Finished.", initiatorName)); ShowSyncButton(); }); }; t.Start(); }