private static long GetLongField(BlittableJsonReaderObject json, CommandType type, string fieldName)
{
if (json.TryGet(fieldName, out long longValue) == false)
{
ThrowMissingField(type, fieldName);
}
return(longValue);
}
private static bool GetBooleanField(BlittableJsonReaderObject json, CommandType type, string fieldName)
{
if (json.TryGet(fieldName, out bool boolValue) == false)
{
ThrowMissingField(type, fieldName);
}
return(boolValue);
}
public string GetTypeFromCommand(BlittableJsonReaderObject cmd)
{
if (cmd.TryGet("Type", out string type) == false)
{
throw new RachisApplyException("Cannot execute command, wrong format");
}
return(type);
}
private static LazyStringValue GetLazyStringField(BlittableJsonReaderObject json, CommandType type, string fieldName, bool throwOnMissing = true)
{
if ((json.TryGet(fieldName, out LazyStringValue value) == false || value == null) && throwOnMissing)
{
ThrowMissingField(type, fieldName);
}
return(value);
}
public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache)
{
response.TryGet(nameof(FormatOperation.Result.Expression), out string function);
Result = new Result
{
Expression = function
};
}
public string GetGuidFromCommand(BlittableJsonReaderObject cmd)
{
if (cmd.TryGet(nameof(CommandBase.UniqueRequestId), out string guid))
{
return(guid);
}
return(null);
}
public static LazyStringValue GetLazyCollectionNameFrom(JsonOperationContext context, BlittableJsonReaderObject document)
{
if (document.TryGet(MetadataKeySegment, out BlittableJsonReaderObject metadata) == false ||
metadata.TryGet(MetadataCollectionSegment, out LazyStringValue collectionName) == false)
{
return(context.GetLazyStringForFieldWithCaching(EmptyCollectionSegment));
}
return(collectionName);
}
private static IndexDefinition ReadIndexDefinition(BlittableJsonReaderObject reader)
{
if (reader.TryGet(nameof(IndexDefinition), out BlittableJsonReaderObject jsonObject) == false || jsonObject == null)
{
throw new InvalidOperationException("No persisted definition");
}
return(JsonDeserializationServer.IndexDefinition(jsonObject));
}
public static string GetChangeVector(BlittableJsonReaderObject metadata)
{
if (metadata.TryGet(Constants.Documents.Metadata.ChangeVector, out string changeVector) == false)
{
InvalidMissingChangeVector();
}
return(changeVector);
}
public static DocumentConflictException From(BlittableJsonReaderObject json)
{
if (json.TryGet(nameof(DocId), out string docId) == false)
{
throw new InvalidDataException("Expected to find property named " + nameof(DocId) + " in the exception received from the server, but didn't find it. This is probably a bug and should be reported.");
}
if (json.TryGet(nameof(Message), out string message) == false)
{
throw new InvalidDataException("Expected to find property named " + nameof(Message) + " in the exception received from the server, but didn't find it. This is probably a bug and should be reported.");
}
if (json.TryGet(nameof(LargestEtag), out long etag) == false)
{
throw new InvalidDataException("Expected to find property named " + nameof(LargestEtag) + " in the exception received from the server, but didn't find it. This is probably a bug and should be reported.");
}
return(new DocumentConflictException(message, docId, etag));
}
private static string GetStringFromJson(BlittableJsonReaderObject reader, string value)
{
string str;
if (reader.TryGet(value, out str) == false)
{
throw new InvalidOperationException($"Missing string '{value}' in message : ${reader}");
}
return(str);
}
public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache)
{
if (response == null || response.TryGet("NewIdentityValue", out long results) == false)
{
ThrowInvalidResponse();
return; // never hit
}
Result = results;
}
private static DateTime GetDateTimeFromJson(BlittableJsonReaderObject reader, string value)
{
string str;
if (reader.TryGet(value, out str) == false)
{
throw new InvalidOperationException($"Missing DateTime '{value}' in message : ${reader}");
}
return(DateTime.Parse(str));
}
private static int GetIntFromJson(BlittableJsonReaderObject reader, string value)
{
int int32;
if (reader.TryGet(value, out int32) == false)
{
throw new InvalidOperationException($"Missing int '{value}' in message : ${reader}");
}
return(int32);
}
public void Put(DocumentsOperationContext context, Slice lowerId, BlittableJsonReaderObject document)
{
if (document.TryGet(Constants.Documents.Metadata.Key, out BlittableJsonReaderObject metadata) == false ||
metadata.TryGet(Constants.Documents.Metadata.Expires, out string expirationDate) == false)
{
return;
}
PutInternal(context, lowerId, expirationDate);
}
protected override long ExecuteCmd(DocumentsOperationContext context)
{
var hiLoDocumentId = RavenHiloIdPrefix + Key;
var prefix = Key + Separator;
var newDoc = new DynamicJsonValue();
BlittableJsonReaderObject hiloDocReader = null;
try
{
try
{
hiloDocReader = Database.DocumentsStorage.Get(context, hiLoDocumentId)?.Data;
}
catch (DocumentConflictException e)
{
throw new InvalidDataException("Failed to fetch HiLo document due to a conflict on the document. " +
"This shouldn't happen, since it this conflict should've been resolved during replication. " +
"This exception should not happen and is likely a bug.", e);
}
if (hiloDocReader == null)
{
OldMax = LastRangeMax;
newDoc["Max"] = OldMax + Capacity;
newDoc[Constants.Documents.Metadata.Key] = new DynamicJsonValue
{
[Constants.Documents.Metadata.Collection] = CollectionName.HiLoCollection
};
using (var freshHilo = context.ReadObject(newDoc, hiLoDocumentId, BlittableJsonDocumentBuilder.UsageMode.ToDisk))
Database.DocumentsStorage.Put(context, hiLoDocumentId, null, freshHilo);
}
else
{
hiloDocReader.TryGet("Max", out long oldMax);
OldMax = Math.Max(oldMax, LastRangeMax);
hiloDocReader.Modifications = new DynamicJsonValue(hiloDocReader)
{
["Max"] = OldMax + Capacity
};
using (var freshHilo = context.ReadObject(hiloDocReader, hiLoDocumentId, BlittableJsonDocumentBuilder.UsageMode.ToDisk))
Database.DocumentsStorage.Put(context, hiLoDocumentId, null, freshHilo);
}
Prefix = prefix;
}
finally
{
hiloDocReader?.Dispose();
}
return(1);
}
public void EnsureMetadata()
{
if (_metadataEnsured)
{
return;
}
_metadataEnsured = true;
DynamicJsonValue mutatedMetadata;
if (Data.TryGet(Constants.Documents.Metadata.Key, out BlittableJsonReaderObject metadata))
{
if (metadata.Modifications == null)
{
metadata.Modifications = new DynamicJsonValue(metadata);
}
mutatedMetadata = metadata.Modifications;
}
else
{
Data.Modifications = new DynamicJsonValue(Data)
{
[Constants.Documents.Metadata.Key] = mutatedMetadata = new DynamicJsonValue()
};
}
mutatedMetadata[Constants.Documents.Metadata.Id] = Id;
if (ChangeVector != null)
{
mutatedMetadata[Constants.Documents.Metadata.ChangeVector] = ChangeVector;
}
if (Flags != DocumentFlags.None)
{
mutatedMetadata[Constants.Documents.Metadata.Flags] = Flags.ToString();
}
if (IndexScore.HasValue)
{
mutatedMetadata[Constants.Documents.Metadata.IndexScore] = IndexScore;
}
_hash = null;
}
protected static string ReadName(BlittableJsonReaderObject reader)
{
string name;
if (reader.TryGet(nameof(Name), out name) == false || string.IsNullOrWhiteSpace(name))
{
throw new InvalidOperationException("No persisted name");
}
return(name);
}
public override void SetResponse(BlittableJsonReaderObject response, bool fromCache)
{
if (response == null || response.TryGet("NewSeedValue", out long result) == false)
{
ThrowInvalidResponse();
return; // never hit
}
Result = result;
}
public static Dictionary <string, CompareExchangeValue <T> > GetValues(BlittableJsonReaderObject response, DocumentConventions conventions)
{
if (response.TryGet("Results", out BlittableJsonReaderArray items) == false)
{
throw new InvalidDataException("Response is invalid. Results is missing.");
}
var results = new Dictionary <string, CompareExchangeValue <T> >();
foreach (BlittableJsonReaderObject item in items)
{
if (item == null)
{
throw new InvalidDataException("Response is invalid. Item is null.");
}
if (item.TryGet("Key", out string key) == false)
{
throw new InvalidDataException("Response is invalid. Key is missing.");
}
if (item.TryGet("Index", out long index) == false)
{
throw new InvalidDataException("Response is invalid. Index is missing.");
}
if (item.TryGet("Value", out BlittableJsonReaderObject raw) == false)
{
throw new InvalidDataException("Response is invalid. Value is missing.");
}
if (typeof(T).GetTypeInfo().IsPrimitive || typeof(T) == typeof(string))
{
// simple
T value = default;
raw?.TryGet("Object", out value);
results[key] = new CompareExchangeValue <T>(key, index, value);
}
else
{
BlittableJsonReaderObject val = null;
raw?.TryGet("Object", out val);
if (val == null)
{
results[key] = new CompareExchangeValue <T>(key, index, default);
}
else
{
var converted = (T)EntityToBlittable.ConvertToEntity(typeof(T), null, val, conventions);
results[key] = new CompareExchangeValue <T>(key, index, converted);
}
}
}
return(results);
}
public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache)
{
Result = new List <string>();
response.TryGet(nameof(IndexQueryServerSide.Diagnostics), out BlittableJsonReaderArray array);
foreach (var item in array)
{
Result.Add(item.ToString());
}
}
public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache)
{
Result = new List <string>();
response.TryGet("Nodes", out BlittableJsonReaderArray array);
foreach (var item in array)
{
Result.Add(item.ToString());
}
}
public static DateTime GetLastModified(this BlittableJsonReaderObject metadata)
{
DateTime lastModified;
if (metadata.TryGet(Constants.Documents.Metadata.LastModified, out lastModified) == false)
{
InvalidMissingLastModified();
}
return(lastModified);
}
public static string GetId(this BlittableJsonReaderObject metadata)
{
string id;
if (metadata.TryGet(Constants.Documents.Metadata.Id, out id) == false)
{
throw new InvalidOperationException($"Metadata does not contain '{Constants.Documents.Metadata.Id}' field.");
}
return(id);
}
public static BlittableJsonReaderObject GetMetadata(this BlittableJsonReaderObject document)
{
BlittableJsonReaderObject metadata;
if (document.TryGet(Constants.Documents.Metadata.Key, out metadata) == false || metadata == null)
{
throw new InvalidOperationException($"Document does not contain '{Constants.Documents.Metadata.Key}' field.");
}
return(metadata);
}
public static bool HasPassed(BlittableJsonReaderObject data, DateTime currentTime)
{
// Validate that the expiration value in metadata is still the same.
// We have to check this as the user can update this value.
if (data.TryGet(Constants.Documents.Metadata.Key, out BlittableJsonReaderObject metadata) == false)
{
return(false);
}
return(HasPassed(metadata, Constants.Documents.Metadata.Expires, currentTime));
}
protected static IndexLockMode ReadLockMode(BlittableJsonReaderObject reader)
{
int lockModeAsInt;
if (reader.TryGet(nameof(LockMode), out lockModeAsInt) == false)
{
throw new InvalidOperationException("No persisted lock mode");
}
return((IndexLockMode)lockModeAsInt);
}
public static string GetCollectionName(BlittableJsonReaderObject document)
{
string collectionName;
BlittableJsonReaderObject metadata;
if (document == null || document.TryGet(Constants.Metadata.Key, out metadata) == false ||
metadata.TryGet(Constants.Headers.RavenEntityName, out collectionName) == false)
{
collectionName = EmptyCollection;
}
return(collectionName);
}
public static CompareExchangeResult <T> ParseFromBlittable(BlittableJsonReaderObject response, DocumentConventions conventions)
{
if (response.TryGet(nameof(Index), out long index) == false)
{
throw new InvalidDataException("Response is invalid. Index is missing.");
}
response.TryGet(nameof(Successful), out bool successful);
response.TryGet(nameof(Value), out BlittableJsonReaderObject raw);
T result;
object val = null;
raw?.TryGet("Object", out val);
if (val == null)
{
return(new CompareExchangeResult <T>
{
Index = index,
Value = default(T),
Successful = successful
});
}
if (val is BlittableJsonReaderObject obj)
{
result = (T)EntityToBlittable.ConvertToEntity(typeof(T), "cluster-value", obj, conventions);
}
else
{
raw.TryGet("Object", out result);
}
return(new CompareExchangeResult <T>
{
Index = index,
Value = result,
Successful = successful
});
}
public static CounterOperation Parse(BlittableJsonReaderObject input)
{
if (input.TryGet(nameof(CounterName), out string name) == false || name == null)
{
ThrowMissingCounterName();
}
if (input.TryGet(nameof(Type), out string type) == false || type == null)
{
ThrowMissingCounterOperationType(name);
}
var counterOperationType = (CounterOperationType)Enum.Parse(typeof(CounterOperationType), type);
long?delta = null;
switch (counterOperationType)
{
case CounterOperationType.Increment:
case CounterOperationType.Put:
if (input.TryGet(nameof(Delta), out delta) == false)
{
ThrowMissingDeltaProperty(name, counterOperationType);
}
break;
}
var counterOperation = new CounterOperation
{
Type = counterOperationType,
CounterName = name
};
if (delta != null)
{
counterOperation.Delta = delta.Value;
}
return(counterOperation);
}