private void ReplayWriteAction(WriteActivityEntry activityEntry, ref Transaction tx)
{
switch (activityEntry.ActionType)
{
case DebugActionType.Add:
tx.ReadTree(activityEntry.TreeName).Add(activityEntry.Key, activityEntry.ValueStream);
break;
case DebugActionType.Delete:
tx.ReadTree(activityEntry.TreeName).Delete(activityEntry.Key);
break;
case DebugActionType.MultiAdd:
tx.ReadTree(activityEntry.TreeName).MultiAdd(activityEntry.Key, new Slice(Encoding.UTF8.GetBytes(activityEntry.Value.ToString())));
break;
case DebugActionType.MultiDelete:
tx.ReadTree(activityEntry.TreeName).MultiDelete(activityEntry.Key, new Slice(Encoding.UTF8.GetBytes(activityEntry.Value.ToString())));
break;
case DebugActionType.CreateTree:
_env.CreateTree(tx, activityEntry.TreeName);
break;
case DebugActionType.Increment:
var buffer = new byte[sizeof(long)];
activityEntry.ValueStream.Read(buffer, 0, buffer.Length);
var delta = EndianBitConverter.Little.ToInt64(buffer, 0);
tx.ReadTree(activityEntry.TreeName).Increment(activityEntry.Key, delta);
break;
default: //precaution against newly added action types
throw new InvalidOperationException("unsupported tree action type");
}
}
public void RecordWriteAction(DebugActionType actionType, Transaction tx, Slice key, string treeName, object value)
{
if (IsRecording)
{
var newAction = new WriteActivityEntry(actionType, tx.Id, key, treeName, value);
WriteQueue.Enqueue(newAction);
WriteAndFlush(newAction);
}
}
public static BaseActivityEntry FromCsvLine(string csvLine, bool recordOnlyValueLength)
{
var firstToken = csvLine.Substring(0, csvLine.IndexOf(",", StringComparison.Ordinal));
if (firstToken.StartsWith("Flush"))
{
return(FlushActivityEntry.FromCsvLine(csvLine));
}
if (firstToken.StartsWith("Transaction"))
{
return(TransactionActivityEntry.FromCsvLine(csvLine, recordOnlyValueLength));
}
return(WriteActivityEntry.FromCsvLine(csvLine, recordOnlyValueLength));
}
public new static WriteActivityEntry FromCsvLine(string csvLine, bool recordOnlyValueLength)
{
var columnArray = csvLine.Split(new[] { ',' }).ToList();
if (columnArray.Count != 5)
{
throw new ArgumentException("invalid csv data - check that you do not have commas in data");
}
try
{
var type = GenericUtil.ParseEnum <DebugActionType>(columnArray[0]);
if (type == DebugActionType.CreateTree)
{
var activityEntry = new WriteActivityEntry(
type,
long.Parse(columnArray[1]),
Slice.Empty,
columnArray[2],
null);
return(activityEntry);
}
if (type == DebugActionType.Delete)
{
var activityEntry = new WriteActivityEntry(
type,
long.Parse(columnArray[1]),
columnArray[3],
columnArray[2],
null);
return(activityEntry);
}
var random = new Random();
object value;
switch (type)
{
case DebugActionType.Increment:
var delta = long.Parse(Encoding.UTF8.GetString(Convert.FromBase64String(columnArray[4])));
value = new MemoryStream(EndianBitConverter.Little.GetBytes(delta));
break;
case DebugActionType.MultiAdd:
case DebugActionType.MultiDelete:
value = new Slice(Convert.FromBase64String(columnArray[4]));
break;
default:
if (recordOnlyValueLength)
{
var length = long.Parse(columnArray[4]);
var bytes = new byte[length];
random.NextBytes(bytes);
value = new MemoryStream(bytes);
}
else
{
value = new MemoryStream(Convert.FromBase64String(columnArray[4]));
}
break;
}
var entry = new WriteActivityEntry(
type,
long.Parse(columnArray[1]),
columnArray[3],
columnArray[2],
value);
return(entry);
}
catch (Exception e)
{
throw new ArgumentException("Unable to parse the argument", e);
}
}
public static new WriteActivityEntry FromCsvLine(string csvLine, bool recordOnlyValueLength)
{
var columnArray = csvLine.Split(new[] { ',' }).ToList();
if (columnArray.Count != 5)
throw new ArgumentException("invalid csv data - check that you do not have commas in data");
try
{
var type = GenericUtil.ParseEnum<DebugActionType>(columnArray[0]);
if (type == DebugActionType.CreateTree)
{
var activityEntry = new WriteActivityEntry(
type,
long.Parse(columnArray[1]),
Slice.Empty,
columnArray[2],
null);
return activityEntry;
}
if (type == DebugActionType.Delete)
{
var activityEntry = new WriteActivityEntry(
type,
long.Parse(columnArray[1]),
(Slice)columnArray[3],
columnArray[2],
null);
return activityEntry;
}
var random = new Random();
object value;
switch (type)
{
case DebugActionType.Increment:
var delta = long.Parse(Encoding.UTF8.GetString(Convert.FromBase64String(columnArray[4])));
value = new MemoryStream(EndianBitConverter.Little.GetBytes(delta));
break;
case DebugActionType.MultiAdd:
case DebugActionType.MultiDelete:
value = new Slice(Convert.FromBase64String(columnArray[4]));
break;
default:
if (recordOnlyValueLength)
{
var length = long.Parse(columnArray[4]);
var bytes = new byte[length];
random.NextBytes(bytes);
value = new MemoryStream(bytes);
}
else
value = new MemoryStream(Convert.FromBase64String(columnArray[4]));
break;
}
var entry = new WriteActivityEntry(
type,
long.Parse(columnArray[1]),
(Slice)columnArray[3],
columnArray[2],
value);
return entry;
}
catch (Exception e)
{
throw new ArgumentException("Unable to parse the argument", e);
}
}
private void ReplayWriteAction(WriteActivityEntry activityEntry, ref Transaction tx)
{
var tree = tx.ReadTree(activityEntry.TreeName);
switch (activityEntry.ActionType)
{
case DebugActionType.Add:
tree.Add(activityEntry.Key, activityEntry.ValueStream);
break;
case DebugActionType.Delete:
tree.Delete(activityEntry.Key);
break;
case DebugActionType.MultiAdd:
tree.MultiAdd(activityEntry.Key, new Slice(Encoding.UTF8.GetBytes(activityEntry.Value.ToString())));
break;
case DebugActionType.MultiDelete:
tree.MultiDelete(activityEntry.Key, new Slice(Encoding.UTF8.GetBytes(activityEntry.Value.ToString())));
break;
case DebugActionType.CreateTree:
_env.CreateTree(tx, activityEntry.TreeName);
break;
case DebugActionType.Increment:
var buffer = new byte[sizeof(long)];
activityEntry.ValueStream.Read(buffer, 0, buffer.Length);
var delta = EndianBitConverter.Little.ToInt64(buffer, 0);
tree.Increment(activityEntry.Key, delta);
break;
case DebugActionType.AddStruct:
tree.Add(activityEntry.Key, activityEntry.ValueStream);
break;
case DebugActionType.RenameTree:
_env.RenameTree(tx, activityEntry.TreeName, activityEntry.Key.ToString());
break;
default: //precaution against newly added action types
throw new InvalidOperationException("unsupported tree action type: " + activityEntry.ActionType);
}
}
public void RecordWriteAction(DebugActionType actionType, Transaction tx, Slice key, string treeName, object value)
{
if (IsRecording)
{
var newAction = new WriteActivityEntry(actionType, tx.Id, key, treeName, value);
WriteQueue.Enqueue(newAction);
WriteAndFlush(newAction);
}
}
