public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
Tracer.Enter("closeimportconnectionresults");
try
{
CloseRunspace();
CloseImportConnectionResults cicr = new CloseImportConnectionResults();
Tracer.TraceInformation("custom-data {0}", importRunStep.CustomData);
Tracer.TraceInformation("close-reason {0}", importRunStep.Reason);
if (importRunStep.Reason == CloseReason.Normal)
{
cicr.CustomData = importRunStep.CustomData;
}
Dispose();
return(cicr);
}
catch (Exception ex)
{
Tracer.TraceError("closeimportconnection", ex);
throw;
}
finally
{
Tracer.Exit("closeimportconnectionresults");
}
}
/// <summary>
/// Closes the import session
/// </summary>
/// <param name="importRunStep">The current run step</param>
/// <returns>Results of the import session close</returns>
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
try
{
CloseImportConnectionResults results = new CloseImportConnectionResults();
if (this.importResponse != null)
{
results.CustomData = this.importResponse.Watermark;
ImportReleaseRequest request = new ImportReleaseRequest();
request.Context = this.importResponse.Context;
request.NormalTermination = importRunStep.Reason == CloseReason.Normal;
this.client.ImportEnd(request);
}
this.Close();
Logger.WriteLine("Import Complete");
Logger.WriteSeparatorLine('*');
return(results);
}
catch (Exception ex)
{
Logger.WriteException(ex);
throw;
}
}
public void GetDeltaImport()
{
using (SQLManagementAgent ma = new SQLManagementAgent())
{
Configuration.Schema = ma.DefaultSchemaXml.XmlDeserializeFromString <SchemaConfiguration>();
Schema schema = ma.GetSchemaDetached();
// first get full data to get deltawatermark
ma.Schema = schema;
ma.ImportType = OperationType.Delta;
ma.CustomData = "140180";
ma.PageSize = 1;
System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParams = null;
ma.OpenImportConnectionDetached(configParams, schema, null);
GetImportEntriesRunStep rs = new GetImportEntriesRunStep();
GetImportEntriesResults rest = new GetImportEntriesResults();
rest.MoreToImport = true;
while (rest.MoreToImport)
{
rest = ma.GetImportEntriesDetached(rs);
}
CloseImportConnectionRunStep dummyCloseImportRunStep = null;
ma.CloseImportConnectionDetached(dummyCloseImportRunStep);
}
}
public CloseImportConnectionResults CloseImportConnectionDetached(CloseImportConnectionRunStep importRunStep)
{
Tracer.Enter(nameof(CloseImportConnectionDetached));
CloseImportConnectionResults result = new CloseImportConnectionResults();
try
{
if (Configuration.RunAfterImport)
{
List <SqlParameter> parameters = new List <SqlParameter>();
parameters.Add(new SqlParameter("importtype", ImportType.ToString()));
parameters.Add(new SqlParameter("customdata", CustomData));
methods.RunStoredProcedure(Configuration.ImportCommandAfter, parameters);
parameters.Clear();
parameters = null;
}
methods.CloseConnection();
if (importAnchors != null)
{
importAnchors.Clear();
importAnchors = null;
}
GC.Collect();
}
catch (Exception ex)
{
Tracer.TraceError(nameof(CloseImportConnectionDetached), ex);
throw;
}
finally
{
Tracer.Exit(nameof(CloseImportConnectionDetached));
}
return(result);
}
// CloseImportConnection
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep _importRunStepInfo)
{
utils.Logger(TraceEventType.Information,
ConstDefinition.ID0600_START_CLOSEIMPORTCONNECTION,
ConstDefinition.MSG0600_START_CLOSEIMPORTCONNECTION);
return(new CloseImportConnectionResults());
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
CloseImportConnectionResults closeImportConnectionResults = new CloseImportConnectionResults();
closeImportConnectionResults.CustomData = _currentRuntimeStamp;
return(closeImportConnectionResults);
}
//private List<CSEntryChange> ConvertToCsentries(List<object> currentImportBatchEntities)
//{
// //TODO: throw error or warning?
// if (currentImportBatchEntities.Count == 0)
// return new List<CSEntryChange>();
// var contactCsentries = new List<CSEntryChange>();
// string typeName = currentImportBatchEntities.First().GetType().Name;
// List<string> usedAttributes = _schemaTypes.Types[typeName].Attributes
// .Select(attribute => attribute.Name).ToList();
// if (_schemaTypes.Types[typeName].AnchorAttributes.Any())
// {
// usedAttributes.AddRange(_schemaTypes.Types[typeName].AnchorAttributes.Select(attribute => attribute.Name));
// }
// foreach (object contact in currentImportBatchEntities)
// {
// CSEntryChange csentry = CSEntryChange.Create();
// //TODO: change csentryconverter to automatically map name from type name. Setting of ObjectType can then be removed
// csentry.ObjectType = typeName;
// csentry.ObjectModificationType = ObjectModificationType.Add;
// try
// {
// //List<AttributeChange> attributes = CsentryConverter.GetCsentryAttributes(contact);
// List<AttributeChange> attributes = CsentryConverter.GetCsentryAttributes(contact, usedAttributes);
// attributes.ForEach(atr => csentry.AttributeChanges.Add(atr));
// contactCsentries.Add(csentry);
// }
// catch (Exception ex)
// {
// csentry.ErrorCodeImport = MAImportError.ImportErrorCustomContinueRun;
// csentry.ErrorDetail = ex.ToString();
// Logger.Log.Error(ex);
// }
// }
// return contactCsentries;
//}
public virtual CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
foreach (var repoContainer in _objectSources)
{
repoContainer.Dispose();
}
return(new CloseImportConnectionResults());
}
/// <summary>
/// Closes the import session
/// </summary>
/// <param name="importRunStepInfo">The current run step</param>
/// <returns>Results of the import session close</returns>
CloseImportConnectionResults IMAExtensible2CallImport.CloseImportConnection(CloseImportConnectionRunStep importRunStepInfo)
{
try
{
OperationBase operation;
if (this.ImportType == OperationType.Delta)
{
operation = MAConfig.GlobalOperations.FirstOrDefault(t => t is ImportDeltaEndOperation);
}
else
{
operation = MAConfig.GlobalOperations.FirstOrDefault(t => t is ImportFullEndOperation);
}
if (operation != null)
{
try
{
SshConnection.ExecuteOperation(operation);
}
catch (Exception ex)
{
Logger.WriteLine("Could not perform import end operation");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("Import end operation failed", ex);
}
}
try
{
SshConnection.CloseSshConnection();
}
catch (Exception ex)
{
Logger.WriteLine("Could not close SSH connection");
Logger.WriteException(ex);
}
Logger.WriteLine("Import Complete");
Logger.WriteSeparatorLine('*');
}
catch (ExtensibleExtensionException)
{
throw;
}
catch (Exception ex)
{
Logger.WriteLine("A exception occured during the open export connection operartion");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("An exception occured during the open export connection operation", ex);
}
return(new CloseImportConnectionResults());
}
/// <summary>
/// Used by the management agent to allow for code cleanup.
/// </summary>
/// <param name="importRunStep"></param>
/// <returns></returns>
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
_customersEnumerator = null;
_customersInfo = null;
_customers = null;
_users = null;
_usersEnumerator = null;
_customersInfoEnumerator.Dispose();
return(new CloseImportConnectionResults());
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
if (this.importRunStepParameters.ImportType == OperationType.Full)
{
// We just performed a full import so clear the queue
CSEntryChangeQueue.Clear();
}
// Save the remaining items in the queue. If we have done a full import, the queue will be empty, and will clear any existing delta records
CSEntryChangeQueue.SaveQueue(this.filename, this.operationSchema);
return(new CloseImportConnectionResults());
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStepInfo)
{
try
{
this.CloseRSAConnection();
return(new CloseImportConnectionResults());
}
catch (Exception ex)
{
EmailError(ex);
throw ex;
}
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
logger.Info("Closing import connection: {0}", importRunStep.Reason);
if (this.importContext == null)
{
logger.Trace("No import context detected");
return(new CloseImportConnectionResults());
}
this.importContext.Timer.Stop();
if (importRunStep.Reason != CloseReason.Normal)
{
if (this.importContext.CancellationTokenSource != null)
{
logger.Info("Cancellation request received");
this.importContext.CancellationTokenSource.Cancel();
this.importContext.CancellationTokenSource.Token.WaitHandle.WaitOne();
logger.Info("Cancellation completed");
}
}
logger.Info("Import operation complete");
logger.Info($"Imported {this.importContext.ImportedItemCount} objects");
if (this.importContext.ImportedItemCount > 0 && this.importContext.Timer.Elapsed.TotalSeconds > 0)
{
if (this.importContext.ProducerDuration.TotalSeconds > 0)
{
logger.Info($"CSEntryChange production duration: {this.importContext.ProducerDuration}");
logger.Info($"CSEntryChange production speed: {(this.importContext.ImportedItemCount / this.importContext.ProducerDuration.TotalSeconds):N2} obj/sec");
}
logger.Info($"Import duration: {this.importContext.Timer.Elapsed}");
logger.Info($"Import speed: {(this.importContext.ImportedItemCount / this.importContext.Timer.Elapsed.TotalSeconds):N2} obj/sec");
}
if (this.importContext.OutgoingWatermark?.Any() == true)
{
string wm = JsonConvert.SerializeObject(this.importContext.OutgoingWatermark);
logger.Trace($"Watermark: {wm}");
return(new CloseImportConnectionResults(wm));
}
else
{
return(new CloseImportConnectionResults());
}
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
Logger.WriteLine("Closing import connection: {0}", importRunStep.Reason);
try
{
if (importRunStep.Reason != CloseReason.Normal)
{
this.cancellationToken?.Cancel();
}
if (this.importRunStep.ImportType == OperationType.Full)
{
CSEntryChangeQueue.Clear();
CSEntryChangeQueue.SaveQueue(this.DeltaPath, this.operationSchemaTypes);
Logger.WriteLine("Cleared delta file");
}
else
{
Logger.WriteLine("Writing {0} delta entries to file", CSEntryChangeQueue.Count);
CSEntryChangeQueue.SaveQueue(this.DeltaPath, this.operationSchemaTypes);
}
}
catch (Exception ex)
{
Logger.WriteLine("An unexpected error occurred");
Logger.WriteException(ex);
throw;
}
Logger.WriteSeparatorLine('*');
Logger.WriteLine("Operation statistics");
Logger.WriteLine("Import objects: {0}", this.opCount);
Logger.WriteLine("Operation time: {0}", this.timer.Elapsed);
Logger.WriteLine("Ops/sec: {0:N3}", this.opCount / this.timer.Elapsed.TotalSeconds);
Logger.WriteSeparatorLine('*');
return(new CloseImportConnectionResults(null));
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
throw new NotImplementedException();
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
return(new CloseImportConnectionResults());
}
CloseImportConnectionResults IMAExtensible2CallImport.CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
return(CloseImportConnectionDetached(importRunStep));
}
