public static IEnumerable <MethodDef> GetVisibleExtensionMethods(this MetadataTables tables)
{
MetadataRecord eaCtor = GetExtensionAttributeCtor(tables);
if (!eaCtor.IsNull)
{
foreach (CustomAttributeDef ca in tables.CustomAttributes)
{
if (ca.Constructor.Equals(eaCtor) && ca.Parent.IsMethodDef)
{
MethodDef mdef = ca.Parent.MethodDef;
var mattrs = mdef.Attributes;
if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public && (mattrs & MethodAttributes.Static) != 0)
{
var declType = mdef.FindDeclaringType();
var tattrs = declType.Attributes;
if (((tattrs & TypeAttributes.VisibilityMask) == TypeAttributes.Public ||
(tattrs & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic) &&
(tattrs & TypeAttributes.Abstract) != 0 &&
(tattrs & TypeAttributes.Sealed) != 0)
{
yield return(mdef);
}
}
}
}
}
}
/// <summary>
/// Computes the length of a data array in a HDU.
/// </summary>
/// <param name="Header">The header for which to compute the array length.</param>
/// <returns>Array length in bytes.</returns>
public static int ComputeDataArrayLength(Dictionary <string, MetadataRecord> Header)
{
try
{
MetadataRecord bp = Header["BITPIX"];
MetadataRecord naxr = Header["NAXIS"];
int nax = naxr.Int;
if (nax != 2)
{
if (nax == 0)
{
return(0);
}
else
{
throw new NotSupportedException("Umbrella2 can only read 2D images.");
}
}
MetadataRecord n1 = Header["NAXIS1"];
MetadataRecord n2 = Header["NAXIS2"];
return(Math.Abs(bp.Int) * n1.Int * n2.Int / 8);
}
catch (Exception ex)
{ throw new FITSFormatException("Missing or malformed FITS header entries.", ex); }
}
private static string MethodToString(MetadataRecord record)
{
if (record.IsNull)
{
return("<none>");
}
switch (record.Type)
{
case MetadataRecordType.MethodDef:
var methodDef = record.MethodDef;
var parent = methodDef.FindDeclaringType();
return(String.Format("def({0}.{1}::{2})", parent.Namespace, parent.Name, methodDef.Name));
case MetadataRecordType.MemberRef:
var memberRef = record.MemberRef;
return(String.Format("ref({0}::{1}|{2})", TypeToString(memberRef.Class), memberRef.Name, SignatureToString(memberRef.Signature)));
case MetadataRecordType.MethodSpec:
var methodSpec = record.MethodSpec;
return(String.Format("spec({0})", SignatureToString(methodSpec.Signature)));
}
throw new InvalidOperationException("Unknown method token");
}
public async Task Set(MetadataRecord record, CancellationToken token = default)
{
record.VerifyNotNull(nameof(record));
IMetadataRecordActor actor = _actorHost !.GetActor <IMetadataRecordActor>((ActorKey)record.Id);
await actor.Set(record, token);
}
public void CouldIncrementCounter()
{
var path = TestUtils.GetPath(clear: true);
var storage = new SQLiteStorage($@"Filename={Path.Combine(path, "metadatastorage.db")}");
var md1 = new MetadataRecord()
{
PK = "test1:/md1",
Metadata = new Metadata("md1"),
RepoId = 2,
ContainerId = 1
};
var insertResult = storage.InsertMetadataRow(md1);
Assert.IsTrue(insertResult);
var result = storage.IncrementCounter("test1:/md1");
var result1 = storage.IncrementCounter("test1:/md1");
Assert.AreEqual(result1, result + 1);
var mdExact = storage.GetExactMetadata("test1:/md1");
Assert.AreEqual(result1, mdExact.Counter);
storage.Dispose();
}
public static JObject ToDto(this MetadataRecord record)
{
var result = new JObject();
var translations = new JArray();
var children = new JArray();
foreach (var translation in record.Translations)
{
translations.Add(new JObject
{
{ translation.Language, translation.Value }
});
}
if (record.Children != null)
{
foreach (var child in record.Children)
{
children.Add(new JObject
{
{ child.Key, child.Value.ToDto() }
});
}
}
result.Add("translations", translations);
result.Add("children", children);
return(result);
}
public void MetadataUnitTest_3()
{
var source = new FileMetadata();
using (var ms = new MemoryStream())
{
ms.Write(new byte[] { 2, 3 }, 0, 2);
var sourceRecords = new MetadataRecord[3]
{
new MetadataRecord(3, 5, 10, 0),
new MetadataRecord(5, 24252525, 23425, 58581758),
new MetadataRecord(long.MaxValue, int.MaxValue, long.MaxValue, int.MaxValue),
};
foreach (var record in sourceRecords)
{
source.AddRecord(record);
}
source.Write(ms);
var target = new FileMetadata();
target.Read(ms);
var targetRecords = target.Records.ToArray();
sourceRecords.Should().BeEquivalentTo(targetRecords);
}
}
public async Task GivenMetadataRecord_WhenFullLifeCycle_ShouldComplete()
{
TestWebsiteHost host = await TestApplication.DefaultHost.GetHost();
const string id = "meta0001";
var record = new MetadataRecord
{
Id = id,
Properties = new[]
{
new KeyValue("key1", "value1"),
new KeyValue("key2", "value2"),
},
};
await host.PathFinderClient.Metadata.Delete(record.Id);
MetadataRecord?response = await host.PathFinderClient.Metadata.Get(record.Id);
response.Should().BeNull();
await host.PathFinderClient.Metadata.Set(record);
MetadataRecord?readResponse = await host.PathFinderClient.Metadata.Get(record.Id);
readResponse.Should().NotBeNull();
await host.PathFinderClient.Metadata.Delete(record.Id);
readResponse = await host.PathFinderClient.Metadata.Get(record.Id);
readResponse.Should().BeNull();
}
public static void Write(this NativeWriter writer, MetadataRecord record)
{
if (record != null)
writer.WriteUnsigned((uint)record.HandleType | (uint)(record.HandleOffset << 8));
else
writer.WriteUnsigned(0);
}
private static string MethodToString(MetadataRecord record)
{
if (record.IsNull)
{
return("<none>");
}
switch (record.Type)
{
case MetadataRecordType.MethodDef:
var methodDef = record.MethodDef;
var parent = methodDef.FindDeclaringType();
return($"def({parent.Namespace}.{parent.Name}::{methodDef.Name})");
case MetadataRecordType.MemberRef:
var memberRef = record.MemberRef;
return
($"ref({TypeToString(memberRef.Class)}::{memberRef.Name}|{SignatureToString(memberRef.Signature)})");
case MetadataRecordType.MethodSpec:
var methodSpec = record.MethodSpec;
return($"spec({SignatureToString(methodSpec.Signature)})");
}
throw new InvalidOperationException("Unknown method token");
}
public async Task Set(MetadataRecord metadataRecord)
{
metadataRecord.VerifyNotNull(nameof(metadataRecord));
HttpResponseMessage response = await _httpClient.PostAsJsonAsync("api/metadata", metadataRecord);
response.EnsureSuccessStatusCode();
}
public Metadata(MetadataRecord metadata)
{
MetadataRecord = metadata;
Instance = metadata.PlantCode;
PointID = metadata.HistorianID;
PointName = metadata.Name;
PointDescription = metadata.Description;
}
public async Task <IActionResult> Post([FromBody] MetadataRecord record)
{
record.Prepare();
await _metadataPathService.Set(record);
return(Ok());
}
/// <summary>
/// Returns an <see cref="MetadataRecord"/> object for this <see cref="SerializableMetadataRecord"/>.
/// </summary>
/// <returns>An <see cref="MetadataRecord"/> object.</returns>
public MetadataRecord Deflate()
{
MetadataRecord metadataRecord = new MetadataRecord(HistorianID, MetadataFileLegacyMode.Enabled);
metadataRecord.GeneralFlags.DataType = (DataType)DataType;
metadataRecord.Name = Name;
metadataRecord.Synonym1 = Synonym1;
metadataRecord.Synonym2 = Synonym2;
metadataRecord.Synonym3 = Synonym3;
metadataRecord.Description = Description;
metadataRecord.HardwareInfo = HardwareInfo;
metadataRecord.Remarks = Remarks;
metadataRecord.PlantCode = PlantCode;
metadataRecord.UnitNumber = UnitNumber;
metadataRecord.SystemName = SystemName;
metadataRecord.SourceID = SourceID;
metadataRecord.GeneralFlags.Enabled = Enabled;
metadataRecord.ScanRate = ScanRate;
metadataRecord.CompressionMinTime = CompressionMinTime;
metadataRecord.CompressionMaxTime = CompressionMaxTime;
metadataRecord.SecurityFlags.ChangeSecurity = ChangeSecurity;
metadataRecord.SecurityFlags.AccessSecurity = AccessSecurity;
metadataRecord.GeneralFlags.StepCheck = StepCheck;
metadataRecord.GeneralFlags.AlarmEnabled = AlarmEnabled;
metadataRecord.AlarmFlags.Value = AlarmFlags;
metadataRecord.GeneralFlags.AlarmToFile = AlarmToFile;
metadataRecord.GeneralFlags.AlarmByEmail = AlarmByEmail;
metadataRecord.GeneralFlags.AlarmByPager = AlarmByPager;
metadataRecord.GeneralFlags.AlarmByPhone = AlarmByPhone;
metadataRecord.AlarmEmails = AlarmEmails;
metadataRecord.AlarmPagers = AlarmPagers;
metadataRecord.AlarmPhones = AlarmPhones;
if (DataType == 0)
{
// Analog properties.
metadataRecord.AnalogFields.EngineeringUnits = EngineeringUnits;
metadataRecord.AnalogFields.LowWarning = LowWarning;
metadataRecord.AnalogFields.HighWarning = HighWarning;
metadataRecord.AnalogFields.LowAlarm = LowAlarm;
metadataRecord.AnalogFields.HighAlarm = HighAlarm;
metadataRecord.AnalogFields.LowRange = LowRange;
metadataRecord.AnalogFields.HighRange = HighRange;
metadataRecord.AnalogFields.CompressionLimit = CompressionLimit;
metadataRecord.AnalogFields.ExceptionLimit = ExceptionLimit;
metadataRecord.AnalogFields.DisplayDigits = DisplayDigits;
metadataRecord.AnalogFields.AlarmDelay = AlarmDelay;
}
else if (DataType == 1)
{
// Digital properties.
metadataRecord.DigitalFields.SetDescription = SetDescription;
metadataRecord.DigitalFields.ClearDescription = ClearDescription;
metadataRecord.DigitalFields.AlarmState = AlarmState;
metadataRecord.DigitalFields.AlarmDelay = AlarmDelay;
}
return(metadataRecord);
}
public async Task Set(MetadataRecord metadataRecord, CancellationToken token = default)
{
_logger.LogTrace($"{nameof(Set)}: Id={metadataRecord.Id}");
metadataRecord
.VerifyNotNull(nameof(metadataRecord))
.Prepare();
await _httpClient.PostAsJsonAsync("api/metadata", metadataRecord, token);
}
byte[] IArchive.ReadMetaData(int historianID)
{
MetadataRecord record = ReadMetadataRecord(historianID);
if (record != null)
{
return(record.BinaryImage());
}
return(null);
}
public async Task Set(MetadataRecord record, CancellationToken token)
{
record
.VerifyNotNull(nameof(record))
.VerifyAssert(x => x.Id == base.ActorKey.Value, "Id mismatch");
_logger.LogTrace($"{nameof(Set)}: Writing {record}");
await _container.Set(record, token);
_recordCache.Set(record);
}
byte[] IArchive.ReadMetaDataSummary(int historianID)
{
MetadataRecord record = ReadMetadataRecord(historianID);
if ((object)record != null)
{
return(record.Summary.BinaryImage());
}
return(null);
}
public bool InsertMetadataRow(MetadataRecord record)
{
var qs = RentQueries();
try
{
return(qs.InsertMetadataRow(record));
}
finally
{
ReturnQueries(qs);
}
}
protected override void ComputeMetadata(NodeFactory factory,
out byte[] metadataBlob,
out List <MetadataMapping <MetadataType> > typeMappings,
out List <MetadataMapping <MethodDesc> > methodMappings,
out List <MetadataMapping <FieldDesc> > fieldMappings,
out List <MetadataMapping <MethodDesc> > stackTraceMapping)
{
var ms = new MemoryStream();
var writer = new MetadataWriter();
// Run an empty transform pass. This doesn't matter. We just need an instance of the MetadataTransform.
var transformed = MetadataTransform.Run(new Policy(), Array.Empty <ModuleDesc>());
MetadataTransform transform = transformed.Transform;
// Generate entries in the blob for methods that will be necessary for stack trace purposes.
var stackTraceRecords = new List <KeyValuePair <MethodDesc, MetadataRecord> >();
foreach (var methodBody in GetCompiledMethodBodies())
{
MethodDesc method = methodBody.Method;
MethodDesc typicalMethod = method.GetTypicalMethodDefinition();
if (!_stackTraceEmissionPolicy.ShouldIncludeMethod(method))
{
continue;
}
MetadataRecord record = CreateStackTraceRecord(transform, method);
stackTraceRecords.Add(new KeyValuePair <MethodDesc, MetadataRecord>(
method,
record));
writer.AdditionalRootRecords.Add(record);
}
writer.Write(ms);
metadataBlob = ms.ToArray();
typeMappings = new List <MetadataMapping <MetadataType> >();
methodMappings = new List <MetadataMapping <MethodDesc> >();
fieldMappings = new List <MetadataMapping <FieldDesc> >();
stackTraceMapping = new List <MetadataMapping <MethodDesc> >();
// Generate stack trace metadata mapping
foreach (var stackTraceRecord in stackTraceRecords)
{
stackTraceMapping.Add(new MetadataMapping <MethodDesc>(stackTraceRecord.Key, writer.GetRecordHandle(stackTraceRecord.Value)));
}
}
private void EnsureMetadataGenerated()
{
if (_metadataBlob != null)
{
return;
}
var transformed = MetadataTransform.Run(new DummyMetadataPolicy(this), _modulesSeen);
// TODO: DeveloperExperienceMode: Use transformed.Transform.HandleType() to generate
// TypeReference records for _typeDefinitionsGenerated that don't have metadata.
// (To be used in MissingMetadataException messages)
// Generate metadata blob
var writer = new MetadataWriter();
writer.ScopeDefinitions.AddRange(transformed.Scopes);
var ms = new MemoryStream();
writer.Write(ms);
_metadataBlob = ms.ToArray();
// Generate type definition mappings
foreach (var definition in _typeDefinitionsGenerated)
{
MetadataRecord record = transformed.GetTransformedTypeDefinition(definition);
// Reflection requires that we maintain type identity. Even if we only generated a TypeReference record,
// if there is an EEType for it, we also need a mapping table entry for it.
if (record == null)
{
record = transformed.GetTransformedTypeReference(definition);
}
if (record != null)
{
_typeMappings.Add(new MetadataMapping <MetadataType>(definition, writer.GetRecordHandle(record)));
}
}
foreach (var method in _methodsGenerated)
{
MetadataRecord record = transformed.GetTransformedMethodDefinition(method.GetTypicalMethodDefinition());
if (record != null)
{
_methodMappings.Add(new MetadataMapping <MethodDesc>(method, writer.GetRecordHandle(record)));
}
}
}
private void CreateMetadataTemplate(int index, string file)
{
var record = new MetadataRecord
{
Id = $"Metadata_{index}",
Properties = new[]
{
new KeyValue("key1", "value1"),
new KeyValue("key2", "value2"),
},
};
File.WriteAllText(file, _json.Serialize(record));
_logger.LogInformation($"Create json template {file} for Metadata");
}
private static string ImplementationToString(MetadataRecord impl)
{
if (impl.IsFileDef)
{
return("file(" + impl.FileDef.Name + ")");
}
if (impl.IsAssemblyRef)
{
return("assembly(" + impl.AssemblyRef.Name + ")");
}
Debug.Assert(impl.IsNull);
return("<no-impl>");
}
/// <summary>
/// Formats an <see cref="MetadataRecord"/> as an 80-byte field ready to be written to disk.
/// </summary>
/// <param name="record">Instance to be formatted.</param>
/// <returns>A byte array containing the binary representation of the record.</returns>
internal static byte[] ToRawRecord(MetadataRecord record)
{
byte[] Record = Encoding.UTF8.GetBytes(new string(' ', 80));
if (record.Name.Length > 8)
{
throw new FITSFormatException("Keyword names must be at most 8 characters long.");
}
if (record.DataString.Length > 71)
{
throw new FITSFormatException("Keyword values must be at most 71 characters long.");
}
Encoding.UTF8.GetBytes(record.Name, 0, record.Name.Length, Record, 0);
Record[8] = (byte)'=';
Encoding.UTF8.GetBytes(record.DataString, 0, record.DataString.Length, Record, 9);
return(Record);
}
public void CouldInsertAndSelectMetadata()
{
var path = TestUtils.GetPath(clear: true);
var storage = new SQLiteStorage($@"Filename={Path.Combine(path, "metadatastorage.db")}");
var md1 = new MetadataRecord()
{
PK = "test1:/md1",
Metadata = new Metadata("md1"),
RepoId = 2,
ContainerId = 1
};
var md2 = new MetadataRecord()
{
PK = "test1:/md2",
Metadata = new Metadata("md2"),
RepoId = 2,
ContainerId = 2
};
var txn = storage.BeginConcurrent();
var result = storage.InsertMetadataRow(md1);
Assert.IsTrue(result);
result = storage.InsertMetadataRow(md2);
Assert.IsTrue(result);
result = storage.InsertMetadataRow(md2);
Assert.IsFalse(result);
txn.RawCommit();
var mdList = storage.FindMetadata("test1:/md");
Assert.AreEqual(2, mdList.Count);
Assert.AreEqual("md1", mdList[0].Metadata.Description);
Assert.AreEqual(2, mdList[0].RepoId);
Assert.AreEqual(1, mdList[0].ContainerId);
var mdExact = storage.GetExactMetadata("test1:/md2");
Assert.AreEqual("md2", mdExact.Metadata.Description);
storage.Dispose();
}
/// <summary>
/// Updates the chart after changes have been made to the chart boundaries or the data displayed in the chart.
/// </summary>
public void UpdateChart()
{
Cursor windowCursor = Cursor;
int colorIndex = 0;
DateTime startTime = m_xAxis.Minimum ?? TimeTag.MinValue.ToDateTime();
DateTime endTime = m_xAxis.Maximum ?? TimeTag.MaxValue.ToDateTime();
Cursor = Cursors.Wait;
m_chart.Series.Clear();
foreach (Tuple <ArchiveReader, MetadataRecord> visiblePoint in m_visiblePoints)
{
if (m_chartResolution > 0 && colorIndex < m_lineColors.Count)
{
ArchiveReader reader = visiblePoint.Item1;
MetadataRecord record = visiblePoint.Item2;
IEnumerable <IDataPoint> data = reader.ReadData(record.HistorianID, startTime, endTime, false);
LineSeries series = new LineSeries();
int interval = (data.Count() / m_chartResolution) + 1;
int pointCount = 0;
// Change how data points are displayed.
series.DataPointStyle = new Style(typeof(LineDataPoint));
series.DataPointStyle.Setters.Add(new Setter(BackgroundProperty, new SolidColorBrush(m_lineColors[colorIndex])));
series.DataPointStyle.Setters.Add(new Setter(TemplateProperty, new ControlTemplate()));
colorIndex++;
// Set the title of the series as it will appear in the legend.
series.Title = record.Name;
// Filter the data to 100 data points.
series.ItemsSource = data.Where(point => (pointCount++ % interval) == 0).Select(point => new DataPointWrapper(point));
series.IndependentValuePath = "Time";
series.DependentValuePath = "Value";
// Add the series to the chart.
m_chart.Series.Add(series);
}
}
UpdateLayout();
Cursor = windowCursor;
OnChartUpdated();
}
// openHistorian 2.0 currently uses the database for its metadata repository - so we just update the database using the
// provided metadata record as received from the metadata web service interface
void IArchive.WriteMetaData(int historianID, byte[] metadata)
{
MetadataRecord record = new MetadataRecord(historianID, MetadataFileLegacyMode.Enabled, metadata, 0, metadata.Length);
using (AdoDataConnection database = new AdoDataConnection("systemSettings"))
{
IDbConnection connection = database.Connection;
// TODO: To enable update signal type, associated device, destination historian, etc. - look up key ID values in advance of measurement record update
// Only updating readily available fields - to make this more useful in the future, will need to update (or add a new) web service metadata format...
string query = database.ParameterizedQueryString("UPDATE Measurement SET PointTag={0}, SignalReference={1}, AlternateTag={2}, Enabled={3} WHERE HistorianID = {4}", "pointTag", "signalReference", "alternateTag", "enabled", "historianID");
// Update metadata fields
connection.ExecuteNonQuery(query, record.Name, record.Synonym1, record.Synonym3, record.GeneralFlags.Enabled, historianID);
}
}
internal void LoadMetadata()
{
List<MetadataRecord> metadata = new List<MetadataRecord>();
MetadataRecord record1 = new MetadataRecord();
record1.User = "******";
record1.ComputerName = "PCName";
DateTime time = DateTime.Now;
time = time.Date.AddHours(time.Hour).AddMinutes(time.Minute).AddSeconds(time.Second);
record1.Time = time;
record1.Arguments.Add(new Tuple<string, string>("input1", "value1"));
record1.Operation = "TestOperation";
metadata.Add(record1);
MetadataRecord record2 = new MetadataRecord();
record2.User = "******";
record2.ComputerName = "PCName2";
record2.Time = time;
record2.Arguments.Add(new Tuple<string, string>("input12", "value12"));
record2.Arguments.Add(new Tuple<string, string>("input22", "value22"));
record2.Operation = "TestOperation2";
metadata.Add(record2);
string fileName = FileFunctions.TempoaryOutputFileName(".txt");
MetadataFunctions.Save(fileName, metadata);
List<MetadataRecord> loadedMetadata = MetadataFunctions.Load(fileName);
if (loadedMetadata.Count != 2)
{
throw new Exception();
}
MetadataRecord loadedRecord1 = loadedMetadata[0];
MetadataRecord loadedRecord2 = loadedMetadata[1];
if (!Equal(record1, loadedRecord1))
{
throw new Exception();
}
if (!Equal(record2, loadedRecord2))
{
throw new Exception();
}
}
private static void DumpGenericParameters(MetadataTableView genericParams, MetadataRecord owner)
{
foreach (GenericParamDef gp in genericParams)
{
_output.WriteLine(" generic parameter #{0}: {1}({2})", gp.Index, gp.Name, gp.Attributes);
Debug.Assert(gp.Owner.Equals(owner));
foreach (GenericParamConstraint gpc in gp.Constraints)
{
_output.WriteLine(" constraint {0}", TypeToString(gpc.Constraint));
Debug.Assert(gpc.Owner.Record.Equals(gp.Record));
}
if (Detailed)
{
DumpCustomAttributes(gp.CustomAttributes, " ");
}
}
}
private List <MetadataRecord> GetMetadata()
{
Ticks operationTime;
Ticks operationStartTime;
// Load historian meta-data
ShowMessage(">>> Loading source connection metadata...");
operationStartTime = DateTime.UtcNow.Ticks;
List <MetadataRecord> metadata = MetadataRecord.Query(m_settings.HostAddress, m_settings.MetadataPort, m_settings.MetadataTimeout);
operationTime = DateTime.UtcNow.Ticks - operationStartTime;
ShowMessage("*** Metadata Load Complete ***");
ShowMessage($"Total metadata load time {operationTime.ToElapsedTimeString(3)}...");
// Parse meta-data expression
ShowMessage(">>> Processing filter expression for metadata...");
operationStartTime = DateTime.UtcNow.Ticks;
MeasurementKey[] inputKeys = AdapterBase.ParseInputMeasurementKeys(MetadataRecord.Metadata, false, m_settings.PointList, "MeasurementDetail");
List <ulong> pointIDList = inputKeys.Select(key => (ulong)key.ID).ToList();
List <MetadataRecord> records = new List <MetadataRecord>();
foreach (ulong pointID in pointIDList)
{
MetadataRecord record = metadata.FirstOrDefault(md => md.PointID == pointID);
if ((object)record != null)
{
records.Add(record);
}
}
operationTime = DateTime.UtcNow.Ticks - operationStartTime;
ShowMessage($">>> Historian read will be for {pointIDList.Count:N0} points based on provided meta-data expression.");
ShowMessage("*** Filter Expression Processing Complete ***");
ShowMessage($"Total filter expression processing time {operationTime.ToElapsedTimeString(3)}...");
return(records);
}
private async Task WriteRecord(string recordType, string json, CancellationToken token)
{
switch (recordType)
{
case nameof(LinkRecord):
LinkRecord linkRecord = _json.Deserialize <LinkRecord>(json);
await _linkContainer.Set(linkRecord, token);
break;
case nameof(MetadataRecord):
MetadataRecord metadataRecord = _json.Deserialize <MetadataRecord>(json);
await _metadataContainer.Set(metadataRecord, token);
break;
default:
throw new ArgumentException($"Unknown record type for importing, recordType={recordType}");
}
}
private TypeReference GetNestedReferenceParent(Cts.MetadataType entity)
{
// This special code deals with the metadata format requirement saying that
// nested type *references* need to have a type *reference* as their containing type.
// This is potentially in conflict with our other rule that says to always resolve
// references to their definition records (we are avoiding emitting references
// to things that have a definition within the same blob to save space).
Cts.MetadataType containingType = (Cts.MetadataType)entity.ContainingType;
MetadataRecord parentRecord = HandleType(containingType);
TypeReference parentReferenceRecord = parentRecord as TypeReference;
if (parentReferenceRecord != null)
{
// Easy case - parent type doesn't have a definition record.
return(parentReferenceRecord);
}
// Parent has a type definition record. We need to make a new record that's a reference.
// We don't bother with interning these because this will be rare and metadata writer
// will do the interning anyway.
Debug.Assert(parentRecord is TypeDefinition);
parentReferenceRecord = new TypeReference
{
TypeName = HandleString(containingType.Name),
};
if (containingType.ContainingType != null)
{
parentReferenceRecord.ParentNamespaceOrType = GetNestedReferenceParent(containingType);
}
else
{
parentReferenceRecord.ParentNamespaceOrType = HandleNamespaceReference(containingType.Module, containingType.Namespace);
}
return(parentReferenceRecord);
}
private static bool Equal(MetadataRecord left, MetadataRecord right)
{
if (false
|| right.User != left.User
|| right.ComputerName != left.ComputerName
|| right.Time != left.Time
|| right.Operation != left.Operation
|| right.Arguments.Count != left.Arguments.Count
)
{
throw new Exception();
}
for (int argumentIndex = 0; argumentIndex < right.Arguments.Count; argumentIndex++)
{
Tuple<string, string> record1Argument = left.Arguments[argumentIndex];
Tuple<string, string> loadedRecord1Argument = right.Arguments[argumentIndex];
if (loadedRecord1Argument.Item1 != record1Argument.Item1 || loadedRecord1Argument.Item2 != record1Argument.Item2)
{
throw new Exception();
}
}
return true;
}
internal void ValuesWritten()
{
// also the operation
/// verifies that the user name, and pc are included in the metadata
/// this includes the user name,
/// pc name,
/// anything else that looks interesting
///
MetadataRecord record = new MetadataRecord();
record.User = "******";
record.ComputerName = "PCName";
DateTime time = DateTime.Now;
string timeString = time.ToShortDateString() + " " + time.ToLongTimeString();
record.Time = time;
record.Arguments.Add(new Tuple<string, string>("input1", "value1"));
record.Operation = "TestOperation";
List<MetadataRecord> metadata = new List<MetadataRecord>();
metadata.Add(record);
string fileName = FileFunctions.TempoaryOutputFileName(".txt");
MetadataFunctions.Save(fileName, metadata);
string metadataFileName = MetadataFunctions.FileName(fileName);
if (!File.Exists(metadataFileName))
{
throw new Exception();
}
string text = File.ReadAllText(metadataFileName);
if (!text.Contains("TestUser")
|| !text.Contains("PCName")
|| !text.Contains(timeString)
|| !text.Contains("input1")
|| !text.Contains("value1")
|| !text.Contains("TestOperation")
)
{
throw new Exception();
}
}