public override void OnPut(string key, RavenJObject document, RavenJObject metadata, TransactionInformation transactionInformation)
{
if (key.StartsWith("Raven/", StringComparison.OrdinalIgnoreCase) && // we don't deal with system documents
key.StartsWith("Raven/Hilo/", StringComparison.OrdinalIgnoreCase) == false) // except for hilos
{
return;
}
using (Database.DisableAllTriggersForCurrentThread())
{
var documentMetadata = GetDocumentMetadata(key);
if (documentMetadata != null)
{
RavenJArray history = new RavenJArray(ReplicationData.GetHistory(documentMetadata));
metadata[Constants.RavenReplicationHistory] = history;
if (documentMetadata.ContainsKey(Constants.RavenReplicationVersion) &&
documentMetadata.ContainsKey(Constants.RavenReplicationSource))
{
history.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, documentMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, documentMetadata[Constants.RavenReplicationSource] }
});
}
while (history.Length > Constants.ChangeHistoryLength)
{
history.RemoveAt(0);
}
}
metadata[Constants.RavenReplicationVersion] = RavenJToken.FromObject(HiLo.NextId());
metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(Database.TransactionalStorage.Id);
}
}
public static string AddGold(LeagueServer server, int client, string args)
{
if (string.IsNullOrEmpty(args))
{
return("Missing speed value!");
}
float value = float.Parse(args);
byte[] buffer = BitConverter.GetBytes(value);
var packet = new OnReplication();
packet.SyncID = (uint)Environment.TickCount;
var data = new ReplicationData()
{
UnitNetID = 0x40000001,
};
data.Data[0] = new Tuple <uint, byte[]>(1, buffer);
packet.ReplicationData = new List <ReplicationData>()
{
data
};
server.SendEncrypted(client, ChannelID.Broadcast, packet);
var packet2 = new UnitAddGold
{
GoldAmmount = value,
TargetNetID = 0x40000001,
};
server.SendEncrypted(client, ChannelID.Broadcast, packet2);
return("Gold Added!");
}
public ReplicationData GetDatabase()
{
var replicationData = new ReplicationData();
replicationData.AccountInfo = _dbContext.AccountInfo.AsNoTracking().ToList();
replicationData.AccountInfo.ForEach(i =>
{
i.AccessToken = string.Empty;
i.AccessTokenExpiration = null;
});
replicationData.AccountInfoStatistics = _dbContext.AccountInfoStatistics.AsNoTracking().ToList();
replicationData.AccountClanHistory = _dbContext.AccountClanHistory.AsNoTracking().ToList();
replicationData.AccountClanInfo = _dbContext.AccountClanInfo.AsNoTracking().ToList();
replicationData.AccountInfoAchievements = _dbContext.AccountInfoAchievement.AsNoTracking()
.Where(a => EF.Property <string>(a, "Discriminator") == "AccountInfoAchievement")
.ToList();
replicationData.AccountInfoTankAchievements = _dbContext.AccountInfoTankAchievement.AsNoTracking()
.Where(a => EF.Property <string>(a, "Discriminator") == "AccountInfoTankAchievement")
.ToList();
replicationData.AccountTanksStatistics = _dbContext.AccountTankStatistics.AsNoTracking().ToList();
replicationData.PresentAccountTanks = _dbContext.PresentAccountTanks.AsNoTracking().ToList();
replicationData.Frags = _dbContext.Frags.AsNoTracking().ToList();
return(replicationData);
}
public static string TestRep(LeagueServer server, ClientID client, string args)
{
var packet = new OnReplication();
packet.SyncID = (uint)Environment.TickCount;
var data = new ReplicationData()
{
UnitNetID = (NetID)0x40000001,
};
byte[] buffer;
using (var stream = new MemoryStream())
{
using (var writer = new PacketWriter(stream, true))
{
writer.WritePackedFloat(333.0f);
writer.WritePackedFloat(123.0f);
}
buffer = new byte[stream.Length];
Buffer.BlockCopy(stream.GetBuffer(), 0, buffer, 0, buffer.Length);
}
data.Data[3] = new Tuple <uint, byte[]>((1 << 0) | (1 << 1), buffer);
packet.ReplicationData = new List <ReplicationData>()
{
data
};
server.SendEncrypted(client, ChannelID.Broadcast, packet);
return("TestRep!");
}
public override void OnPut(string key, Stream data, RavenJObject metadata)
{
if (key.StartsWith("Raven/")) // we don't deal with system attachment
{
return;
}
using (Database.DisableAllTriggersForCurrentThread())
{
var attachmentMetadata = GetAttachmentMetadata(key);
if (attachmentMetadata != null)
{
RavenJArray history = new RavenJArray(ReplicationData.GetHistory(metadata));
metadata[Constants.RavenReplicationHistory] = history;
if (attachmentMetadata.ContainsKey(Constants.RavenReplicationVersion) &&
attachmentMetadata.ContainsKey(Constants.RavenReplicationSource))
{
history.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, attachmentMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, attachmentMetadata[Constants.RavenReplicationSource] }
});
}
while (history.Length > Constants.ChangeHistoryLength)
{
history.RemoveAt(0);
}
}
metadata[Constants.RavenReplicationVersion] = RavenJToken.FromObject(HiLo.NextId());
metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(Database.TransactionalStorage.Id);
}
}
public static ReplicationData GetReplicationDataFrom(this IReplicable replicable, int typeId)
{
ReplicationData ret = new ReplicationData()
{
Id = replicable.Id,
TypeId = typeId,
NetworkMaster = ((Node)replicable).GetNetworkMaster(),
FieldValues = new List <byte[]>(),
};
foreach (var prop in replicable.GetType().GetProperties())
{
if (prop.GetCustomAttribute <Replicated>() != null)
{
ret.FieldValues.Add(Util.ObjToBytes(prop.GetValue(replicable), prop.PropertyType));
}
}
foreach (var prop in replicable.GetType().GetFields())
{
if (prop.GetCustomAttribute <Replicated>() != null)
{
ret.FieldValues.Add(Util.ObjToBytes(prop.GetValue(replicable), prop.FieldType));
}
}
return(ret);
}
public override void OnPut(string key, Stream data, RavenJObject metadata)
{
using (Database.DisableAllTriggersForCurrentThread())
{
metadata.Remove(Constants.RavenReplicationConflict);// you can't put conflicts
metadata.Remove(Constants.RavenReplicationConflictDocument);
var oldVersion = Database.Attachments.GetStatic(key);
if (oldVersion == null)
{
return;
}
if (oldVersion.Metadata[Constants.RavenReplicationConflict] == null)
{
return;
}
var history = new RavenJArray(ReplicationData.GetOrCreateHistory(metadata));
metadata[Constants.RavenReplicationHistory] = history;
// this is a conflict document, holding document keys in the
// values of the properties
var conflictData = oldVersion.Data().ToJObject();
var conflicts = conflictData.Value <RavenJArray>("Conflicts");
if (conflicts == null)
{
return;
}
foreach (var prop in conflicts)
{
var id = prop.Value <string>();
Attachment attachment = Database.Attachments.GetStatic(id);
if (attachment == null)
{
continue;
}
Database.Attachments.DeleteStatic(id, null);
// add the conflict history to the mix, so we make sure that we mark that we resolved the conflict
var conflictHistory = new RavenJArray(ReplicationData.GetOrCreateHistory(attachment.Metadata));
conflictHistory.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, attachment.Metadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, attachment.Metadata[Constants.RavenReplicationSource] }
});
foreach (var item in conflictHistory)
{
if (history.Any(x => RavenJTokenEqualityComparer.Default.Equals(x, item)))
{
continue;
}
history.Add(item);
}
}
}
}
/// <summary>
/// GetHashCode
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
var hashCode = -1592154030;
hashCode = hashCode * -1521134295 + Error.GetHashCodeWithNullCheck();
hashCode = hashCode * -1521134295 + ExplotationResult.GetHashCodeWithNullCheck();
hashCode = hashCode * -1521134295 + ErrorId.GetHashCodeWithNullCheck();
hashCode = hashCode * -1521134295 + ReplicationData.GetHashCodeWithNullCheck();
return(hashCode);
}
private void HandleAttachment(Attachment document)
{
deletedHistory.Value = new RavenJArray(ReplicationData.GetHistory(document.Metadata))
{
new RavenJObject
{
{ Constants.RavenReplicationVersion, document.Metadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, document.Metadata[Constants.RavenReplicationSource] }
}
};
}
private void HandleDocument(JsonDocumentMetadata metadata)
{
deletedHistory.Value = new RavenJArray(ReplicationData.GetOrCreateHistory(metadata.Metadata))
{
new RavenJObject
{
{ Constants.RavenReplicationVersion, metadata.Metadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, metadata.Metadata[Constants.RavenReplicationSource] }
}
};
}
/// <summary>
/// Equals
/// </summary>
/// <param name="obj">Object</param>
/// <returns>Return true if are equals</returns>
public bool Equals(FuzzerError obj)
{
if (obj == null)
{
return(false);
}
return(Error == obj.Error &&
ErrorId == obj.ErrorId &&
ExplotationResult == obj.ExplotationResult &&
((ReplicationData == null && obj.ReplicationData == null) ||
(obj.ReplicationData != null && ReplicationData.SequenceEqual(obj.ReplicationData))));
}
public override void OnPut(string key, RavenJObject document, RavenJObject metadata, TransactionInformation transactionInformation)
{
using (Database.DisableAllTriggersForCurrentThread())
{
metadata.Remove(Constants.RavenReplicationConflict); // you can't put conflicts
var oldVersion = Database.Get(key, transactionInformation);
if (oldVersion == null)
{
return;
}
if (oldVersion.Metadata[Constants.RavenReplicationConflict] == null)
{
return;
}
RavenJArray history = new RavenJArray(ReplicationData.GetHistory(metadata));
metadata[Constants.RavenReplicationHistory] = history;
var ravenJTokenEqualityComparer = new RavenJTokenEqualityComparer();
// this is a conflict document, holding document keys in the
// values of the properties
var conflicts = oldVersion.DataAsJson.Value <RavenJArray>("Conflicts");
if (conflicts == null)
{
return;
}
foreach (var prop in conflicts)
{
RavenJObject deletedMetadata;
Database.Delete(prop.Value <string>(), null, transactionInformation, out deletedMetadata);
// add the conflict history to the mix, so we make sure that we mark that we resolved the conflict
var conflictHistory = new RavenJArray(ReplicationData.GetHistory(deletedMetadata));
conflictHistory.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, deletedMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, deletedMetadata[Constants.RavenReplicationSource] }
});
foreach (var item in conflictHistory)
{
if (history.Any(x => ravenJTokenEqualityComparer.Equals(x, item)))
{
continue;
}
history.Add(item);
}
}
}
}
public void ShouldResolveConflictsToLocal()
{
ResolveConflictsCore(StraightforwardConflictResolution.ResolveToLocal, (store, id) =>
{
using (var session = store.OpenSession())
{
var company = session.Load <Company>(id);
Assert.Equal(company.Name, "Local");
var metadata = session.Advanced.GetMetadataFor(company);
Assert.Equal(2, ReplicationData.GetHistory(metadata).ToList().Count);
return(true);
}
});
}
public static void SetReplicationDataTo(this IReplicable replicable, ReplicationData data)
{
replicable.Id = data.Id;
((Node)replicable).SetNetworkMaster(data.NetworkMaster);
int i = 0;
foreach (var prop in replicable.GetType().GetProperties())
{
if (prop.GetCustomAttribute <Replicated>() != null)
{
prop.SetValue(replicable, Util.BytesToObj(data.FieldValues[i++], prop.PropertyType));
}
}
foreach (var prop in replicable.GetType().GetFields())
{
if (prop.GetCustomAttribute <Replicated>() != null)
{
prop.SetValue(replicable, Util.BytesToObj(data.FieldValues[i++], prop.FieldType));
}
}
}
public static string TestRep(LeagueServer server, int client, string args)
{
var packet = new OnReplication();
packet.SyncID = (uint)Environment.TickCount;
var data = new ReplicationData()
{
UnitNetID = 0x40000001,
};
using (var writer = new ByteWriter())
{
writer.WritePackedFloat(333.0f);
writer.WritePackedFloat(123.0f);
data.Data[3] = new Tuple <uint, byte[]>((1 << 0) | (1 << 1), writer.GetBytes());
}
packet.ReplicationData = new List <ReplicationData>()
{
data
};
server.SendEncrypted(client, ChannelID.Broadcast, packet);
return("TestRep!");
}
private void ReplicateDelete(string id, RavenJObject newMetadata, TExternal incoming)
{
TInternal existingItem;
Etag existingEtag;
bool deleted;
var existingMetadata = TryGetExisting(id, out existingItem, out existingEtag, out deleted);
if (existingMetadata == null)
{
if (log.IsDebugEnabled)
{
log.Debug("Replicating deleted item {0} from {1} that does not exist, ignoring.", id, Src);
}
return;
}
if (existingMetadata.ContainsKey(Constants.RavenEntityName))
{
newMetadata[Constants.RavenEntityName] = existingMetadata[Constants.RavenEntityName];
}
RavenJObject currentReplicationEntry = null;
if (newMetadata.ContainsKey(Constants.RavenReplicationVersion) &&
newMetadata.ContainsKey(Constants.RavenReplicationSource))
{
currentReplicationEntry = new RavenJObject
{
{ Constants.RavenReplicationVersion, newMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, newMetadata[Constants.RavenReplicationSource] }
};
}
var existingHistory = ReplicationData.GetOrCreateHistory(existingMetadata);
if (currentReplicationEntry != null &&
existingHistory.Any(x => RavenJTokenEqualityComparer.Default.Equals(
((RavenJObject)x)[Constants.RavenReplicationSource], currentReplicationEntry[Constants.RavenReplicationSource]) &&
((RavenJObject)x)[Constants.RavenReplicationVersion].Value <long>() >= currentReplicationEntry[Constants.RavenReplicationVersion].Value <long>()))
{
if (log.IsDebugEnabled)
{
log.Debug("Replicated delete for {0} already exist in item history, ignoring", id);
}
return;
}
if (existingMetadata.Value <bool>(Constants.RavenDeleteMarker)) //deleted locally as well
{
if (log.IsDebugEnabled)
{
log.Debug("Replicating deleted item {0} from {1} that was deleted locally. Merging histories.", id, Src);
}
var newHistory = ReplicationData.GetOrCreateHistory(newMetadata);
if (currentReplicationEntry != null)
{
newHistory.Add(currentReplicationEntry);
}
//Merge histories
ReplicationData.SetHistory(newMetadata, Historian.MergeReplicationHistories(newHistory, existingHistory, id));
newMetadata[Constants.RavenReplicationMergedHistory] = true;
MarkAsDeleted(id, newMetadata);
return;
}
if (Historian.IsDirectChildOfCurrent(newMetadata, existingMetadata)) // not modified
{
if (log.IsDebugEnabled)
{
log.Debug("Delete of existing item {0} was replicated successfully from {1}", id, Src);
}
DeleteItem(id, existingEtag);
MarkAsDeleted(id, newMetadata);
return;
}
CreatedConflict createdConflict;
if (existingMetadata.Value <bool>(Constants.RavenReplicationConflict)) // locally conflicted
{
if (log.IsDebugEnabled)
{
log.Debug("Replicating deleted item {0} from {1} that is already conflicted, adding to conflicts.", id, Src);
}
var savedConflictedItemId = SaveConflictedItem(id, newMetadata, incoming, existingEtag);
createdConflict = AppendToCurrentItemConflicts(id, savedConflictedItemId, existingMetadata, existingItem);
}
else
{
RavenJObject resolvedMetadataToSave;
TExternal resolvedItemToSave;
if (TryResolveConflict(id, newMetadata, incoming, existingItem, out resolvedMetadataToSave, out resolvedItemToSave))
{
if (resolvedMetadataToSave.ContainsKey("Raven-Delete-Marker") &&
resolvedMetadataToSave.Value <bool>("Raven-Delete-Marker"))
{
// the deleted document "wins"
if (newMetadata.ContainsKey(Constants.RavenEntityName))
{
resolvedMetadataToSave[Constants.RavenEntityName] = newMetadata[Constants.RavenEntityName];
}
DeleteItem(id, null);
MarkAsDeleted(id, resolvedMetadataToSave);
}
else
{
var etag = deleted == false ? existingEtag : null;
AddWithoutConflict(id, etag, resolvedMetadataToSave, resolvedItemToSave);
}
return;
}
var newConflictId = SaveConflictedItem(id, newMetadata, incoming, existingEtag);
if (log.IsDebugEnabled)
{
log.Debug("Existing item {0} is in conflict with replicated delete from {1}, marking item as conflicted", id, Src);
}
// we have a new conflict move the existing doc to a conflict and create a conflict document
var existingDocumentConflictId = id + "/conflicts/" + GetReplicationIdentifierForCurrentDatabase();
createdConflict = CreateConflict(id, newConflictId, existingDocumentConflictId, existingItem, existingMetadata);
}
Database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
Database.Notifications.RaiseNotifications(new ReplicationConflictNotification()
{
Id = id,
Etag = createdConflict.Etag,
Conflicts = createdConflict.ConflictedIds,
ItemType = ReplicationConflictTypes.DocumentReplicationConflict,
OperationType = ReplicationOperationTypes.Delete
}));
}
public override void OnPut(string key, RavenJObject jsonReplicationDocument, RavenJObject metadata, TransactionInformation transactionInformation)
{
if (key.StartsWith("Raven/", StringComparison.OrdinalIgnoreCase) && // we don't deal with system documents
key.StartsWith("Raven/Hilo/", StringComparison.OrdinalIgnoreCase) == false) // except for hilos
{
return;
}
using (Database.DisableAllTriggersForCurrentThread())
{
var documentMetadata = GetDocumentMetadata(key);
if (documentMetadata == null)
{
var history = new RavenJArray()
{
new RavenJObject
{
{ Constants.RavenReplicationVersion, metadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, metadata[Constants.RavenReplicationSource] }
}
};
}
else
{
var history = new RavenJArray(ReplicationData.GetOrCreateHistory(documentMetadata));
if (documentMetadata.ContainsKey(Constants.RavenReplicationMergedHistory) == false)
{
if (documentMetadata.ContainsKey(Constants.RavenReplicationVersion) &&
documentMetadata.ContainsKey(Constants.RavenReplicationSource))
{
history.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, documentMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, documentMetadata[Constants.RavenReplicationSource] }
});
}
else
{
history.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, 0 },
{ Constants.RavenReplicationSource, RavenJToken.FromObject(Database.TransactionalStorage.Id) }
});
}
var sources = new HashSet <RavenJToken>(RavenJTokenEqualityComparer.Default);
int pos = history.Length - 1;
for (; pos >= 0; pos--)
{
var source = ((RavenJObject)history[pos])[Constants.RavenReplicationSource];
if (sources.Contains(source))
{
history.RemoveAt(pos);
continue;
}
sources.Add(source);
}
metadata[Constants.RavenReplicationMergedHistory] = true;
metadata[Constants.RavenReplicationHistory] = history;
}
//If we have the flag we must have Constants.RavenReplicationVersion and Constants.RavenReplicationSource too
//Here we assume that the replication history is in the form of a "sorted dictionary" so we just need to remove
//the entry with the current source id and insert the new version at the end of the history.
else
{
int i = history.Length - 1;
for (; i >= 0; i--)
{
var currentEntry = history[i];
if (RavenJTokenEqualityComparer.Default.Equals(((RavenJObject)currentEntry)
[Constants.RavenReplicationSource], documentMetadata[Constants.RavenReplicationSource]))
{
break;
}
}
if (i != -1)
{
history.RemoveAt(i);
}
history.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, documentMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, documentMetadata[Constants.RavenReplicationSource] }
});
metadata[Constants.RavenReplicationHistory] = history;
}
}
metadata[Constants.RavenReplicationVersion] = RavenJToken.FromObject(ReplicationHiLo.NextId(Database));
metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(Database.TransactionalStorage.Id);
}
}
private void ReplicateDelete(string id, RavenJObject metadata, TExternal incoming)
{
TInternal existingItem;
Etag existingEtag;
bool deleted;
var existingMetadata = TryGetExisting(id, out existingItem, out existingEtag, out deleted);
if (existingMetadata == null)
{
log.Debug("Replicating deleted item {0} from {1} that does not exist, ignoring", id, Src);
return;
}
if (existingMetadata.Value <bool>(Constants.RavenDeleteMarker)) //deleted locally as well
{
log.Debug("Replicating deleted item {0} from {1} that was deleted locally. Merging histories", id, Src);
var existingHistory = new RavenJArray(ReplicationData.GetHistory(existingMetadata));
var newHistory = new RavenJArray(ReplicationData.GetHistory(metadata));
foreach (var item in newHistory)
{
existingHistory.Add(item);
}
if (metadata.ContainsKey(Constants.RavenReplicationVersion) &&
metadata.ContainsKey(Constants.RavenReplicationSource))
{
existingHistory.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, metadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, metadata[Constants.RavenReplicationSource] }
});
}
while (existingHistory.Length > Constants.ChangeHistoryLength)
{
existingHistory.RemoveAt(0);
}
MarkAsDeleted(id, metadata);
return;
}
if (Historian.IsDirectChildOfCurrent(metadata, existingMetadata)) // not modified
{
log.Debug("Delete of existing item {0} was replicated successfully from {1}", id, Src);
DeleteItem(id, existingEtag);
MarkAsDeleted(id, metadata);
return;
}
CreatedConflict createdConflict;
if (existingMetadata.Value <bool>(Constants.RavenReplicationConflict)) // locally conflicted
{
log.Debug("Replicating deleted item {0} from {1} that is already conflicted, adding to conflicts.", id, Src);
var savedConflictedItemId = SaveConflictedItem(id, metadata, incoming, existingEtag);
createdConflict = AppendToCurrentItemConflicts(id, savedConflictedItemId, existingMetadata, existingItem);
}
else
{
RavenJObject resolvedMetadataToSave;
TExternal resolvedItemToSave;
if (TryResolveConflict(id, metadata, incoming, existingItem, out resolvedMetadataToSave, out resolvedItemToSave))
{
AddWithoutConflict(id, existingEtag, resolvedMetadataToSave, resolvedItemToSave);
return;
}
var newConflictId = SaveConflictedItem(id, metadata, incoming, existingEtag);
log.Debug("Existing item {0} is in conflict with replicated delete from {1}, marking item as conflicted", id, Src);
// we have a new conflict move the existing doc to a conflict and create a conflict document
var existingDocumentConflictId = id + "/conflicts/" + GetReplicationIdentifierForCurrentDatabase();
createdConflict = CreateConflict(id, newConflictId, existingDocumentConflictId, existingItem, existingMetadata);
}
Database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
Database.Notifications.RaiseNotifications(new ReplicationConflictNotification()
{
Id = id,
Etag = createdConflict.Etag,
Conflicts = createdConflict.ConflictedIds,
ItemType = ReplicationConflictTypes.DocumentReplicationConflict,
OperationType = ReplicationOperationTypes.Delete
}));
}
public override void OnPut(string key, RavenJObject jsonReplicationDocument, RavenJObject metadata, TransactionInformation transactionInformation)
{
using (Database.DisableAllTriggersForCurrentThread())
{
if (metadata.Remove(Constants.RavenReplicationConflictSkipResolution))
{
if (key.IndexOf("/conflicts/", StringComparison.OrdinalIgnoreCase) == -1)
{
metadata["@Http-Status-Code"] = 409;
metadata["@Http-Status-Description"] = "Conflict";
}
return;
}
metadata.Remove(Constants.RavenReplicationConflict);// you can't put conflicts
metadata.Remove(Constants.RavenReplicationConflictDocument);
var oldVersion = Database.Documents.Get(key, transactionInformation);
if (oldVersion == null)
{
return;
}
if (oldVersion.Metadata[Constants.RavenReplicationConflict] == null)
{
return;
}
var history = new RavenJArray();
metadata[Constants.RavenReplicationHistory] = history;
// this is a conflict document, holding document keys in the
// values of the properties
var conflicts = oldVersion.DataAsJson.Value <RavenJArray>("Conflicts");
if (conflicts == null)
{
return;
}
Dictionary <string, RavenJObject> conflictHistoryAsDictionary = new Dictionary <string, RavenJObject>();
foreach (var prop in conflicts)
{
RavenJObject deletedMetadata;
Database.Documents.Delete(prop.Value <string>(), null, transactionInformation, out deletedMetadata);
if (deletedMetadata != null)
{
var conflictHistory = new RavenJArray(ReplicationData.GetHistory(deletedMetadata));
conflictHistory.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, deletedMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, deletedMetadata[Constants.RavenReplicationSource] }
});
Historian.MergeSingleHistory(conflictHistory, conflictHistoryAsDictionary);
}
}
metadata[Constants.RavenReplicationHistory] = new RavenJArray(conflictHistoryAsDictionary.Values);
metadata[Constants.RavenReplicationMergedHistory] = true;
}
}
public abstract void OnReplicate(Controllers.BaseControllers controllers, GameObject ownerEnt, ReplicationData replicationData);
public bool TryResolveConflict(string id, RavenJObject metadata, RavenJObject document, JsonDocument existingDoc,
Func <string, JsonDocument> getDocument, out RavenJObject metadataToSave,
out RavenJObject documentToSave)
{
var success = TryResolve(id, metadata, document, existingDoc, getDocument, out metadataToSave, out documentToSave);
if (success == false)
{
return(false);
}
var history = ReplicationData.GetHistory(metadata);
var existingHistory = ReplicationData.GetHistory(existingDoc.Metadata);
ReplicationData.SetHistory(metadataToSave, Historian.MergeReplicationHistories(history, existingHistory));
metadataToSave[Constants.RavenReplicationMergedHistory] = true;
// here we make sure that we keep a deleted document deleted, rather than "reviving" it.
var ravenDeleteMarker = existingDoc.Metadata.Value <string>("Raven-Delete-Marker");
bool markerValue;
if (ravenDeleteMarker != null && bool.TryParse(ravenDeleteMarker, out markerValue) && markerValue)
{
existingDoc.Metadata["Raven-Remove-Document-Marker"] = true;
}
var docToSave = documentToSave;
var metaToSave = metadataToSave;
if (log.IsDebugEnabled)
{
log.Debug(() =>
{
var builder = new StringBuilder();
builder.AppendLine(string.Format("Conflict on document with key '{0}' resolved by '{1}'.", id, GetType().Name));
builder.AppendLine(string.Format("Existing document:"));
if (existingDoc != null && existingDoc.DataAsJson != null)
{
builder.AppendLine(existingDoc.DataAsJson.ToString());
}
builder.AppendLine(string.Format("Existing metadata:"));
if (existingDoc != null && existingDoc.Metadata != null)
{
builder.AppendLine(existingDoc.Metadata.ToString());
}
builder.AppendLine(string.Format("Incoming document:"));
if (document != null)
{
builder.AppendLine(document.ToString());
}
builder.AppendLine(string.Format("Incoming metadata:"));
if (metadata != null)
{
builder.AppendLine(metadata.ToString());
}
builder.AppendLine(string.Format("Output document:"));
if (docToSave != null)
{
builder.AppendLine(docToSave.ToString());
}
builder.AppendLine(string.Format("Output metadata:"));
if (metaToSave != null)
{
builder.AppendLine(metaToSave.ToString());
}
return(builder.ToString());
});
}
return(true);
}
public IActionResult ImportDatabase([FromBody] ReplicationData replicationData)
{
_replicationDataAccessor.SetDatabase(replicationData);
return(Ok());
}
public void SetDatabase(ReplicationData replicationData)
{
if (_dbContext.AccountInfo.AsNoTracking().Count() != 0)
{
throw new ApplicationException("Database is not empty");
}
var exPresentAccountTanks = new List <AccountTankStatistics>();
replicationData.AccountInfoStatistics.ForEach(s => s.AccountInfoStatisticsId = 0);
replicationData.AccountClanHistory.ForEach(h => h.AccountClanHistoryId = 0);
replicationData.AccountClanInfo.ForEach(c => c.AccountClanInfoId = 0);
replicationData.AccountInfoAchievements.ForEach(c => c.AccountInfoAchievementId = 0);
replicationData.AccountInfoTankAchievements.ForEach(c => c.AccountInfoAchievementId = 0);
replicationData.Frags.ForEach(f => f.FragListItemId = 0);
replicationData.PresentAccountTanks.ForEach(t =>
{
t.PresentAccountTankId = 0;
var stat = replicationData.AccountTanksStatistics.First(s => s.AccountTankStatisticId == t.AccountTankStatisticId);
exPresentAccountTanks.Add(new AccountTankStatistics
{
AccountTankStatisticId = stat.AccountTankStatisticId,
AccountId = stat.AccountId,
TankId = stat.TankId,
BattleLifeTimeInSeconds = stat.BattleLifeTimeInSeconds
});
});
replicationData.AccountTanksStatistics.ForEach(s => s.AccountTankStatisticId = 0);
try
{
_dbContext.Database.BeginTransaction();
_dbContext.AccountInfo.AddRange(replicationData.AccountInfo);
_dbContext.AccountInfoStatistics.AddRange(replicationData.AccountInfoStatistics);
_dbContext.AccountClanHistory.AddRange(replicationData.AccountClanHistory);
_dbContext.AccountClanInfo.AddRange(replicationData.AccountClanInfo);
_dbContext.AccountInfoAchievement.AddRange(replicationData.AccountInfoAchievements);
_dbContext.AccountInfoTankAchievement.AddRange(replicationData.AccountInfoTankAchievements);
_dbContext.Frags.AddRange(replicationData.Frags);
_dbContext.AccountTankStatistics.AddRange(replicationData.AccountTanksStatistics);
_dbContext.SaveChanges();
foreach (var presentTank in replicationData.PresentAccountTanks)
{
var exAccountTankStat = exPresentAccountTanks
.First(t => t.AccountTankStatisticId == presentTank.AccountTankStatisticId);
presentTank.AccountTankStatisticId = _dbContext.AccountTankStatistics
.Where(t => t.AccountId == exAccountTankStat.AccountId && t.TankId == exAccountTankStat.TankId && t.BattleLifeTimeInSeconds == exAccountTankStat.BattleLifeTimeInSeconds)
.Select(t => t.AccountTankStatisticId)
.First();
_dbContext.PresentAccountTanks.Add(presentTank);
}
_dbContext.SaveChanges();
_dbContext.Database.CommitTransaction();
}
catch (Exception e)
{
_logger.LogError(e, "Cannot update database");
_dbContext.Database.RollbackTransaction();
}
}
public override void OnPut(string key, RavenJObject jsonReplicationDocument, RavenJObject metadata)
{
using (Database.DisableAllTriggersForCurrentThread())
{
if (metadata.Remove(Constants.RavenReplicationConflictSkipResolution))
{
if (key.IndexOf("/conflicts/", StringComparison.OrdinalIgnoreCase) == -1)
{
metadata["@Http-Status-Code"] = 409;
metadata["@Http-Status-Description"] = "Conflict";
}
return;
}
metadata.Remove(Constants.RavenReplicationConflict);// you can't put conflicts
var oldVersion = Database.Documents.Get(key);
if (oldVersion == null)
{
return;
}
if (oldVersion.Metadata[Constants.RavenReplicationConflict] == null)
{
return;
}
var history = new RavenJArray();
metadata[Constants.RavenReplicationHistory] = history;
// this is a conflict document, holding document keys in the
// values of the properties
var conflicts = oldVersion.DataAsJson.Value <RavenJArray>("Conflicts");
if (conflicts == null)
{
return;
}
var list = new List <RavenJArray>
{
new RavenJArray(ReplicationData.GetHistory(metadata)) // first item to interleave
};
foreach (var prop in conflicts)
{
RavenJObject deletedMetadata;
Database.Documents.Delete(prop.Value <string>(), null, out deletedMetadata);
if (deletedMetadata != null)
{
var conflictHistory = new RavenJArray(ReplicationData.GetHistory(deletedMetadata));
conflictHistory.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, deletedMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, deletedMetadata[Constants.RavenReplicationSource] }
});
list.Add(conflictHistory);
}
}
int index = 0;
bool added = true;
while (added) // interleave the history from all conflicts
{
added = false;
foreach (var deletedMetadata in list)
{
// add the conflict history to the mix, so we make sure that we mark that we resolved the conflict
if (index < deletedMetadata.Length)
{
history.Add(deletedMetadata[index]);
added = true;
}
}
index++;
}
while (history.Length > Constants.ChangeHistoryLength)
{
history.RemoveAt(0);
}
}
}
public override void OnPut(string key, RavenJObject document, RavenJObject metadata, TransactionInformation transactionInformation)
{
using (Database.DisableAllTriggersForCurrentThread())
{
metadata.Remove(Constants.RavenReplicationConflict); // you can't put conflicts
var oldVersion = Database.Get(key, transactionInformation);
if (oldVersion == null)
{
return;
}
if (oldVersion.Metadata[Constants.RavenReplicationConflict] == null)
{
return;
}
var history = new RavenJArray();
metadata[Constants.RavenReplicationHistory] = history;
var ravenJTokenEqualityComparer = new RavenJTokenEqualityComparer();
// this is a conflict document, holding document keys in the
// values of the properties
var conflicts = oldVersion.DataAsJson.Value <RavenJArray>("Conflicts");
if (conflicts == null)
{
return;
}
var list = new List <RavenJArray>
{
new RavenJArray(ReplicationData.GetHistory(metadata)) // first item to interleave
};
foreach (var prop in conflicts)
{
RavenJObject deletedMetadata;
Database.Delete(prop.Value <string>(), null, transactionInformation, out deletedMetadata);
if (deletedMetadata != null)
{
var conflictHistory = new RavenJArray(ReplicationData.GetHistory(deletedMetadata));
conflictHistory.Add(new RavenJObject
{
{ Constants.RavenReplicationVersion, deletedMetadata[Constants.RavenReplicationVersion] },
{ Constants.RavenReplicationSource, deletedMetadata[Constants.RavenReplicationSource] }
});
list.Add(conflictHistory);
}
}
int index = 0;
bool added = true;
while (added) // interleave the history from all conflicts
{
added = false;
foreach (var deletedMetadata in list)
{
// add the conflict history to the mix, so we make sure that we mark that we resolved the conflict
if (index < deletedMetadata.Length)
{
history.Add(deletedMetadata[index]);
added = true;
}
}
index++;
}
while (history.Length > Constants.ChangeHistoryLength)
{
history.RemoveAt(0);
}
}
}