/// <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();
}
