public void Call(IDictionary <string, object> parameters = null, C8oResponseListener c8oResponseListener = null, C8oExceptionListener c8oExceptionListener = null)
{
// IMPORTANT : all c8o calls have to end here !
try
{
c8oLogger.LogMethodCall("Call", parameters);
// Checks parameters validity
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
else
{
// Clones parameters in order to modify them
parameters = new Dictionary <string, object>(parameters);
}
// Creates a async task running on another thread
// Exceptions have to be handled by the C8oExceptionListener
var task = new C8oCallTask(this, parameters, c8oResponseListener, c8oExceptionListener);
task.Execute();
}
catch (Exception e)
{
HandleCallException(c8oExceptionListener, parameters, e);
}
}
public C8oCallTask(C8o c8o, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener, C8oExceptionListener c8oExceptionListener)
{
this.c8o = c8o;
this.parameters = parameters;
this.c8oResponseListener = c8oResponseListener;
this.c8oExceptionListener = c8oExceptionListener;
c8o.c8oLogger.LogMethodCall("C8oCallTask", parameters);
}
/// <summary>
/// Handles the fullSync response depending to the C8oResponseListener.
/// </summary>
/// <param name="response"></param>
/// <param name="parameters"></param>
/// <param name="c8oResponseListener"></param>
public virtual object HandleFullSyncResponse(object response, C8oResponseListener listener)
{
if (response is JObject)
{
if (listener is C8oResponseXmlListener)
{
response = C8oFullSyncTranslator.FullSyncJsonToXml(response as JObject);
}
}
return(response);
}
//*** Request handlers ***//
public override object HandleFullSyncResponse(object response, C8oResponseListener listener)
{
response = base.HandleFullSyncResponse(response, listener);
if (response is VoidResponse)
{
return(response);
}
if (listener is C8oResponseJsonListener)
{
//*** Document (GetDocument) ***//
if (response is Document)
{
return(C8oFullSyncCblTranslator.DocumentToJson(response as Document));
}
//*** FullSyncDocumentOperationResponse (DeleteDocument, PostDocument) ***//
else if (response is FullSyncDocumentOperationResponse)
{
return(C8oFullSyncCblTranslator.FullSyncDocumentOperationResponseToJSON(response as FullSyncDocumentOperationResponse));
}
//*** QueryEnumerator (GetAllDocuments, GetView) ***//
else if (response is QueryEnumerator)
{
try
{
return(C8oFullSyncCblTranslator.QueryEnumeratorToJson(response as QueryEnumerator));
}
catch (C8oException e)
{
throw new C8oException(C8oExceptionMessage.queryEnumeratorToJSON(), e);
}
}
//*** FullSyncDefaultResponse (Sync, ReplicatePull, ReplicatePush, Reset) ***//
else if (response is FullSyncDefaultResponse)
{
return(C8oFullSyncCblTranslator.FullSyncDefaultResponseToJson(response as FullSyncDefaultResponse));
}
}
else if (listener is C8oResponseXmlListener)
{
//*** Document (GetDocument) ***//
if (response is Document)
{
return(C8oFullSyncCblTranslator.DocumentToXml(response as Document));
}
//*** FullSyncDocumentOperationResponse (DeleteDocument, PostDocument) ***//
else if (response is FullSyncDocumentOperationResponse)
{
return(C8oFullSyncCblTranslator.FullSyncDocumentOperationResponseToXml(response as FullSyncDocumentOperationResponse));
}
//*** QueryEnumerator (GetAllDocuments, GetView) ***//
else if (response is QueryEnumerator)
{
try
{
return(C8oFullSyncCblTranslator.QueryEnumeratorToXml(response as QueryEnumerator));
}
catch (C8oException e)
{
throw new C8oException(C8oExceptionMessage.queryEnumeratorToXML(), e);
}
}
//*** FullSyncDefaultResponse (Sync, ReplicatePull, ReplicatePush, Reset) ***//
else if (response is FullSyncDefaultResponse)
{
return(C8oFullSyncCblTranslator.FullSyncDefaultResponseToXml(response as FullSyncDefaultResponse));
}
}
else if (listener is C8oResponseCblListener)
{
//*** Document (GetDocument) ***// || //*** QueryEnumerator (GetAllDocuments, GetView) ***//
if (response is Document || response is QueryEnumerator)
{
return(response);
}
}
return(response);
}
public async override Task <object> HandleReplicatePushRequest(string databaseName, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener)
{
var fullSyncDatabase = await GetOrCreateFullSyncDatabase(databaseName);
try
{
fullSyncDatabase.StartPushReplication(parameters, c8oResponseListener);
}
catch (Exception e)
{
throw new C8oException(C8oExceptionMessage.FullSyncReplicationFail(databaseName, "push"), e);
}
return(VoidResponse.GetInstance());
}
//*** C8o calls ***//
public void Call(string requestable, IDictionary <string, object> parameters = null, C8oResponseListener c8oResponseListener = null, C8oExceptionListener c8oExceptionListener = null)
{
try
{
if (requestable == null)
{
throw new System.ArgumentNullException(C8oExceptionMessage.InvalidArgumentNullParameter("requestable"));
}
// Checks parameters validity
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
else
{
// Clone parameters in order to modify them
parameters = new Dictionary <string, object>(parameters);
}
// Use the requestable string to add parameters corresponding to the c8o project, sequence, connector and transaction (<project>.<sequence> or <project>.<connector>.<transaction>)
var matches = RE_REQUESTABLE.Match(requestable);
if (!matches.Success)
{
// The requestable is not correct so the default transaction of the default connector will be called
throw new System.ArgumentException(C8oExceptionMessage.InvalidRequestable(requestable));
}
// If the project name is specified
if (matches.Groups[1].Value != "")
{
parameters[ENGINE_PARAMETER_PROJECT] = matches.Groups[1].Value;
}
// If the C8o call use a sequence
if (matches.Groups[2].Value != "")
{
parameters[ENGINE_PARAMETER_SEQUENCE] = matches.Groups[2].Value;
}
else
{
parameters[ENGINE_PARAMETER_CONNECTOR] = matches.Groups[3].Value;
parameters[ENGINE_PARAMETER_TRANSACTION] = matches.Groups[4].Value;
}
Call(parameters, c8oResponseListener, c8oExceptionListener);
}
catch (Exception e)
{
HandleCallException(c8oExceptionListener, parameters, e);
}
}
public override object HandleFullSyncResponse(object response, C8oResponseListener listener)
{
return(base.HandleFullSyncResponse(response, listener));
}
private async Task <object> postReplicate(string fullSyncDatatbaseName, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener, bool isPull)
{
bool createTarget = true;
bool continuous = false;
bool cancel = false;
if (parameters.ContainsKey("create_target"))
{
createTarget = parameters["create_target"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase);
}
if (parameters.ContainsKey("continuous"))
{
continuous = parameters["continuous"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase);
}
if (parameters.ContainsKey("cancel"))
{
cancel = parameters["cancel"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase);
}
JToken local = fullSyncDatatbaseName + localSuffix;
var remote = new JObject();
remote["url"] = fullSyncDatabaseUrlBase + fullSyncDatatbaseName + '/';
var cookies = c8o.CookieStore;
if (cookies.Count > 0)
{
var headers = new JObject();
var cookieHeader = new StringBuilder();
foreach (Cookie cookie in cookies.GetCookies(new Uri(c8o.EndpointConvertigo + '/')))
{
cookieHeader.Append(cookie.Name).Append("=").Append(cookie.Value).Append("; ");
}
cookieHeader.Remove(cookieHeader.Length - 2, 2);
headers["Cookie"] = cookieHeader.ToString();
remote["headers"] = headers;
}
var request = HttpWebRequest.CreateHttp(serverUrl + "/_replicate");
request.Method = "POST";
var json = new JObject();
string sourceId = (isPull ? remote["url"] : local).ToString();
string targetId = (isPull ? local : remote["url"]).ToString();
json["source"] = isPull ? remote : local;
json["target"] = isPull ? local : remote;
json["create_target"] = createTarget;
json["continuous"] = false;
json["cancel"] = true;
var response = await Execute(request, json);
c8o.Log._Warn("CANCEL REPLICATE:\n" + response.ToString());
if (cancel)
{
return(response);
}
json["cancel"] = false;
request = HttpWebRequest.CreateHttp(serverUrl + "/_replicate");
request.Method = "POST";
response = null;
var param = new Dictionary <string, object>(parameters);
var progress = new C8oProgress();
progress.Pull = isPull;
progress.Status = "Active";
progress.Finished = false;
Task.Run(async() =>
{
long checkPoint_Interval = 1000;
while (response == null)
{
await Task.Delay(TimeSpan.FromMilliseconds(checkPoint_Interval));
if (response != null)
{
break;
}
var req = HttpWebRequest.CreateHttp(serverUrl + "/_active_tasks");
req.Method = "GET";
var res = await Execute(req);
if (response != null)
{
break;
}
c8o.Log._Warn(res.ToString());
JObject task = null;
foreach (JToken item in res["item"])
{
if (item["target"].ToString() == targetId && item["source"].ToString() == sourceId)
{
task = item as JObject;
break;
}
}
if (task != null)
{
checkPoint_Interval = (long)task["checkpoint_interval"].ToObject(typeof(long));
progress.Raw = task;
progress.Total = task["source_seq"].Value <long>();
progress.Current = task["revisions_checked"].Value <long>();
progress.TaskInfo = task.ToString();
c8o.Log._Warn(progress.ToString());
if (progress.Changed)
{
var newProgress = progress;
progress = new C8oProgress(progress);
if (c8oResponseListener != null && c8oResponseListener is C8oResponseProgressListener)
{
param[C8o.ENGINE_PARAMETER_PROGRESS] = newProgress;
(c8oResponseListener as C8oResponseProgressListener).OnProgressResponse(progress, param);
}
}
}
}
}).GetAwaiter();
response = await Execute(request, json);
response.Remove("_c8oMeta");
progress.Total = response["source_last_seq"].Value <long>();
progress.Current = response["source_last_seq"].Value <long>();
progress.TaskInfo = response.ToString();
progress.Status = "Stopped";
progress.Finished = true;
if (c8oResponseListener != null && c8oResponseListener is C8oResponseProgressListener)
{
(c8oResponseListener as C8oResponseProgressListener).OnProgressResponse(progress, param);
}
if (continuous)
{
progress.Status = "Idle";
json["continuous"] = true;
request = HttpWebRequest.CreateHttp(serverUrl + "/_replicate");
request.Method = "POST";
response = await Execute(request, json);
c8o.Log._Warn(response.ToString());
/*
* string localId = response["_local_id"].ToString();
* localId = localId.Substring(0, localId.IndexOf('+'));
*
* do {
* request = HttpWebRequest.CreateHttp(GetDatabaseUrl(fullSyncDatatbaseName) + "/_local/" + localId);
* c8o.Log(C8oLogLevel.WARN, request.RequestUri.ToString());
* request.Method = "GET";
*
* response = await Execute(request);
* c8o.Log(C8oLogLevel.WARN, response.ToString());
* } while(response["hystory"] != null);
*/
}
return(VoidResponse.GetInstance());
}
public void StartPushReplication(IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener)
{
StartReplication(pushFullSyncReplication, parameters, c8oResponseListener);
}
public async override Task <object> HandleSyncRequest(string fullSyncDatatbaseName, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener)
{
await CheckDatabase(fullSyncDatatbaseName);
Task.Run(async() =>
{
await HandleReplicatePushRequest(fullSyncDatatbaseName, parameters, c8oResponseListener);
}).GetAwaiter();
return(await HandleReplicatePullRequest(fullSyncDatatbaseName, parameters, c8oResponseListener));
}
//*** Request handlers ***//
public async Task <object> HandleFullSyncRequest(IDictionary <string, object> parameters, C8oResponseListener listener)
{
parameters = new Dictionary <string, object>(parameters);
// Gets the project and the sequence parameter in order to know which database and which fullSyncrequestable to use
string projectParameterValue = C8oUtils.PeekParameterStringValue(parameters, C8o.ENGINE_PARAMETER_PROJECT, true);
if (!projectParameterValue.StartsWith(FULL_SYNC_PROJECT))
{
throw new ArgumentException(C8oExceptionMessage.InvalidParameterValue(projectParameterValue, "its don't start with " + FULL_SYNC_PROJECT));
}
string fullSyncRequestableValue = C8oUtils.PeekParameterStringValue(parameters, C8o.ENGINE_PARAMETER_SEQUENCE, true);
// Gets the fullSync requestable and gets the response from this requestable
FullSyncRequestable fullSyncRequestable = FullSyncRequestable.GetFullSyncRequestable(fullSyncRequestableValue);
if (fullSyncRequestable == null)
{
throw new ArgumentException(C8oExceptionMessage.InvalidParameterValue(C8o.ENGINE_PARAMETER_PROJECT, C8oExceptionMessage.UnknownValue("fullSync requestable", fullSyncRequestableValue)));
}
// Gets the database name if this is not specified then if takes the default database name
string databaseName = projectParameterValue.Substring(C8oFullSync.FULL_SYNC_PROJECT.Length);
if (databaseName.Length < 1)
{
databaseName = c8o.DefaultDatabaseName;
if (databaseName == null)
{
throw new ArgumentException(C8oExceptionMessage.InvalidParameterValue(C8o.ENGINE_PARAMETER_PROJECT, C8oExceptionMessage.MissingValue("fullSync database name")));
}
}
Object response;
try
{
response = await fullSyncRequestable.HandleFullSyncRequest(this, databaseName, parameters, listener);
}
catch (C8oException e)
{
throw e;
}
catch (Exception e)
{
throw new C8oException(C8oExceptionMessage.FullSyncRequestFail(), e);
}
if (response == null)
{
throw new C8oException(C8oExceptionMessage.couchNullResult());
}
response = HandleFullSyncResponse(response, listener);
return(response);
}
public abstract Task <object> HandleReplicatePushRequest(string fullSyncDatatbaseName, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener);
private void StartReplication(FullSyncReplication fullSyncReplication, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener)
{
bool continuous;
bool cancel = false;
if (parameters.ContainsKey("live"))
{
continuous = parameters["live"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase);
}
else if (parameters.ContainsKey("continuous"))
{
continuous = parameters["continuous"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase);
}
else
{
continuous = false;
}
if (parameters.ContainsKey("cancel"))
{
cancel = parameters["cancel"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase);
}
var rep = GetReplication(fullSyncReplication);
var _progress = new C8oProgress();
_progress.Raw = rep;
_progress.Pull = rep.IsPull;
if (cancel)
{
StopReplication(fullSyncReplication);
_progress.Finished = true;
if (c8oResponseListener != null && c8oResponseListener is C8oResponseProgressListener)
{
(c8oResponseListener as C8oResponseProgressListener).OnProgressResponse(_progress, null);
}
return;
}
var param = new Dictionary <string, object>(parameters);
rep.Changed +=
fullSyncReplication.changeListener =
new EventHandler <ReplicationChangeEventArgs>((source, changeEvt) =>
{
var progress = _progress;
progress.Total = rep.ChangesCount;
progress.Current = rep.CompletedChangesCount;
progress.TaskInfo = C8oFullSyncTranslator.DictionaryToString(rep.ActiveTaskInfo);
progress.Status = "" + rep.Status;
progress.Finished = rep.Status != ReplicationStatus.Active;
if (progress.Changed)
{
_progress = new C8oProgress(progress);
if (c8oResponseListener != null && c8oResponseListener is C8oResponseProgressListener)
{
param[C8o.ENGINE_PARAMETER_PROGRESS] = progress;
(c8oResponseListener as C8oResponseProgressListener).OnProgressResponse(progress, param);
}
}
if (progress.Finished)
{
StopReplication(fullSyncReplication);
if (continuous)
{
long lastCurrent = progress.Current;
rep = GetReplication(fullSyncReplication);
_progress.Raw = rep;
_progress.Continuous = true;
rep.Continuous = true;
rep.Changed +=
fullSyncReplication.changeListener =
new EventHandler <ReplicationChangeEventArgs>((src, chEvt) =>
{
progress = _progress;
progress.Total = rep.ChangesCount;
progress.Current = rep.CompletedChangesCount;
progress.TaskInfo = C8oFullSyncTranslator.DictionaryToString(rep.ActiveTaskInfo);
progress.Status = "" + rep.Status;
//if (progress.Current > lastCurrent && progress.Changed)
if (progress.Changed)
{
_progress = new C8oProgress(progress);
if (c8oResponseListener != null && c8oResponseListener is C8oResponseProgressListener)
{
param[C8o.ENGINE_PARAMETER_PROGRESS] = progress;
(c8oResponseListener as C8oResponseProgressListener).OnProgressResponse(progress, param);
}
}
});
rep.Start();
}
}
});
rep.Start();
}
internal async Task <object> HandleFullSyncRequest(C8oFullSync c8oFullSync, String databaseNameName, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListner)
{
return(await handleFullSyncrequestOp(c8oFullSync, databaseNameName, parameters, c8oResponseListner));
}
public async override Task <object> HandleReplicatePushRequest(string fullSyncDatatbaseName, IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener)
{
await CheckDatabase(fullSyncDatatbaseName);
return(await postReplicate(fullSyncDatatbaseName, parameters, c8oResponseListener, false));
}
public static string WrongListener(C8oResponseListener c8oListener)
{
return("The C8oListener class " + C8oUtils.GetObjectClassName(c8oListener) + " is not handled");
}
//*** Replication ***//
public void StartAllReplications(IDictionary <string, object> parameters, C8oResponseListener c8oResponseListener)
{
StartPullReplication(parameters, c8oResponseListener);
StartPushReplication(parameters, c8oResponseListener);
}
