public void GetOperationTest()
{
var data = new OperationData { Id = "1", State = OperationState.Succeeded.ToString() };
var dataContextMock = new Mock<IMediaDataServiceContext>();
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var fakeResponse = new OperationData[] { data };
int exceptionCount = 2;
dataContextMock.Setup((ctxt) => ctxt
.Execute<OperationData>(It.IsAny<Uri>()))
.Returns(() =>
{
if (--exceptionCount > 0) throw fakeException;
return fakeResponse;
});
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
var actual = _mediaContext.Operations.GetOperation(data.Id);
Assert.AreEqual(data.Id, actual.Id);
dataContextMock.Verify((ctxt) => ctxt.Execute<OperationData>(It.IsAny<Uri>()), Times.Exactly(2));
}
public Task<OperationData> GetNextAsync(CancellationToken cancellationToken)
{
OperationData result = null;
while (this.progressVector.MoveNext())
{
this.logger.Log($"CopyContext.GetNextAsync returning record {this.progressVector.Current}");
// Copy the stream into the result.
var progressIndicator = this.serializer.Serialize(this.progressVector.Current);
if (result == null)
{
result = new OperationData(progressIndicator);
}
else
{
result.Add(progressIndicator);
}
}
if (result == null)
{
this.logger.Log("CopyContext.GetNextAsync signalling completion");
}
return Task.FromResult(result);
}
Task <long> ITransactionalReplicator.BeginTransactionAsync(
Transaction transaction,
OperationData metaData,
OperationData undo,
OperationData redo,
object operationContext,
long stateProviderId)
{
return(this.stateManager.BeginTransactionAsync(
transaction,
metaData,
undo,
redo,
operationContext,
stateProviderId));
}
private void UpdateGridRow(OperationData op, DataGridViewRow gridRow)
{
gridRow.Tag = op.Name;
if (gridRow.Cells.Count == 0)
{
for (int i = 0; i < 5; i++)
{
gridRow.Cells.Add(new DataGridViewTextBoxCell());
}
}
gridRow.Cells[0].Value = op.Name;
gridRow.Cells[1].Value = op.Calls;
gridRow.Cells[2].Value = op.Duration.TotalSeconds.ToString("N3");
gridRow.Cells[3].Value = op.SentBytes.ToString("N0");
gridRow.Cells[4].Value = op.ReceivedBytes.ToString("N0");
}
private ISOTimeLog ExportTimeLog(OperationData operation, IEnumerable <SpatialRecord> spatialRecords, string dataPath)
{
ISOTimeLog isoTimeLog = new ISOTimeLog();
//ID
string id = operation.Id.FindIsoId() ?? GenerateId(5);
isoTimeLog.Filename = id;
isoTimeLog.TimeLogType = 1; // TimeLogType TLG.C is a required attribute. Currently only the value "1" is defined.
ExportIDs(operation.Id, id);
List <DeviceElementUse> deviceElementUses = operation.GetAllSections();
List <WorkingData> workingDatas = deviceElementUses.SelectMany(x => x.GetWorkingDatas()).ToList();
ISOTime isoTime = new ISOTime();
isoTime.HasStart = true;
isoTime.Type = ISOTimeType.Effective;
isoTime.DataLogValues = ExportDataLogValues(workingDatas, deviceElementUses).ToList();
//Set the timelog data definition for PTN
ISOPosition position = new ISOPosition();
position.HasPositionNorth = true;
position.HasPositionEast = true;
position.HasPositionUp = true;
position.HasPositionStatus = true;
position.HasPDOP = false;
position.HasHDOP = false;
position.HasNumberOfSatellites = false;
position.HasGpsUtcTime = false;
position.HasGpsUtcTime = false;
isoTime.Positions.Add(position);
//Write XML
TaskDocumentWriter xmlWriter = new TaskDocumentWriter();
xmlWriter.WriteTimeLog(dataPath, isoTimeLog, isoTime);
//Write BIN
var binFilePath = Path.Combine(dataPath, isoTimeLog.Filename + ".bin");
BinaryWriter writer = new BinaryWriter(_dataLogValueOrdersByWorkingDataID);
writer.Write(binFilePath, workingDatas.ToList(), spatialRecords);
return(isoTimeLog);
}
public void GivenOperationDataWithMaxDepthOneWhenGetAllSectionsThenAllSections()
{
var operationData = new OperationData {
MaxDepth = 1
};
var depth0Sections = new List <DeviceElementUse> {
new DeviceElementUse()
};
var depth1Sections = new List <DeviceElementUse> {
new DeviceElementUse()
};
var depth2Sections = new List <DeviceElementUse> {
new DeviceElementUse()
};
var depth3Sections = new List <DeviceElementUse> {
new DeviceElementUse()
};
operationData.GetDeviceElementUses = depth =>
{
if (depth == 0)
{
return(depth0Sections);
}
if (depth == 1)
{
return(depth1Sections);
}
if (depth == 2)
{
return(depth2Sections);
}
if (depth == 3)
{
return(depth3Sections);
}
return(null);
};
var result = operationData.GetAllSections();
Assert.AreEqual(2, result.Count);
Assert.Contains(depth0Sections.First(), result);
Assert.Contains(depth1Sections.First(), result);
}
private void OnOperationsUpdated(IReadOnlyList <OperationData> ops)
{
if (monitor == null)
{
return;
}
var shownOps = new Dictionary <string, DataGridViewRow>();
var rowsToRemove = new List <int>();
for (int i = 0; i < operationsGrid.Rows.Count; i++)
{
string action = (string)operationsGrid.Rows[i].Tag;
OperationData op = ops.FirstOrDefault(x => x.Name == action);
if (op != null)
{
shownOps.Add(action, operationsGrid.Rows[i]);
}
else
{
rowsToRemove.Add(i);
}
}
rowsToRemove.Reverse();
foreach (int index in rowsToRemove)
{
operationsGrid.Rows.RemoveAt(index);
}
// Now we may have some rows to add or update
foreach (var op in ops)
{
if (shownOps.ContainsKey(op.Name))
{
// Just update
UpdateGridRow(op, shownOps[op.Name]);
}
else
{
var newRow = (DataGridViewRow)operationsGrid.RowTemplate.Clone();
UpdateGridRow(op, newRow);
operationsGrid.Rows.Add(newRow);
}
}
operationsGrid.ClearSelection();
}
private void InitOperationData()
{
string jsonText = File.ReadAllText(Application.dataPath + "/JsonData/Operation.json", Encoding.UTF8);
JSONObject j = new JSONObject(jsonText);
foreach (var tmp in j.list)
{
uint id = (uint)tmp["id"].n;
operationData[id] = new OperationData
{
id = id,
name = tmp["name"].str,
enemyType = (uint)tmp["enemy_type"].n
};
}
}
protected int CalculateWireSize(OperationData data)
{
// Number of Array segments for data.
var size = sizeof(int);
if (data == null)
{
return(size);
}
foreach (var item in data)
{
size += sizeof(int);
}
return(size);
}
/// <summary>
/// Deserializes a set of bytes into a redo/undo operation.
/// </summary>
/// <param name="operationData">Bytes to deserialize.</param>
/// <param name="traceType">trace Id</param>
/// <returns></returns>
public static RedoUndoOperationData FromBytes(OperationData operationData, string traceType)
{
// Check arguments.
if (operationData == null)
{
throw new ArgumentNullException(SR.Error_OperationData);
}
// OperationData must contain at least the metadata and key (values may be null).
if (operationData.Count == 0)
{
throw new ArgumentException(SR.Error_OperationData);
}
// Array segment zero contains the metadata
var metadataBytes = operationData[0];
using (var stream = new MemoryStream(metadataBytes.Array, metadataBytes.Offset, metadataBytes.Count))
using (var reader = new BinaryReader(stream, Encoding.Unicode))
{
// Read how many value and new value segments there are
var valueSegmentCount = reader.ReadInt32();
var newValueSegmentCount = reader.ReadInt32();
// Check the actual number of segments matches the expected number (metadata, key, and count for the value segments)
var expectedSegmentCount = 1 + valueSegmentCount + newValueSegmentCount;
if (operationData.Count != expectedSegmentCount)
{
throw new InvalidDataException(
string.Format(
System.Globalization.CultureInfo.CurrentCulture,
SR.Error_MetadataOperationData_ExpectedSegments,
operationData.Count,
expectedSegmentCount));
}
// Read values.
var startSegmentIndex = 1;
var valueBytes = GetValueBytes(operationData, startSegmentIndex, valueSegmentCount);
startSegmentIndex += valueSegmentCount;
var newValueBytes = GetValueBytes(operationData, startSegmentIndex, newValueSegmentCount);
return(new RedoUndoOperationData(valueBytes, newValueBytes, traceType));
}
}
/// <summary>
/// The set current state.
/// </summary>
/// <param name="stateRecordNumber">
/// The state record number.
/// </param>
/// <param name="data">
/// The data.
/// </param>
Task IStateProvider2.SetCurrentStateAsync(long stateRecordNumber, OperationData data)
{
var count = data?.Count ?? 0;
var length = data?.Sum(_ => _.Count) ?? 0;
Trace.TraceInformation(
"[" + this.partitionId + "] " + "SetCurrentState({0}, [{1} operations, {2}b])",
stateRecordNumber,
count,
length);
/*
* indexex: LSN, row key + partition key
*/
return(Task.FromResult(0));
}
public void PostCommit(IServiceOperationRecorderContext recorderContext)
{
var request = (ConfigurationDocumentRequestBase)recorderContext.Request;
var data = new OperationData
{
Operation = "SetConfigurationDocument",
DocumentName = request.DocumentKey.DocumentName,
DocumentVersion = request.DocumentKey.Version.ToString(),
DocumentUser = request.DocumentKey.User ?? "{application}",
DocumentInstanceKey = StringUtilities.NullIfEmpty(request.DocumentKey.InstanceKey) ?? "{default}"
};
var xml = JsmlSerializer.Serialize(data, "Audit");
recorderContext.Write(data.Operation, xml);
}
internal static OperationData WriteRecord(
LogRecord record,
BinaryWriter bw,
bool isPhysicalWrite = true,
bool setRecordLength = true,
bool forceRecomputeOffsets = false)
{
// NOTE:- The binary writer is not where the real data is written
// It is only passed in to avoid each log record from creating its own writer
// The real data of the log record is returned in the operation data
// As a result, reset the position of the writer before starting to write
bw.BaseStream.Position = 0;
var operationData = new OperationData();
record.Write(bw, operationData, isPhysicalWrite, forceRecomputeOffsets);
uint recordLength = 0;
foreach (var data in operationData)
{
recordLength += (uint)data.Count;
}
if (setRecordLength)
{
record.RecordLength = recordLength;
}
var mm = bw.BaseStream as MemoryStream;
var startingPosition = bw.BaseStream.Position;
bw.Write(recordLength);
var arraySegment = new ArraySegment <byte>(
mm.GetBuffer(),
(int)startingPosition,
(int)mm.Position - (int)startingPosition);
// Append and prepend record length in a fixed encoding of sizeof(int) bytes
operationData.Add(arraySegment);
operationData.Insert(0, arraySegment);
return(operationData);
}
/// <summary>
/// Reads the state provider metadata from the next chunk of copy data.
/// </summary>
/// <param name="operationData">The next chunk of copy data.</param>
/// <param name="traceType">Tracing type information.</param>
/// <returns>The copied set of state providers' metadata.</returns>
internal static IEnumerable <SerializableMetadata> ReadCopyData(OperationData operationData, string traceType)
{
if (operationData == null)
{
throw new ArgumentNullException("operationData");
}
if (operationData.Count <= 0)
{
throw new ArgumentException("OperationData contains zero data.", "operationData");
}
// The state manager currently sends a single array segment per operation data.
var itemData = operationData[0];
var operationType =
(StateManagerCopyOperation)itemData.Array[itemData.Offset + itemData.Count - 1];
using (var itemStream = new MemoryStream(itemData.Array, itemData.Offset, itemData.Count - 1))
using (var itemReader = new InMemoryBinaryReader(itemStream))
{
if (operationType == StateManagerCopyOperation.Version)
{
// Verify the copy protocol version is known.
var copyProtocolVersion = itemReader.ReadInt32();
if (copyProtocolVersion != CopyProtocolVersion)
{
throw new InvalidDataException(
string.Format(CultureInfo.CurrentCulture, SR.Error_SMFile_UnknownCopyProtocol_OneArg, copyProtocolVersion));
}
}
else if (operationType == StateManagerCopyOperation.StateProviderMetadata)
{
// Read the chunk of state provider metadata.
while (itemStream.Position < itemStream.Length)
{
yield return(ReadMetadata(itemReader, traceType, true));
}
}
else
{
throw new InvalidDataException(
string.Format(CultureInfo.CurrentCulture, SR.Error_SMFile_UnknownSMCopyOperation_OneArg, operationType));
}
}
}
/// <summary>
/// Returns the metadata for the copied state.
/// </summary>
/// <returns></returns>
/// <remarks>
/// Contains
/// - Version of the copy metadata state.
/// - Progress ProgressVectorEntry of the copied checkpoint.
/// - Copied Checkpoints Epoch
/// - Sequence number of the first operation in the log to be copied.
/// - Sequence number of the copied checkpoints sequence number.
/// - UptoSequence number for the copy provided by the volatile replicator.
/// - Highest possible the state providers could have copied.
/// </remarks>
private OperationData GetCopyStateMetadata()
{
var expectedSize = this.beginCheckpointRecord.ProgressVector.ByteCount;
expectedSize += CopyStateMetadataByteSizeNotIncludingProgressVector;
OperationData result;
using (var stream = new MemoryStream(expectedSize))
{
using (var bw = new BinaryWriter(stream))
{
// First 4 bytes are reserved for the version of the metadata.
bw.Write(CopyStateMetadataVersion);
// TODO: Ask for the size to avoid expanding the memoryStream.
this.beginCheckpointRecord.ProgressVector.Write(bw);
var startingEpoch = this.beginCheckpointRecord.Epoch;
bw.Write(startingEpoch.DataLossNumber);
bw.Write(startingEpoch.ConfigurationNumber);
bw.Write(this.sourceStartingLsn.LSN);
bw.Write(this.beginCheckpointRecord.Lsn.LSN);
bw.Write(this.uptoLsn.LSN);
bw.Write(this.replicatedLogManager.CurrentLogTailLsn.LSN);
Utility.Assert(
expectedSize == stream.Position,
"Position mismatch. Expected {0} Position {1}",
expectedSize, stream.Position);
result = new OperationData(new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Position));
result.Add(CopyProgressVectorOperation);
}
}
var trace = "Copying Log Preamble. SourceStartingLSN: " + this.sourceStartingLsn.LSN
+ " BeginCheckpointLSN: " + this.beginCheckpointRecord.Lsn.LSN + " StateRecordsCoipied: "
+ this.copiedRecordNumber + " CurrentTailSequenceNumber: "
+ this.replicatedLogManager.CurrentLogTailLsn.LSN;
FabricEvents.Events.CopyStreamGetNext(tracer.Type, trace);
return(result);
}
/// <summary>
/// Deserialize the header for the OperationData
/// </summary>
internal void DeserializeContext(
OperationData operationData,
int version,
string traceType)
{
Utility.Assert(
operationData != null,
"{0}: DeserializeContext: Null named operation data during create",
this.TraceType);
Utility.Assert(
operationData.Count > 0,
"{0}:DeserializeContext: Named operation data should have atleast one buffer during create",
this.TraceType);
var headerBufferSPtr = operationData[operationData.Count - 1];
bool isStateProviderDataNull;
using (InMemoryBinaryReader reader = new InMemoryBinaryReader(new MemoryStream(
headerBufferSPtr.Array,
headerBufferSPtr.Offset,
headerBufferSPtr.Count)))
{
this.Version = reader.ReadInt32();
if (this.Version != version)
{
FabricEvents.Events.OnApplyVersionError(traceType, this.Version, version);
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
"Unsupported version {0} on deserialization, current version is {1}",
this.Version,
version));
}
this.StateProviderId = reader.ReadInt64();
isStateProviderDataNull = reader.ReadBoolean();
}
// Remove state manager metadata from data.
operationData.RemoveAt(operationData.Count - 1);
this.OperationData = isStateProviderDataNull ? null : operationData;
}
/// <summary>
/// Runs a test for a specific class and method.
/// </summary>
/// <param name="op">The operation data.</param>
/// <param name="done">The completion callback.</param>
public void HandleOp(OperationData op, Action done)
{
var testOp = (RunTestOperation)op;
var func = GetTestFunc(testOp);
var err = "";
ConsoleProxy.log("Running test: " + testOp.ClassName + "." + testOp.MethodName);
object result = null;
try { result = func(); }
catch (Exception ex)
{
// exceptions indicate test failure
var browser = GetBrowserName();
err = ((browser != null) ? ("[" + browser + "] ") : "") + ex.toString();
ConsoleProxy.log("Test Failed: " + err);
ClientHost.Service.FailTest(err, done);
return;
}
// tests returing null or undefined indicate
// the test is complete and has passed
if (result == null || result == window.undefined)
{
ConsoleProxy.log("Test Passed");
ClientHost.Service.PassTest(done);
return;
}
// if a test result type is returned, the
// result may be deferred due to async execution
if (result is TestResult)
{
CheckAsyncResult((TestResult)result, done);
return;
}
// the return type was not of any expected
// value, return as test failure
ClientHost.Service.FailTest(
"Unexpected test return value. Synchronous tests should return void. " +
"Asynchronous tests should return an object of type TestResult.", done);
}
internal BeginTransactionOperationLogRecord(
Transaction transaction,
OperationData metaData,
OperationData undo,
OperationData redo,
object operationContext,
bool isSingleOperationTransaction)
: base(LogRecordType.BeginTransaction, transaction, null)
{
this.isSingleOperationTransaction = isSingleOperationTransaction;
this.recordEpoch = LogicalSequenceNumber.InvalidEpoch;
this.metaData = metaData;
this.undo = undo;
this.redo = redo;
this.operationContext = operationContext;
this.UpdateApproximateDiskSize();
}
/// <summary>
/// Initializes a new instance of the <see cref="NamedOperationContext"/> class by deserialization from OperationData.
/// </summary>
public NamedOperationData(
OperationData operationData,
int version,
string traceType)
{
// State Manager always at least creates OperationData of one buffer to keeps dispatching information.
Utility.Assert(
operationData != null,
"{0}: NamedOperationData: Null named operation data during create",
traceType);
Utility.Assert(
operationData.Count > 0,
"{0}: NamedOperationData: Named operation data should have atleast one buffer during create, Count: {1}.",
traceType, operationData.Count);
this.DeserializeContext(operationData, version, traceType);
}
public static void ReportOpenDoc()
{
OperationData operation = FindOperation(OperationTypes.kOpenDoc);
if (operation == null)
{
operation = new OperationData(OperationTypes.kOpenDoc);
lock (_lockObject)
{
_allOperations.Add(operation);
}
}
else
{
operation.Count++;
}
}
internal static OperationData ReadOperationData(BinaryReader br)
{
var count = br.ReadInt32();
if (count == NullOperationDataCode)
{
return(null);
}
var operationData = new OperationData();
for (var i = 0; i < count; i++)
{
operationData.Add(ReadBytes(br));
}
return(operationData);
}
private NativeRuntime.IFabricOperationData GetOrCreateOperationData(IOperationData operationData)
{
OperationData managed = operationData as OperationData;
if (managed != null)
{
return(this.operationDataFactory.CreateOperationData(managed));
}
ReadOnlyOperationData native = operationData as ReadOnlyOperationData;
if (native != null)
{
return(native.NativeOperationData);
}
return(null);
}
public void PostCommit(IServiceOperationRecorderContext recorderContext)
{
var request = (ConfigurationDocumentRequestBase)recorderContext.Request;
var data = new OperationData
{
Operation = "SetConfigurationDocument",
DocumentName = request.DocumentKey.DocumentName,
DocumentVersion = request.DocumentKey.Version.ToString(),
DocumentUser = request.DocumentKey.User ?? "{application}",
DocumentInstanceKey = StringUtilities.NullIfEmpty(request.DocumentKey.InstanceKey) ?? "{default}"
};
var xml = JsmlSerializer.Serialize(data, "Audit");
recorderContext.Write(data.Operation, xml);
}
protected override void Write(BinaryWriter bw, OperationData operationData, bool isPhysicalWrite, bool forceRecomputeOffsets)
{
base.Write(bw, operationData, isPhysicalWrite, forceRecomputeOffsets);
var startingPos = bw.BaseStream.Position;
bw.BaseStream.Position += sizeof(int);
bw.Write((int)this.informationEvent);
var endPosition = bw.BaseStream.Position;
var sizeOfSection = checked ((int)(endPosition - startingPos));
bw.BaseStream.Position = startingPos;
bw.Write(sizeOfSection);
bw.BaseStream.Position = endPosition;
operationData.Add(CreateArraySegment(startingPos, bw));
}
/// <summary>
/// Verify <paramref name="result"/> contains the expected operation exactly.
/// </summary>
/// <param name="result">Resulting GeneratedModule object.</param>
/// <param name="expectedOperation">Expected operation info.</param>
private void AssertModuleContainsOperation(GeneratedModule result, OperationData expectedOperation)
{
// Ignore these 11 parameters:
/* Verbose
* Debug
* ErrorAction
* WarningAction
* InformationAction
* ErrorVariable
* WarningVariable
* InformationVariable
* OutVariable
* OutBuffer
* PipelineVariable */
Assert.True(result.Operations.ContainsKey(expectedOperation.OperationId.ToLowerInvariant()));
Assert.Equal(expectedOperation.Parameters.Count, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters.Count - 11);
OperationData actualOperation = result.Operations[expectedOperation.OperationId.ToLowerInvariant()];
foreach (string parmName in expectedOperation.Parameters.Keys)
{
Assert.True(actualOperation.Parameters.ContainsKey(parmName), parmName);
Assert.NotNull(actualOperation.Parameters[parmName].Type);
Assert.Equal(expectedOperation.Parameters[parmName].Type.Type, actualOperation.Parameters[parmName].Type.Type);
Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties.Count, actualOperation.Parameters[parmName].Type.Properties.Count);
foreach (string propertyName in expectedOperation.Parameters[parmName].Type.Properties.Keys)
{
Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].Type, actualOperation.Parameters[parmName].Type.Properties[propertyName].Type);
Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].Name, actualOperation.Parameters[parmName].Type.Properties[propertyName].Name);
Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].JsonName, actualOperation.Parameters[parmName].Type.Properties[propertyName].JsonName);
}
}
if (expectedOperation.ResponseType != null)
{
Assert.NotNull(actualOperation.ResponseType);
Assert.NotNull(actualOperation.ResponseType.ModuleData);
Assert.Equal(expectedOperation.ResponseType.ModuleData.Type, actualOperation.ResponseType.ModuleData.Type);
}
else
{
Assert.Null(actualOperation.ResponseType);
}
}
protected override void Write(BinaryWriter bw, OperationData operationData, bool isPhysicalWrite, bool forceRecomputeOffsets)
{
base.Write(bw, operationData, isPhysicalWrite, forceRecomputeOffsets);
var startingPosition = bw.BaseStream.Position;
bw.BaseStream.Position += sizeof(int);
if (this.linkedPhysicalRecordOffset == InvalidPhysicalRecordOffset || forceRecomputeOffsets == true)
{
Utility.Assert(
this.linkedPhysicalRecord != null || forceRecomputeOffsets == true,
"(this.linkedPhysicalRecord != null)={0}, forceRecomputeOffsets={1}",
this.linkedPhysicalRecord != null,
forceRecomputeOffsets);
if (this.linkedPhysicalRecord == null)
{
this.linkedPhysicalRecordOffset = 0;
}
else
{
Utility.Assert(
this.linkedPhysicalRecord.RecordPosition != InvalidRecordPosition,
"this.linkedPhysicalRecord.RecordPosition != LogRecord.INVALID_RECORD_POSITION");
Utility.Assert(
this.RecordPosition != InvalidRecordPosition,
"this.RecordPosition != LogRecord.INVALID_RECORD_POSITION");
this.linkedPhysicalRecordOffset = this.RecordPosition - this.linkedPhysicalRecord.RecordPosition;
}
}
bw.Write(this.linkedPhysicalRecordOffset);
var endPosition = bw.BaseStream.Position;
var sizeOfSection = checked ((int)(endPosition - startingPosition));
bw.BaseStream.Position = startingPosition;
bw.Write(sizeOfSection);
bw.BaseStream.Position = endPosition;
operationData.Add(CreateArraySegment(startingPosition, bw));
return;
}
/// <summary>
/// Initializes a new instance of the <see cref="NamedOperationContext"/> class with serialize.
/// </summary>
public NamedOperationData(
OperationData operationData,
long stateProviderId,
int version,
string traceType)
{
// #9894884: Native changed Version to metadataCount, keep the old format for now.
Utility.Assert(
stateProviderId != DynamicStateManager.EmptyStateProviderId,
"{0}: NamedOperationData: Id cannot be empty in named operation data",
traceType);
this.OperationData = operationData;
this.StateProviderId = stateProviderId;
this.Version = version;
this.TraceType = traceType;
this.Serialize();
}
private static bool SwitchState(OperationData data, OperationState expectedState, OperationState nextState)
{
if (data.State < expectedState)
{
// Throws to retry and wait until the operation will be in the required state
throw new InvalidOperationException(
$"Operation execution state can't be switched: {data.State} -> {nextState}. Waiting for the {expectedState} state.");
}
if (data.State > expectedState)
{
// Already in the next state, so this event can be just ignored
return false;
}
data.State = nextState;
return true;
}
public virtual IOperation <T, U, V> Make <ProtocolClass>(T model) where ProtocolClass : class, new()
{
IEnumerable <V> context = new V() as IEnumerable <V>;
IOperationContext <V> operationContext = new OperationContext <V>(context);
// TODO move request to context
IOperationData <T> requestOperationData = new OperationData <T>(model);
IOperationRequest <T> operationRequest = new OperationRequest <T>(requestOperationData);
IOperationData <U> responseOperationData = new OperationData <U>(new U());
IOperationResponse <U> operationResponse = new OperationResponse <U>(responseOperationData);
IOperationAction <T, U, V> operationAction = new OperationAction <T, U, V>(operationRequest, operationResponse, operationContext);
var protocol = CreateProtocolInstance <ProtocolClass>(logger, operationAction);
this.protocol = protocol as OperationProtocol <T, U, V>;
return(this);
}
protected override void Write(BinaryWriter bw, OperationData operationData, bool isPhysicalWrite, bool forceRecomputeOffsets)
{
base.Write(bw, operationData, isPhysicalWrite, forceRecomputeOffsets);
var startingPosition = bw.BaseStream.Position;
bw.BaseStream.Position += sizeof(int);
bw.Write(this.isStable);
bw.Write(this.periodicTruncationTimeTicks);
var endPosition = bw.BaseStream.Position;
var sizeOfSection = checked ((int)(endPosition - startingPosition));
bw.BaseStream.Position = startingPosition;
bw.Write(sizeOfSection);
bw.BaseStream.Position = endPosition;
operationData.Add(CreateArraySegment(startingPosition, bw));
}
private static void AreEqual(OperationData operationData, List <TimeScope> timeScopes, TLG tlg, string cardPath)
{
var fileName = tlg.A + ".xml";
var tlgXmlHeaderFilePath = Path.Combine(cardPath, "TASKDATA", fileName);
Assert.IsTrue(File.Exists(tlgXmlHeaderFilePath));
var tims = new XmlReader().ReadTlgXmlData(cardPath, fileName);
TimAssert.AreEqual(timeScopes, tims);
var sections = operationData.GetAllSections();
var meters = sections.SelectMany(x => x.GetWorkingDatas()).ToList();
var adaptSpatialRecords = operationData.GetSpatialRecords();
var binaryReader = new BinaryReader();
var isoSpatialRecords = binaryReader.Read(cardPath, tlg.A + ".bin", tims.First());
IsoSpatialRecordAssert.AreEqual(adaptSpatialRecords, meters, isoSpatialRecords);
}
protected override void Write(BinaryWriter bw, OperationData operationData, bool isPhysicalWrite, bool forceRecomputeOffsets)
{
base.Write(bw, operationData, isPhysicalWrite, forceRecomputeOffsets);
var startingPosition = bw.BaseStream.Position;
// Metadata Size
bw.BaseStream.Position += sizeof(int);
// Future fields
// End of metadata.
var endPosition = bw.BaseStream.Position;
var sizeOfSection = checked ((int)(endPosition - startingPosition));
bw.BaseStream.Position = startingPosition;
bw.Write(sizeOfSection);
bw.BaseStream.Position = endPosition;
operationData.Add(CreateArraySegment(startingPosition, bw));
}
public static List <DeviceElementUse> GetAllSections(this OperationData operationData)
{
if (operationData.GetDeviceElementUses == null)
{
return(new List <DeviceElementUse>());
}
var allSections = new List <DeviceElementUse>();
for (var i = 0; i <= operationData.MaxDepth; i++)
{
var sections = operationData.GetDeviceElementUses(i);
if (sections != null)
{
allSections.AddRange(sections);
}
}
return(allSections);
}
private void talkOperation(OperationData operation)
{
if (operation == null) {
return;
}
StringBuilder sb = new StringBuilder();
sb.Append("operation id: ");
sb.Append(operation.OperationId);
sb.Append(". ");
sb.Append("date: ");
sb.Append(operation.Date.ToLongDateString());
sb.Append(". ");
sb.Append("team: ");
sb.Append(operation.Team);
sb.Append(". ");
sb.Append("process: ");
sb.Append(operation.Process);
sb.Append(". ");
sb.Append("diagnoses: ");
sb.Append(operation.Diagnoses);
sb.Append(". ");
sb.Append("performed: ");
sb.Append(operation.Performed);
sb.Append(". ");
talk(sb.ToString());
}
void IServiceOperationRecorder.PreCommit(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
if (!ShouldCapture(recorderContext, persistenceContext))
return;
_capturedData = Capture(recorderContext, persistenceContext);
// if we need to capture the change-set, it is important that we do so now,
// while the persistence context is still alive, rather than during the
// post-commit phase, where we can get lazy loading exceptions
if (_changeSetIncludes.Any() && recorderContext.ChangeSet != null)
{
var changeSetData = DefaultEntityChangeSetRecorder.WriteChangeSet(_capturedData.Operation, recorderContext.ChangeSet.Changes);
var includedActions = from action in changeSetData.Actions
where action.Type == "Update" && _changeSetIncludes.Contains(action.OID) || _changeSetIncludes.Contains(action.Class)
select (object)action;
_capturedData.ChangeSet = new ChangeSetData { Actions = includedActions.ToList() };
}
}
public async Task<OperationData> GetNextAsync(CancellationToken cancellationToken)
{
// Get the progress of the remote replica.
if (this.catchUpProgressVector == null)
{
var remoteProgress = await this.GetRemoteReplicaProgress();
this.catchUpProgressVector = new ProgressVector(this.localProgress.Excluding(remoteProgress));
this.logger.Log(
"CopyStateStream:\n"
+ $"Local progress: {this.localProgress} (& up to LSN {this.upToSequenceNumber})\n"
+ $"Remote progress: {remoteProgress}\n" + $"Delta Progress: {this.catchUpProgressVector}");
}
// Nothing to copy.
if (this.upToSequenceNumber == 0)
{
return null;
}
// Find the first entry which needs to be replicated
var result = default(OperationData);
var totalSize = 0;
// Wait for the required records to become available.
this.hasRecord = this.records.MoveNext();
while (this.hasRecord)
{
var rawRecord = this.records.Current;
var record = this.serializer.Deserialize<Record>(rawRecord);
var operation = record as OperationCommittedRecord;
if (operation == null)
{
this.logger.Log(
$"CopyStateStream: {record} is not an {nameof(OperationCommittedRecord)}, it is an {record.GetType()}.");
this.hasRecord = this.records.MoveNext();
continue;
}
var currentVersion = operation.Version;
var currentLsn = currentVersion.LogSequenceNumber;
if (currentLsn > this.upToSequenceNumber)
{
break;
}
// Only return records which were actually committed.
if (!this.catchUpProgressVector.IncludesVersionInPreviousEpoch(currentVersion)
&& this.catchUpProgressVector.Current.Epoch != currentVersion.Epoch)
{
#warning we need a bucket load of tests around this to motivate correctness. How is the 'zero' epoch handled? Does such a thing even exist?
/*this.logger.Log(
$"CopyStateStream: {currentVersion} is not in the catchup vector or current epoch ({this.catchUpProgressVector.Current.Epoch.ToDisplayString()})");*/
this.hasRecord = this.records.MoveNext();
continue;
}
if (result == null)
{
this.lowestLsn = currentLsn;
}
this.highestLsn = this.highestLsn > currentLsn ? this.highestLsn : currentLsn;
// Copy the payload into the result.
var data = this.serializer.Serialize(record);
if (result == null)
{
result = new OperationData(data);
}
else
{
result.Add(data);
}
this.hasRecord = this.records.MoveNext();
// If a sequence number which has not yet been committed has been requested, wait for that before continuing.
if (!this.hasRecord && this.highestLsn != this.upToSequenceNumber)
{
await this.WaitForCommit(rawRecord.SequenceNumber, cancellationToken);
}
// Send only a certain amount of data at a time.
totalSize += data.Count;
if (totalSize > ResultCutoffLength)
{
break;
}
}
this.logger.Log(
result == null
? "Completed copying state"
: $"CopyStateStream.GetNextAsync returning {result.Count} records, from LSN {this.lowestLsn} to {this.highestLsn}");
return result;
}
public static void ReportOpenEditor()
{
_backgroundThread.IsBackground = true;
_backgroundThread.Start();
OperationData operation = FindOperation(OperationTypes.kOpenEditor);
if (operation == null)
{
operation = new OperationData(OperationTypes.kOpenEditor);
lock (_lockObject)
{
_allOperations.Add(operation);
}
}
else
{
operation.Count++;
}
}
public static void ReportOpenDoc()
{
OperationData operation = FindOperation(OperationTypes.kOpenDoc);
if (operation == null)
{
operation = new OperationData(OperationTypes.kOpenDoc);
lock (_lockObject)
{
_allOperations.Add(operation);
}
}
else
{
operation.Count++;
}
}
