public SDKClusterDataSource(INuiRuntime nuiRuntime, IClusterFactory clusterFactory, IDepthPointFilter <ImageFrame> filter)
: base(nuiRuntime)
{
this.CurrentValue = new ClusterCollection();
this.clusterFactory = clusterFactory;
this.filter = filter;
}
public OpenNIClusterDataSource(IDepthPointerDataSource dataSource, IClusterFactory clusterFactory, IDepthPointFilter <IntPtr> filter)
: base(dataSource)
{
this.size = dataSource.Size;
this.CurrentValue = new ClusterCollection();
this.clusterFactory = clusterFactory;
this.filter = filter;
}
public Plugin(IClusterFactory clusterFactory = null)
{
_clusterFactory = clusterFactory ?? new ClusterFactory();
_server = new ServerStatus
{
Connected = false,
WriteConfigured = false
};
}
public SDKClusterDataSource(IKinectSensor nuiRuntime, IClusterFactory clusterFactory, IDepthPointFilter <DepthImageFrame> filter)
: base(nuiRuntime)
{
this.CurrentValue = new ClusterCollection();
this.clusterFactory = clusterFactory;
this.filter = filter;
this.queue = new ConcurrentQueue <DepthImageFrame>();
this.runner = new ActionRunner(() => Process());
}
//public SDKClusterDataSource(IKinectSensor nuiRuntime, IClusterFactory clusterFactory, IDepthPointFilter<DepthImageFrame> filter)
// : base(nuiRuntime) // older version
public SDKClusterDataSource(IKinectSensor nuiRuntime, IClusterFactory clusterFactory, IDepthPointFilter <DepthFrame> filter)
: base(nuiRuntime) // update: using DepthFrame instead of DeothImageFrame
{
this.CurrentValue = new ClusterCollection();
this.clusterFactory = clusterFactory;
this.filter = filter;
//this.queue = new ConcurrentQueue<DepthImageFrame>(); // older version
this.queue = new ConcurrentQueue <DepthFrame>(); // update: using DepthFrame instead of DepthImageFrame
this.runner = new ActionRunner(() => Process());
}
public HandDataFactory(IntSize size, ClusterDataSourceSettings clusteringSettings, ShapeDataSourceSettings shapeSettings, HandDataSourceSettings handSettings)
{
this.clusteringSettings = clusteringSettings;
this.shapeSettings = shapeSettings;
this.handSettings = handSettings;
this.clusterFactory = new KMeansClusterFactory(this.clusteringSettings, size);
this.filter = new PointerDepthPointFilter(size, this.clusteringSettings.MinimumDepthThreshold, this.clusteringSettings.MaximumDepthThreshold, this.clusteringSettings.LowerBorder);
this.shapeFactory = new ClusterShapeFactory(this.shapeSettings);
this.handFactory = new ShapeHandDataFactory(this.handSettings);
}
public HandDataFactory(IntSize size, ClusterDataSourceSettings clusteringSettings, ShapeDataSourceSettings shapeSettings, HandDataSourceSettings handSettings)
{
this.clusteringSettings = clusteringSettings;
this.shapeSettings = shapeSettings;
this.handSettings = handSettings;
this.clusterFactory = new KMeansClusterFactory(this.clusteringSettings, size);
this.filter = new PointerDepthPointFilter(size, this.clusteringSettings.MinimumDepthThreshold, this.clusteringSettings.MaximumDepthThreshold, this.clusteringSettings.LowerBorder);
this.shapeFactory = new ClusterShapeFactory(this.shapeSettings);
this.handFactory = new ShapeHandDataFactory(this.handSettings);
}
public static async Task <ReplicationMetadata> UpsertReplicationMetadata(IClusterFactory clusterFactory, string jobId, ReplicationMetadata metadata)
{
try
{
var bucket = await clusterFactory.GetBucketAsync(Constants.ReplicationMetadataBucket);
var result = await bucket.UpsertAsync(jobId, metadata);
result.EnsureSuccess();
return(result.Value);
}
catch (Exception e)
{
Logger.Error(e, e.Message);
throw;
}
}
/// <summary>Ctor
/// </summary>
public FastDFSClient(IExecuter executer, IClusterFactory clusterFactory)
{
_executer = executer;
_clusterFactory = clusterFactory;
}
public static async Task ReconcileReplicationJob(IClusterFactory clusterFactory, PrepareWriteRequest request)
{
// get request settings
var replicationSettings =
JsonConvert.DeserializeObject <ConfigureReplicationFormData>(request.Replication.SettingsJson);
var safeGoldenBucketName =
string.Concat(replicationSettings.GoldenBucketName.Where(c => !char.IsWhiteSpace(c)));
var safeVersionBucketName =
string.Concat(replicationSettings.VersionBucketName.Where(c => !char.IsWhiteSpace(c)));
Logger.Info(
$"Golden Bucket: {safeGoldenBucketName} Version Bucket: {safeVersionBucketName} job: {request.DataVersions.JobId}");
// get previous metadata
Logger.Info($"Getting previous metadata job: {request.DataVersions.JobId}");
var previousMetadata = await GetPreviousReplicationMetadata(clusterFactory, request.DataVersions.JobId);
Logger.Info($"Got previous metadata job: {request.DataVersions.JobId}");
// create current metadata
Logger.Info($"Generating current metadata job: {request.DataVersions.JobId}");
var metadata = new ReplicationMetadata
{
ReplicatedShapeId = request.Schema.Id,
ReplicatedShapeName = request.Schema.Name,
Timestamp = DateTime.Now,
Request = request
};
Logger.Info($"Generated current metadata job: {request.DataVersions.JobId}");
// check if changes are needed
if (previousMetadata == null)
{
Logger.Info($"No Previous metadata creating buckets job: {request.DataVersions.JobId}");
await clusterFactory.EnsureBucketAsync(safeGoldenBucketName);
await clusterFactory.EnsureBucketAsync(safeVersionBucketName);
Logger.Info($"Created buckets job: {request.DataVersions.JobId}");
}
else
{
var dropGoldenReason = "";
var dropVersionReason = "";
var previousReplicationSettings =
JsonConvert.DeserializeObject <ConfigureReplicationFormData>(previousMetadata.Request.Replication
.SettingsJson);
// check if golden bucket name changed
if (previousReplicationSettings.GoldenBucketName != replicationSettings.GoldenBucketName)
{
dropGoldenReason = GoldenNameChange;
}
// check if version bucket name changed
if (previousReplicationSettings.VersionBucketName != replicationSettings.VersionBucketName)
{
dropVersionReason = VersionNameChange;
}
// check if job data version changed
if (metadata.Request.DataVersions.JobDataVersion > previousMetadata.Request.DataVersions.JobDataVersion)
{
dropGoldenReason = JobDataVersionChange;
dropVersionReason = JobDataVersionChange;
}
// check if shape data version changed
if (metadata.Request.DataVersions.ShapeDataVersion >
previousMetadata.Request.DataVersions.ShapeDataVersion)
{
dropGoldenReason = ShapeDataVersionChange;
dropVersionReason = ShapeDataVersionChange;
}
// drop previous golden bucket
if (dropGoldenReason != "")
{
var safePreviousGoldenBucketName =
string.Concat(previousReplicationSettings.GoldenBucketName.Where(c => !char.IsWhiteSpace(c)));
await clusterFactory.DeleteBucketAsync(safePreviousGoldenBucketName);
await clusterFactory.EnsureBucketAsync(safeGoldenBucketName);
}
// drop previous version bucket
if (dropVersionReason != "")
{
var safePreviousVersionBucketName =
string.Concat(previousReplicationSettings.VersionBucketName.Where(c => !char.IsWhiteSpace(c)));
await clusterFactory.DeleteBucketAsync(safePreviousVersionBucketName);
await clusterFactory.EnsureBucketAsync(safeVersionBucketName);
}
}
// save new metadata
Logger.Info($"Updating metadata job: {request.DataVersions.JobId}");
await UpsertReplicationMetadata(clusterFactory, request.DataVersions.JobId, metadata);
Logger.Info($"Updated metadata job: {request.DataVersions.JobId}");
}
/// <summary>
/// Adds and removes records to local replication db
/// Adds and updates available shapes
/// </summary>
/// <param name="clusterFactory"></param>
/// <param name="schema"></param>
/// <param name="record"></param>
/// <param name="config"></param>
/// <param name="responseStream"></param>
/// <returns>Error message string</returns>
public static async Task <string> WriteRecord(IClusterFactory clusterFactory, Schema schema, Record record,
ConfigureReplicationFormData config, IServerStreamWriter <RecordAck> responseStream)
{
// debug
Logger.Debug($"Starting timer for {record.RecordId}");
var timer = Stopwatch.StartNew();
try
{
// debug
Logger.Debug(JsonConvert.SerializeObject(record, Formatting.Indented));
// semaphore
await ReplicationSemaphoreSlim.WaitAsync();
// setup
var safeShapeName = schema.Name;
var safeGoldenBucketName =
string.Concat(config.GoldenBucketName.Where(c => !char.IsWhiteSpace(c)));
var safeVersionBucketName =
string.Concat(config.VersionBucketName.Where(c => !char.IsWhiteSpace(c)));
var goldenBucket = await clusterFactory.GetBucketAsync(safeGoldenBucketName);
var versionBucket = await clusterFactory.GetBucketAsync(safeVersionBucketName);
// transform data
var recordVersionIds = record.Versions.Select(v => v.RecordId).ToList();
var recordData = GetNamedRecordData(schema, record.DataJson);
recordData[Constants.NaveegoVersionIds] = recordVersionIds;
// get previous golden record
List <string> previousRecordVersionIds;
if (await goldenBucket.ExistsAsync(record.RecordId))
{
var result = await goldenBucket.GetAsync <Dictionary <string, object> >(record.RecordId);
if (result.Value.ContainsKey(Constants.NaveegoVersionIds))
{
previousRecordVersionIds =
JsonConvert.DeserializeObject <List <string> >(
JsonConvert.SerializeObject(result.Value[Constants.NaveegoVersionIds]));
}
else
{
previousRecordVersionIds = recordVersionIds;
}
}
else
{
previousRecordVersionIds = recordVersionIds;
}
// write data
if (recordData.Count == 0)
{
// delete everything for this record
Logger.Debug($"shapeId: {safeShapeName} | recordId: {record.RecordId} - DELETE");
var result = await goldenBucket.RemoveAsync(record.RecordId);
result.EnsureSuccess();
foreach (var versionId in previousRecordVersionIds)
{
Logger.Debug(
$"shapeId: {safeShapeName} | recordId: {record.RecordId} | versionId: {versionId} - DELETE");
result = await versionBucket.RemoveAsync(versionId);
result.EnsureSuccess();
}
}
else
{
// update record and remove/add versions
Logger.Debug($"shapeId: {safeShapeName} | recordId: {record.RecordId} - UPSERT");
var result = await goldenBucket.UpsertAsync(record.RecordId, recordData);
result.EnsureSuccess();
// delete missing versions
var missingVersions = previousRecordVersionIds.Except(recordVersionIds);
foreach (var versionId in missingVersions)
{
Logger.Debug(
$"shapeId: {safeShapeName} | recordId: {record.RecordId} | versionId: {versionId} - DELETE");
var versionDeleteResult = await versionBucket.RemoveAsync(versionId);
versionDeleteResult.EnsureSuccess();
}
// upsert other versions
foreach (var version in record.Versions)
{
Logger.Debug(
$"shapeId: {safeShapeName} | recordId: {record.RecordId} | versionId: {version.RecordId} - UPSERT");
var versionData = GetNamedRecordData(schema, version.DataJson);
var versionUpsertResult = await versionBucket.UpsertAsync(version.RecordId, versionData);
versionUpsertResult.EnsureSuccess();
}
}
var ack = new RecordAck
{
CorrelationId = record.CorrelationId,
Error = ""
};
await responseStream.WriteAsync(ack);
timer.Stop();
Logger.Debug($"Acknowledged Record {record.RecordId} time: {timer.ElapsedMilliseconds}");
return("");
}
catch (Exception e)
{
Logger.Error(e, $"Error replicating records {e.Message}");
// send ack
var ack = new RecordAck
{
CorrelationId = record.CorrelationId,
Error = e.Message
};
await responseStream.WriteAsync(ack);
timer.Stop();
Logger.Debug($"Failed Record {record.RecordId} time: {timer.ElapsedMilliseconds}");
return(e.Message);
}
finally
{
ReplicationSemaphoreSlim.Release();
}
}
/// <summary>Ctor
/// </summary>
public DefaultExecuter(IClusterFactory clusterFactory)
{
_clusterFactory = clusterFactory;
}
// Token: 0x0600075E RID: 1886 RVA: 0x000240B7 File Offset: 0x000222B7
public static void SetTestClusterFactory(IClusterFactory testClusterFactory, IMockableCluster amClusterOverride)
{
ClusterFactory.instance = testClusterFactory;
MockableCluster.SetTestInstance(amClusterOverride);
}
public static async Task <ReplicationMetadata> GetPreviousReplicationMetadata(IClusterFactory clusterFactory,
string jobId)
{
try
{
var bucket = await clusterFactory.GetBucketAsync(Constants.ReplicationMetadataBucket);
// check if metadata exists
if (!await bucket.ExistsAsync(jobId))
{
// no metadata
return(null);
}
// metadata exists
var result = await bucket.GetAsync <ReplicationMetadata>(jobId);
result.EnsureSuccess();
return(result.Value);
}
catch (Exception e)
{
Logger.Error(e, e.Message);
throw;
}
}
