public void ShouldWriteToEmptyBuffer()
{
const int length = 8;
var recordLength = length + RecordDescriptor.HeaderLength;
var alignedRecordLength = BitUtil.Align(recordLength, RecordDescriptor.Alignment);
const long tail = 0L;
const long head = 0L;
A.CallTo(() => _buffer.GetLongVolatile(HeadCounterIndex)).Returns(head);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
A.CallTo(() => _buffer.CompareAndSetLong(TailCounterIndex, tail, tail + alignedRecordLength)).Returns(true);
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int srcIndex = 0;
Assert.True(_ringBuffer.Write(MsgTypeID, srcBuffer, srcIndex, length));
A.CallTo(() => _buffer.PutLongOrdered((int)tail, RecordDescriptor.MakeHeader(-recordLength, MsgTypeID)))
.MustHaveHappened()
.Then(A.CallTo(() =>
_buffer.PutBytes(RecordDescriptor.EncodedMsgOffset((int)tail), srcBuffer, srcIndex, length))
.MustHaveHappened())
.Then(A.CallTo(() => _buffer.PutIntOrdered(RecordDescriptor.LengthOffset((int)tail), recordLength))
.MustHaveHappened());
}
public void ShouldLimitReadOfMessages()
{
const int msgLength = 16;
var recordLength = RecordDescriptor.HeaderLength + msgLength;
var alignedRecordLength = BitUtil.Align(recordLength, RecordDescriptor.Alignment);
const long head = 0L;
var headIndex = (int)head;
A.CallTo(() => _buffer.GetLong(HeadCounterIndex)).Returns(head);
A.CallTo(() => _buffer.GetLongVolatile(headIndex))
.Returns(RecordDescriptor.MakeHeader(recordLength, MsgTypeID));
var times = new int[1];
MessageHandler handler = (msgTypeId, buffer, index, length) => times[0]++;
const int limit = 1;
var messagesRead = _ringBuffer.Read(handler, limit);
Assert.AreEqual(messagesRead, 1);
Assert.AreEqual(times[0], 1);
A.CallTo(() => _buffer.SetMemory(headIndex, alignedRecordLength, 0)).MustHaveHappened(1, Times.Exactly)
.Then(
A.CallTo(() => _buffer.PutLongOrdered(HeadCounterIndex, head + alignedRecordLength))
.MustHaveHappened(1, Times.Exactly));
}
private static ICache <long, T> CreateCacheGeneric <T>(IIgnite ignite, RecordDescriptor desc)
{
var cacheMode = ReplicatedTables.Contains(desc.TableName)
? CacheMode.Replicated
: CacheMode.Partitioned;
var cacheCfg = new CacheConfiguration
{
Name = desc.TableName,
QueryEntities = new[]
{
new QueryEntity
{
TableName = desc.TableName,
KeyType = typeof(long),
ValueType = typeof(T)
}
},
EnableStatistics = true,
QueryParallelism = cacheMode == CacheMode.Partitioned ? 4 : 1,
CacheMode = cacheMode
};
return(ignite.GetOrCreateCache <long, T>(cacheCfg));
}
public void ShouldDealWithRecordBecomingInvalidDueToOverwrite()
{
const int length = 8;
var recordLength = length + RecordDescriptor.HeaderLength;
var recordLengthAligned = BitUtil.Align(recordLength, RecordDescriptor.RecordAlignment);
long tail = recordLengthAligned;
var latestRecord = tail - recordLengthAligned;
var recordOffset = (int)latestRecord;
A.CallTo(() => _buffer.GetLongVolatile(TailIntentCounterOffset)).ReturnsNextFromSequence(tail, tail + (Capacity - recordLengthAligned));
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetLengthOffset(recordOffset))).Returns(recordLength);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetTypeOffset(recordOffset))).Returns(MsgTypeID);
Assert.IsTrue(_broadcastReceiver.ReceiveNext());
Assert.AreEqual(MsgTypeID, _broadcastReceiver.TypeId());
Assert.AreEqual(_buffer, _broadcastReceiver.Buffer());
Assert.AreEqual(RecordDescriptor.GetMsgOffset(recordOffset), _broadcastReceiver.Offset());
Assert.AreEqual(length, _broadcastReceiver.Length());
Assert.False(_broadcastReceiver.Validate()); // Need to receiveNext() to catch up with transmission again.
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).MustHaveHappened();
}
public IIndex <TKey, TRecord> OpenXIndex <TKey, TRecord>(IDataTransformer <TKey> keyTransformer, IDataTransformer <TRecord> recordTransformer, CompareOption[] compareOptions, bool compressKeys, bool compressRecords, params string[] path)
{
var keyType = keyTransformer.DataType;
bool keySupported = keyType.IsPrimitive || (keyType.IsSlotes && keyType.AreAllTypesPrimitive);
if (!keySupported)
{
throw new NotSupportedException(keyType.ToString());
}
var recordType = recordTransformer.DataType;
bool recordSupported = recordType.IsPrimitive || (recordType.IsSlotes && recordType.AreAllTypesPrimitive);
if (!recordSupported)
{
throw new NotSupportedException(recordType.ToString());
}
Type[] keySlotTypes = keyType.IsPrimitive ? new Type[] { keyType.PrimitiveType } : keyType.Select(x => x.PrimitiveType).ToArray();
Type[] recordSlotTypes = recordType.IsPrimitive ? new Type[] { recordType.PrimitiveType } : recordType.Select(x => x.PrimitiveType).ToArray();
keyType.CheckCompareOptions(compareOptions);
KeyDescriptor keyDescriptor = new KeyDescriptor(keyType, compressKeys, compareOptions);
RecordDescriptor recordDescriptor = new RecordDescriptor(recordType, compressRecords);
var index = OpenXIndex(keyDescriptor, recordDescriptor, path);
return(new XIndex <TKey, TRecord>(index, keyTransformer, recordTransformer));
}
public StructureDescriptor(KeyDescriptor keyDescriptor, RecordDescriptor recordDescriptor)
{
KeyDescriptor = keyDescriptor;
RecordDescriptor = recordDescriptor;
IsEncoded = false;
IsDecoded = true;
}
public IIndex <IData, IData> OpenXIndex(DataType keyType, DataType recordType, bool compressKeys, bool compressRecords, params string[] path)
{
KeyDescriptor keyDescriptor = new KeyDescriptor(keyType, compressKeys);
RecordDescriptor recordDescriptor = new RecordDescriptor(recordType, compressRecords);
return(OpenXIndex(keyDescriptor, recordDescriptor, path));
}
public void ShouldInsertPaddingRecordPlusMessageOnBufferWrapWithHeadEqualToTail()
{
const int length = 200;
var recordLength = length + RecordDescriptor.HeaderLength;
var alignedRecordLength = BitUtil.Align(recordLength, RecordDescriptor.Alignment);
long tail = Capacity - RecordDescriptor.HeaderLength;
var head = tail;
A.CallTo(() => _buffer.GetLongVolatile(HeadCounterIndex)).Returns(head);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
A.CallTo(() =>
_buffer.CompareAndSetLong(TailCounterIndex, tail,
tail + alignedRecordLength + RecordDescriptor.Alignment)).Returns(true);
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int srcIndex = 0;
Assert.True(_ringBuffer.Write(MsgTypeID, srcBuffer, srcIndex, length));
A.CallTo(() => _buffer.PutLongOrdered((int)tail,
RecordDescriptor.MakeHeader(RecordDescriptor.HeaderLength, ManyToOneRingBuffer.PaddingMsgTypeId)))
.MustHaveHappened()
.Then(A.CallTo(() => _buffer.PutLongOrdered(0, RecordDescriptor.MakeHeader(-recordLength, MsgTypeID)))
.MustHaveHappened())
.Then(A.CallTo(
() => _buffer.PutBytes(RecordDescriptor.EncodedMsgOffset(0), srcBuffer, srcIndex, length))
.MustHaveHappened())
.Then(A.CallTo(() => _buffer.PutIntOrdered(RecordDescriptor.LengthOffset(0), recordLength))
.MustHaveHappened());
}
public IIndex <object[], object[]> OpenXIndexPrimitive(DataType keyType, DataType recordType, bool compressKeys, bool compressRecords, params string[] path)
{
KeyDescriptor keyDescriptor = new KeyDescriptor(keyType, compressKeys);
RecordDescriptor recordDescriptor = new RecordDescriptor(recordType, compressRecords);
return(OpenXIndexPrimitive(keyDescriptor, recordDescriptor, path));
}
public void ShouldReceiveFirstMessageFromBuffer()
{
const int length = 8;
var recordLength = length + RecordDescriptor.HeaderLength;
var recordLengthAligned = BitUtil.Align(recordLength, RecordDescriptor.RecordAlignment);
long tail = recordLengthAligned;
var latestRecord = tail - recordLengthAligned;
var recordOffset = (int)latestRecord;
A.CallTo(() => _buffer.GetLongVolatile(TailIntentCounterOffset)).Returns(tail);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetLengthOffset(recordOffset))).Returns(recordLength);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetTypeOffset(recordOffset))).Returns(MsgTypeID);
Assert.True(_broadcastReceiver.ReceiveNext());
Assert.AreEqual(MsgTypeID, _broadcastReceiver.TypeId());
Assert.AreEqual(_buffer, _broadcastReceiver.Buffer());
Assert.AreEqual(RecordDescriptor.GetMsgOffset(recordOffset), _broadcastReceiver.Offset());
Assert.AreEqual(length, _broadcastReceiver.Length());
Assert.True(_broadcastReceiver.Validate());
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).MustHaveHappened();
A.CallTo(() => _buffer.GetLongVolatile(TailIntentCounterOffset)).MustHaveHappened();
}
public static Message Deserialize(BinaryReader reader)
{
int structType = reader.ReadInt32();
int pathCount = reader.ReadInt32();
string[] path = new string[pathCount];
for (int i = 0; i < pathCount; i++)
{
int sizeOfString = reader.ReadInt32();
byte[] pathNameBytes = reader.ReadBytes(sizeOfString);
path[i] = Encoding.Unicode.GetString(pathNameBytes);
}
KeyDescriptor keyDescriptor = KeyDescriptor.Deserialize(reader);
RecordDescriptor recordDescriptor = RecordDescriptor.Deserialize(reader);
ILocator locator = STSdb4.Database.Locator.Obtain(structType, keyDescriptor, recordDescriptor, path);
IndexPersistOperationCollection persistOperations = new IndexPersistOperationCollection(locator);
IOperationCollection operations = persistOperations.Read(reader);
return(new Message(operations));
}
public void ShouldLateJoinTransmission()
{
const int length = 8;
var recordLength = length + RecordDescriptor.HeaderLength;
var recordLengthAligned = BitUtil.Align(recordLength, RecordDescriptor.RecordAlignment);
var tail = Capacity * 3L + RecordDescriptor.HeaderLength + recordLengthAligned;
var latestRecord = tail - recordLengthAligned;
var recordOffset = (int)latestRecord & (Capacity - 1);
A.CallTo(() => _buffer.GetLongVolatile(TailIntentCounterOffset)).Returns(tail);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
A.CallTo(() => _buffer.GetLong(LatestCounterIndex)).Returns(latestRecord);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetLengthOffset(recordOffset))).Returns(recordLength);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetTypeOffset(recordOffset))).Returns(MsgTypeID);
Assert.IsTrue(_broadcastReceiver.ReceiveNext());
Assert.AreEqual(MsgTypeID, _broadcastReceiver.TypeId());
Assert.AreEqual(_buffer, _broadcastReceiver.Buffer());
Assert.AreEqual(RecordDescriptor.GetMsgOffset(recordOffset), _broadcastReceiver.Offset());
Assert.AreEqual(length, _broadcastReceiver.Length());
Assert.True(_broadcastReceiver.Validate());
Assert.Greater(_broadcastReceiver.LappedCount(), 0);
}
public void ShouldCopeWithPaddingRecordAndWrapOfBufferForNextRecord()
{
const int length = 120;
var recordLength = length + RecordDescriptor.HeaderLength;
var recordLengthAligned = BitUtil.Align(recordLength, RecordDescriptor.RecordAlignment);
var catchupTail = (Capacity * 2L) - RecordDescriptor.HeaderLength;
var postPaddingTail = catchupTail + RecordDescriptor.HeaderLength + recordLengthAligned;
var latestRecord = catchupTail - recordLengthAligned;
var catchupOffset = (int)latestRecord & (Capacity - 1);
A.CallTo(() => _buffer.GetLongVolatile(TailIntentCounterOffset)).ReturnsNextFromSequence(catchupTail, postPaddingTail);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).ReturnsNextFromSequence(catchupTail, postPaddingTail);
A.CallTo(() => _buffer.GetLong(LatestCounterIndex)).Returns(latestRecord);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetLengthOffset(catchupOffset))).Returns(recordLength);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetTypeOffset(catchupOffset))).Returns(MsgTypeID);
var paddingOffset = (int)catchupTail & (Capacity - 1);
var recordOffset = (int)(postPaddingTail - recordLengthAligned) & (Capacity - 1);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetTypeOffset(paddingOffset))).Returns(RecordDescriptor.PaddingMsgTypeID);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetLengthOffset(recordOffset))).Returns(recordLength);
A.CallTo(() => _buffer.GetInt(RecordDescriptor.GetTypeOffset(recordOffset))).Returns(MsgTypeID);
Assert.IsTrue(_broadcastReceiver.ReceiveNext()); // To catch up to record before padding.
Assert.IsTrue(_broadcastReceiver.ReceiveNext()); // no skip over the padding and read next record.
Assert.AreEqual(MsgTypeID, _broadcastReceiver.TypeId());
Assert.AreEqual(_buffer, _broadcastReceiver.Buffer());
Assert.AreEqual(RecordDescriptor.GetMsgOffset(recordOffset), _broadcastReceiver.Offset());
Assert.AreEqual(length, _broadcastReceiver.Length());
Assert.True(_broadcastReceiver.Validate());
}
/// <summary>
/// Visits the record descriptor.
/// </summary>
/// <param name="recordDescriptor">The record descriptor to visit.</param>
public override void VisitRecordDescriptor(RecordDescriptor recordDescriptor)
{
if (recordDescriptor.Id != null)
{
this.dictionary.Add(recordDescriptor.Id, recordDescriptor);
}
base.VisitRecordDescriptor(recordDescriptor);
}
public static BinaryRecordReader GetBinaryRecordReader(this RecordDescriptor desc, string fullPath)
{
var fileStream = File.OpenRead(fullPath);
// var gzipStream = new GZipStream(fileStream, CompressionMode.Decompress);
var gzipStream = new GZipInputStream(fileStream);
return(new BinaryRecordReader(desc, gzipStream));
}
public override void NewRecord(RecordDescriptor recordDescriptor)
{
_writer.Write((Int32)recordDescriptor.Record);
_currentRecordInfos.Push(new CurrentRecordInfo(recordDescriptor, _stream.Position));
_writer.Write(RecordSizePlaceHolder);
_writer.Write(recordDescriptor.Version);
}
private static IEnumerable <string> GetLines(
IEnumerable <string> template,
RecordDescriptor desc,
string className)
{
foreach (var line in template)
{
var l = line.Trim();
if (l.StartsWith("public class"))
{
yield return(line.Replace(nameof(ModelClassTemplate), className));
}
else if (l.StartsWith("[QuerySqlField"))
{
foreach (var field in desc.Fields)
{
yield return(line
.Replace(nameof(ModelClassTemplate.FieldTemplate), GetPropertyName(field.Name))
.Replace("SQL_NAME", field.Name)
.Replace("string", field.Type.GetShortTypeName()));
}
}
else if (l.StartsWith("writer.WriteString"))
{
foreach (var field in desc.Fields)
{
yield return(line
.Replace(nameof(ModelClassTemplate.FieldTemplate), GetPropertyName(field.Name))
.Replace("SQL_NAME", field.Name)
.Replace("WriteString", field.Type.GetWriteMethodName()));
}
}
else if (l.StartsWith("FieldTemplate = reader.ReadString"))
{
foreach (var field in desc.Fields)
{
yield return(line
.Replace(nameof(ModelClassTemplate.FieldTemplate), GetPropertyName(field.Name))
.Replace("SQL_NAME", field.Name)
.Replace("ReadString", field.Type.GetReadMethodName()));
}
}
else if (l.StartsWith("FieldTemplate = Encoding.ASCII.GetString"))
{
foreach (var field in desc.Fields)
{
yield return(new string(' ', 16) + GetReadFromRecordBufferCode(field));
}
}
else
{
yield return(line);
}
}
}
public CurrentRecordInfo(RecordDescriptor recordDescriptor, Int64 recordSizePosition)
{
RecordDescriptor = recordDescriptor;
RecordSizePosition = (Int32)recordSizePosition;
if (RecordSizePosition != recordSizePosition)
{
throw new RecordArchiveException("Record size overflow detected");
}
}
public void Decode()
{
using (MemoryStream ms = new MemoryStream(Raw))
{
BinaryReader reader = new BinaryReader(ms);
KeyDescriptor = KeyDescriptor.Deserialize(reader);
RecordDescriptor = RecordDescriptor.Deserialize(reader);
IsDecoded = true;
}
}
private static void InvokeCreateCacheGeneric(RecordDescriptor desc, IIgnite ignite)
{
// A bit of reflection won't hurt once per table.
var method = typeof(CacheLoader)
.GetMethod(nameof(CreateCacheGeneric), BindingFlags.Static | BindingFlags.NonPublic);
var genericMethod = method.MakeGenericMethod(desc.GetModelType());
genericMethod.Invoke(null, new object[] { ignite, desc });
}
/**
* Add a recordDescriptor to the data set.
*
* @param recordDescriptor The recordDescriptor to be added.
*/
public void AddRecordDescriptor(RecordDescriptor recordDescriptor)
{
if (recordDescriptor != null)
{
if (RecordDescriptors == null)
{
RecordDescriptors = new List <RecordDescriptor>();
}
RecordDescriptors.Add(recordDescriptor);
}
}
public static void GenerateClass(RecordDescriptor desc)
{
Arg.NotNull(desc, nameof(desc));
var template = Template.Value;
var className = GetClassName(desc.TableName);
var lines = GetLines(template, desc, className);
var targetPath = Path.Combine(AsmPath, "..", "..", "..", "Models", className + ".cs");
File.WriteAllLines(targetPath, lines);
}
public XFile OpenXFile(params string[] path)
{
var keyDescriptor = new KeyDescriptor(DataType.Int64, false);
var recordDescriptor = new RecordDescriptor(DataType.ByteArray, false);
ILocator p = Locator.Obtain(StructureType.XFILE, keyDescriptor, recordDescriptor, path);
XIndex index = new XIndex(this, p);
return(new XFile(index));
}
private static void InvokeLoadCacheGeneric(RecordDescriptor desc, string dir, IIgnite ignite,
ConcurrentBag <DataFileInfo> dataFiles)
{
// A bit of reflection won't hurt once per table.
var method = typeof(CacheLoader)
.GetMethod(nameof(LoadCacheGeneric), BindingFlags.Static | BindingFlags.NonPublic);
var genericMethod = method.MakeGenericMethod(desc.GetModelType());
genericMethod.Invoke(null, new object[] { ignite, desc, dir, dataFiles });
}
public void ShouldNotUnblockGapWithMessageRaceOnSecondMessageIncreasingTailThenInterrupting()
{
var messageLength = RecordDescriptor.Alignment * 4;
A.CallTo(() => _buffer.GetLongVolatile(HeadCounterIndex)).Returns(messageLength);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns((long)messageLength * 3);
A.CallTo(() => _buffer.GetIntVolatile(messageLength * 2)).ReturnsNextFromSequence(0, messageLength);
Assert.False(_ringBuffer.Unblock());
A.CallTo(() => _buffer.PutLongOrdered(messageLength, RecordDescriptor.MakeHeader(messageLength, ManyToOneRingBuffer.PaddingMsgTypeId))).MustNotHaveHappened();
}
public void ShouldUnblockMessageWithHeader()
{
var messageLength = RecordDescriptor.Alignment * 4;
A.CallTo(() => _buffer.GetLongVolatile(HeadCounterIndex)).Returns(messageLength);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns((long)messageLength * 2);
A.CallTo(() => _buffer.GetIntVolatile(messageLength)).Returns(-messageLength);
Assert.True(_ringBuffer.Unblock());
A.CallTo(() => _buffer.PutLongOrdered(messageLength, RecordDescriptor.MakeHeader(messageLength, ManyToOneRingBuffer.PaddingMsgTypeId))).MustHaveHappened();
}
public void Encode()
{
using (MemoryStream ms = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(ms);
KeyDescriptor.Serialize(writer);
RecordDescriptor.Serialize(writer);
Raw = ms.ToArray();
IsEncoded = true;
}
}
public static Type GetModelType(this RecordDescriptor desc)
{
var typeName = "Apache.Ignite.Sybase.Ingest.Cache." + ModelClassGenerator.GetClassName(desc.TableName);
var type = Type.GetType(typeName);
if (type == null)
{
throw new Exception("Model class not found: " + typeName);
}
return(type);
}
public static string[] GetDataFilePaths(this RecordDescriptor desc, string dir)
{
Arg.NotNull(desc, nameof(desc));
Arg.NotNullOrWhitespace(dir, nameof(dir));
var fileName = desc.InFile.Split(
new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar },
StringSplitOptions.RemoveEmptyEntries)
.Last()
.Replace(".ctrl.gen", ".*.gz");
return(Directory.GetFiles(dir, fileName));
}
private static ILocator Create(int structType, KeyDescriptor keyDescriptor, RecordDescriptor recordDescriptor, params string[] path)
{
if (!STSdb4.Database.StructureType.IsValid(structType))
{
throw new ArgumentException("Invalid structType");
}
StructureDescriptor descriptor = new StructureDescriptor(keyDescriptor, recordDescriptor);
descriptor.Encode();
return(new Locator(structType, descriptor, path));
}
public IIndex <TKey, TRecord> OpenXIndex <TKey, TRecord>(IDataTransformer <TKey> keyTransformer, IDataTransformer <TRecord> recordTransformer, CompareOption[] compareOptions, bool compressKeys, bool compressRecords, params string[] path)
{
DataType keyType = keyTransformer.DataType;
DataType recordType = recordTransformer.DataType;
keyType.CheckCompareOptions(compareOptions);
KeyDescriptor keyDescriptor = new KeyDescriptor(keyType, compressKeys, compareOptions);
RecordDescriptor recordDescriptor = new RecordDescriptor(recordType, compressRecords);
var index = OpenXIndex(keyDescriptor, recordDescriptor, path);
return(new XIndex <TKey, TRecord>(index, keyTransformer, recordTransformer));
}
public static (BinaryRecordReader Reader, string FullPath) GetInFileStream(this RecordDescriptor desc, string dir)
{
// TODO: Some tables can be in multiple files.
var fullPath = desc.GetInFilePath(dir);
if (!File.Exists(fullPath))
{
return(null, fullPath);
}
var reader = GetBinaryRecordReader(desc, fullPath);
return(reader, fullPath);
}
// According to HTML1.1, PUT can create an entity at a URI (return 201) or update (return 200)
public HttpResponseMessage Put(RecordDescriptor recordSchema)
{
var instanceValidator = new RecordSchemaValidator(documentSession);
var results = instanceValidator.Validate(recordSchema);
if (!results.IsValid)
{
BadRequest(results);
}
// Update internal ItemType field (could do in RavenDb behavior)
recordSchema.UpdateFieldTypes();
documentSession.Store(recordSchema, recordSchema.Etag);
var pathToResource = string.Format("schema/getbyname?name={0}", recordSchema.Name);
return SaveChanges(recordSchema, pathToResource);
}
private void InitialiseSurveySchema()
{
/* Survey */
var surveyFieldDescriptors = new List<FieldDescriptor>
{
new FieldDescriptor
{
ItemType = typeof(string),
Name = "Name",
Description = "What is the name of the survey?"
},
new FieldDescriptor
{
FriendlyType = "1 to many",
ItemType = typeof(List<RecordRef>),
Name = "Responses",
Description = ""
}
};
var surveyDescriptor = new RecordDescriptor
{
FieldDescriptors = surveyFieldDescriptors,
Id = "recordSchema/Survey1",
Name = "Survey"
};
session.Store(surveyDescriptor);
/* Response */
var surveyResponseFieldDescriptors = new List<FieldDescriptor>
{
new FieldDescriptor
{
ItemType = typeof(string),
Name = "Q1",
Description = "Do surveys make a difference?"
},
new FieldDescriptor
{
ItemType = typeof(int),
Name = "Q2",
Description = "How many survey's have you filled out in the last hour?"
},
new FieldDescriptor
{
ItemType = typeof(string),
Name = "RecipientId",
Description = "The recipient"
},
new FieldDescriptor
{
ItemType = typeof(RecordRef),
Name = "ParentReference",
Description = "ParentRef"
},
};
var surveyResponseDescriptor = new RecordDescriptor
{
FieldDescriptors = surveyResponseFieldDescriptors,
Id = "recordSchema/SurveyResponse",
Name = "SurveyResponse"
};
session.Store(surveyResponseDescriptor);
}
private static void CreateSampleRecordDescriptor()
{
using (var session = ds.OpenSession("SoftModel"))
{
if (session.Load<RecordDescriptor>("personSchema") != null)
return;
var stringDef = new FieldDescriptor { ItemType = typeof(string), Name = "Name" };
var intDef = new FieldDescriptor { ItemType = typeof(int), Name = "Age" };
var recordSchema = new RecordDescriptor
{
Id = "personSchema",
Name = "Person Schema",
FieldDescriptors = new List<FieldDescriptor> { stringDef, intDef }
};
session.Store(recordSchema);
session.SaveChanges();
var retrieved = session.Load<RecordDescriptor>(recordSchema.Id);
}
}
public abstract void NewRecord(RecordDescriptor recordDescriptor);
