IEnumerator EndOfReplica(Replica replica){
yield return new WaitForSeconds (REPLICA_DURATION);
Destroy (bulle);
if (!stop)
replica.Finished ();
else
stop = false;
}
private ReplicationMasterFile(ReplicationMasterStorageImpl storage, IFile file, string localhost, int port, string[] hosts, bool ack, String pageTimestampFilePath)
{
this.storage = storage;
this.file = file;
this.ack = ack;
this.localhost = localhost;
this.port = port;
mutex = new object();
replicas = new Replica[hosts.Length];
rcBuf = new byte[1];
nHosts = 0;
if (pageTimestampFilePath != null) {
FileParameters fileParameters = storage != null ? storage.fileParameters : new FileParameters(false, false, false, 1024*1024);
pageTimestampFile = new OSFile(pageTimestampFilePath, fileParameters);
long fileLength = pageTimestampFile.Length;
if (fileLength == 0) {
pageTimestamps = new int[InitPageTimestampsLength];
} else {
pageTimestamps = new int[(int)(fileLength/4)];
byte[] page = new byte[Page.pageSize];
int i = 0;
for (long pos = 0; pos < fileLength; pos += Page.pageSize) {
int rc = pageTimestampFile.Read(pos, page);
for (int offs = 0; offs < rc; offs += 4, i++) {
pageTimestamps[i] = Bytes.unpack4(page, offs);
if (pageTimestamps[i] > timestamp) {
timestamp = pageTimestamps[i];
}
}
}
if (i != pageTimestamps.Length) {
throw new StorageError(StorageError.ErrorCode.FILE_ACCESS_ERROR);
}
}
dirtyPageTimestampMap = new int[(((pageTimestamps.Length*4 + Page.pageSize - 1) >> Page.pageSizeLog) + 31) >> 5];
txBuf = new byte[12 + Page.pageSize];
} else {
txBuf = new byte[8 + Page.pageSize];
}
for (int i = 0; i < hosts.Length; i++)
{
replicas[i] = new Replica();
replicas[i].host = hosts[i];
Connect(i);
}
if (port >= 0)
{
storage.SetProperty("perst.alternative.btree", true); // prevent direct modification of pages
listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(localhost != null && localhost != "localhost" ? IPAddress.Parse(localhost) : IPAddress.Any, port));
listenSocket.Listen(ListenQueueSize);
listening = true;
listenThread = new Thread(new ThreadStart(run));
listenThread.Start();
}
watchdogThread = new Thread(new ThreadStart(watchdog));
watchdogThread.Start();
}
public static List <BatchNode> GenerateList
(
Cluster cluster,
BatchPolicy policy,
List <BatchRead> records,
uint sequenceAP,
uint sequenceSC,
BatchNode batchSeed
)
{
Node[] nodes = cluster.Nodes;
if (nodes.Length == 0)
{
throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Command failed because cluster is empty.");
}
// Create initial key capacity for each node as average + 25%.
int keysPerNode = batchSeed.offsetsSize / nodes.Length;
keysPerNode += (int)((uint)keysPerNode >> 2);
// The minimum key capacity is 10.
if (keysPerNode < 10)
{
keysPerNode = 10;
}
Replica replica = policy.replica;
Replica replicaSC = Partition.GetReplicaSC(policy);
// Split keys by server node.
List <BatchNode> batchNodes = new List <BatchNode>(nodes.Length);
for (int i = 0; i < batchSeed.offsetsSize; i++)
{
int offset = batchSeed.offsets[i];
Node node = Partition.GetNodeBatchRead(cluster, records[offset].key, replica, replicaSC, sequenceAP, sequenceSC);
BatchNode batchNode = FindBatchNode(batchNodes, node);
if (batchNode == null)
{
batchNodes.Add(new BatchNode(node, keysPerNode, offset));
}
else
{
batchNode.AddKey(offset);
}
}
return(batchNodes);
}
public void FulfillSyncRequest_ValidRequest_SyncResultBuildCalled()
{
var syncResult = Mocking.MockAndBind <ISyncResult <TestItem, Guid> >(_container);
var replica = new Replica("test");
var syncRequest = Mock.Create <ISyncRequest <Guid> >();
var target = new ReceivingSynchronizer <TestItem, Guid>(_container);
var result = target.FulfillSyncRequest(syncRequest);
Mock.Assert(() => syncResult.Build(syncRequest), Occurs.Once());
}
public void ReplicarComentario(int id, string replicar)
{
Replica replica = new Replica();
replica.IdCalificacion = Convert.ToInt16(id);
replica.Comentario = replicar;
context.Replica.AddObject(replica);
Calificacion calificacion = context.Calificacion.Where(e => e.Id == id).FirstOrDefault();
calificacion.FlagReplicado = 1; //comentario de la calificacion fue replicado
context.SaveChanges();
}
protected void PresentaEventoSelezionato(string codice)
{
Replica oReplica = new Replica();
ReplicaDAO oReplicaDAO = new ReplicaDAO();
oReplica = oReplicaDAO.GetReplicaById(codice);
TableCell tc1 = new TableCell();
TableCell tc2 = new TableCell();
TableCell tc3 = new TableCell();
TableCell tc4 = new TableCell();
TableCell tc5 = new TableCell();
TableCell tc6 = new TableCell();
TableCell tc7 = new TableCell();
TableCell tc8 = new TableCell();
TableCell tc9 = new TableCell();
//Button bt1 = new Button();
//bt1.Text = "PRENOTA";
//bt1.CssClass = "btn btn-primary";
//bt1.ID = oReplica.codReplica;
//bt1.Click += new EventHandler(prenotaReplica);
tc1.Text = oReplica.codReplica;
tc2.Text = oReplica.codEvento;
tc3.Text = (oReplica.dataEOra).ToString();
tc4.Text = oReplica.codLocale;
tc5.Text = oReplica.nomeEvento;
tc6.Text = oReplica.nomeLocale;
tc7.Text = oReplica.luogo;
tc8.Text = (oReplica.posti).ToString();
//tc9.Controls.Add(bt1);
TableRow tr = new TableRow();
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
tr.Cells.Add(tc3);
tr.Cells.Add(tc4);
tr.Cells.Add(tc5);
tr.Cells.Add(tc6);
tr.Cells.Add(tc7);
tr.Cells.Add(tc8);
//tr.Cells.Add(tc9);
TBLEvento.Rows.Add(tr);
}
/// <summary>
/// Copy constructor.
/// </summary>
public Policy(Policy other)
{
this.priority = other.priority;
this.readModeAP = other.readModeAP;
this.readModeSC = other.readModeSC;
this.replica = other.replica;
this.predExp = other.predExp;
this.socketTimeout = other.socketTimeout;
this.totalTimeout = other.totalTimeout;
this.maxRetries = other.maxRetries;
this.sleepBetweenRetries = other.sleepBetweenRetries;
this.sendKey = other.sendKey;
this.failOnFilteredOut = other.failOnFilteredOut;
}
public static void Handle(
SecretShareMessage message,
Replica replica,
string replicaSecretShare,
Dictionary<int, uint> childSecretHashes,
Dictionary<int, CancellationTokenSource> secretShareMessageTokenSources,
ConcurrentDictionary<int, string> verifiedChildrenSecretShares)
{
var childReplicaId = message.ReplicaId;
var childReplicaSecretShare = message.ReplicaSecretShares[message.ReplicaId];
secretShareMessageTokenSources[childReplicaId].Cancel();
secretShareMessageTokenSources.Remove(childReplicaId);
if (Crypto.GetHash(childReplicaSecretShare) != childSecretHashes[childReplicaId])
{
replica.ParentReplica.SendMessage(
new SuspectMessage
{
ReplicaId = childReplicaId
});
}
foreach (var childSecretShare in message.ReplicaSecretShares)
{
if (verifiedChildrenSecretShares.TryAdd(childSecretShare.Key, childSecretShare.Value) == false)
{
throw new InvalidOperationException($"The child secret share for replica #{childSecretShare.Key} has already been delivered.");
}
}
if (replica.ChildReplicas.All(chr => verifiedChildrenSecretShares.ContainsKey(chr.Id)) == false)
{
return;
}
verifiedChildrenSecretShares.TryAdd(replica.Id, replicaSecretShare);
// we send a message with a secret share to the parent replica
Network.EmulateLatency();
replica.ParentReplica.SendMessage(
new SecretShareMessage
{
ReplicaId = replica.Id,
ReplicaSecretShares = verifiedChildrenSecretShares.ToDictionary(kv => kv.Key, kv => kv.Value)
});
Log(replica, "Send a secret share to the parent replica (ParentReplicaId: {0})", replica.ParentReplica.Id);
}
public void Kill(DamageInfo reason)
{
if (!isServer)
{
return;
}
deathReason = reason;
try {
OnDeath?.Invoke(reason);
} finally {
Replica.Destroy();
}
}
void RpcBuild(Replica buildingReplica, BuildingPartType partType, BuildingSlotType buildingSlotType, Vector3 slotPosition)
{
var building = buildingReplica.GetComponent <Building>();
float distance = 0;
var slot = building.GetClosestSlot(slotPosition, buildingSlotType, true, out distance);
//#TODO check distance
Assert.IsNotNull(slot);
building.AddPart(partType, slot);
building.Rebuild();
}
public Node GetReadNode(Partition partition, Replica replica)
{
switch (replica)
{
case Replica.MASTER:
return(GetMasterNode(partition));
case Replica.MASTER_PROLES:
return(GetMasterProlesNode(partition));
default:
case Replica.RANDOM:
return(GetRandomNode());
}
}
public static List <BatchNode> GenerateList
(
Cluster cluster,
BatchPolicy policy,
Key[] keys,
uint sequenceAP,
uint sequenceSC,
BatchNode batchSeed
)
{
Node[] nodes = cluster.ValidateNodes();
// Create initial key capacity for each node as average + 25%.
int keysPerNode = batchSeed.offsetsSize / nodes.Length;
keysPerNode += (int)((uint)keysPerNode >> 2);
// The minimum key capacity is 10.
if (keysPerNode < 10)
{
keysPerNode = 10;
}
Replica replica = policy.replica;
Replica replicaSC = Partition.GetReplicaSC(policy);
// Split keys by server node.
List <BatchNode> batchNodes = new List <BatchNode>(nodes.Length);
for (int i = 0; i < batchSeed.offsetsSize; i++)
{
int offset = batchSeed.offsets[i];
Node node = Partition.GetNodeBatchRead(cluster, keys[offset], replica, replicaSC, sequenceAP, sequenceSC);
BatchNode batchNode = FindBatchNode(batchNodes, node);
if (batchNode == null)
{
batchNodes.Add(new BatchNode(node, keysPerNode, offset));
}
else
{
batchNode.AddKey(offset);
}
}
return(batchNodes);
}
static void RunAfterMakeLabel(
List <string> filteredRepos,
List <string> dstServers,
List <RepoMapping> mappings,
string labelName,
string repoName,
string serverName,
ErrorEmailSender emailSender)
{
Logger.LogInfo("Running as after-makelabel trigger...");
Branch branchToReplicate = null;
if (!FindBranchForLabel(
labelName, repoName, serverName, out branchToReplicate))
{
return;
}
List <Replica> pendingReplicas =
Replica.BuildPendingReplicas(
branchToReplicate.BranchName,
branchToReplicate.RepositoryName,
branchToReplicate.ServerName,
filteredRepos,
dstServers,
mappings);
Logger.LogInfo(
$"Found {pendingReplicas.Count} destinations to replicate to.");
List <Replica> failedReplicas = new List <Replica>();
foreach (Replica pendingReplica in pendingReplicas)
{
if (!Replicate(pendingReplica))
{
failedReplicas.Add(pendingReplica);
}
}
NotifyFailedReplicas(
"after-makelabel",
failedReplicas,
emailSender);
}
public Node GetReadNode(Partition partition, Replica replica)
{
// This method should only be called by batch.
switch (replica)
{
default:
case Replica.SEQUENCE: // Use Command.GetReadNode() to really use sequence mode.
case Replica.MASTER:
return(GetMasterNode(partition));
case Replica.MASTER_PROLES:
return(GetMasterProlesNode(partition));
case Replica.RANDOM:
return(GetRandomNode());
}
}
public void StartReplica(Replica replica){
GameObject o = new GameObject ("bulle") as GameObject;
o.transform.SetParent (transform);
o.transform.position = transform.position + Vector3.up * 50;
SpriteRenderer sr = o.AddComponent<SpriteRenderer> ();
sr.sprite = PreparationManager.Instance.bulleSprite;
sr.color = new Color (1, 1, 1, 0.9f);
bulle = o;
GameObject phrase = GameObject.Instantiate (PreparationManager.Instance.PhrasePrefab) as GameObject;
phrase.transform.SetParent (o.transform);
phrase.transform.localPosition = PreparationManager.Instance.PhrasePrefab.transform.localPosition;
phrase.transform.localScale = Vector3.one;
phrase.GetComponentInChildren<Text> ().text = replica.text;
//Debug.Log (name + " is saying : " + replica.text);
StartCoroutine (EndOfReplica (replica));
}
private static void Server()
{
var port = 55001;
Server server = new Server
{
Services = { Replica.BindService(new KafkaSyncImpl()) },
Ports = { new ServerPort("0.0.0.0", port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("Greeter server listening on port " + port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
public void PlayReplica(CharacterType character, string key)
{
portraitUncleVo.SetActive(false);
portraitVita.SetActive(false);
portraitDitto.SetActive(false);
MonologData data = null;
switch (character)
{
case CharacterType.Ditto:
data = dittoData;
portraitDitto.SetActive(true);
break;
case CharacterType.Vita:
data = vitaData;
portraitVita.SetActive(true);
break;
case CharacterType.UncleVo:
data = uncleVoData;
portraitUncleVo.SetActive(true);
break;
}
Replica replica = null;
foreach (var r in data.replics)
{
if (r.key == key)
{
replica = r;
}
}
if (replica == null)
{
Debug.LogError("Invalid key!");
return;
}
replicaCharachter = character;
SetText(replica.text, character.ToString() + replica.key);
}
public async Task <IActionResult> Post([FromBody] ReplicaCadastroViewModel model)
{
Usuario user = db.Usuarios.SingleOrDefault(u => u.Id == model.AprendizId);
Replica replica = new Replica();
replica.Texto = model.Texto;
replica.TopicoId = model.TopicoId;
replica.DataCriacao = DateTime.Now;
replica.Usuario = user; // await userManager.GetUserAsync(this.User);
System.Console.WriteLine("[" + user.Nome + "]");
db.Replicas.Add(replica);
await db.SaveChangesAsync();
return(Ok());
}
public Node GetReadNode(Cluster cluster, Partition partition, Replica replica)
{
switch (replica)
{
case Replica.MASTER:
return(cluster.GetMasterNode(partition));
case Replica.MASTER_PROLES:
return(cluster.GetMasterProlesNode(partition));
case Replica.SEQUENCE:
return(GetSequenceNode(cluster, partition));
default:
case Replica.RANDOM:
return(cluster.GetRandomNode());
}
}
static void RunAfterCheckin(
List <string> filteredRepos,
List <string> dstServers,
List <RepoMapping> mappings,
string csetSpecs,
ErrorEmailSender emailSender)
{
Logger.LogInfo("Running as after-checkin trigger...");
List <Changeset> csets =
Changeset.ParsePlasticChangesetEnvironVar(csetSpecs);
List <Replica> pendingReplicas = new List <Replica>();
foreach (Changeset cset in csets)
{
pendingReplicas.AddRange(
Replica.BuildPendingReplicas(
cset.BranchName,
cset.RepositoryName,
cset.ServerName,
filteredRepos,
dstServers,
mappings));
}
Logger.LogInfo(
$"Found {pendingReplicas.Count} destinations to replicate to.");
List <Replica> failedReplicas = new List <Replica>();
foreach (Replica pendingReplica in pendingReplicas)
{
if (!Replicate(pendingReplica))
{
failedReplicas.Add(pendingReplica);
}
}
NotifyFailedReplicas(
"after-checkin",
failedReplicas,
emailSender);
}
public static void Handle(
ViewChangeMessage message,
Replica replica,
Replica[] activeReplicas,
ConcurrentDictionary <int, int> viewChangesCount,
byte[] signedByPrimaryReplicaAheadBlocksOrTreeHashAndCounterViewNumber,
string encryptedViewKey
)
{
// execute the requests in O that have not been executed
// extract and store information from T
var activeReplica = activeReplicas.SingleOrDefault(r => r.Id == message.ReplicaId);
if (activeReplica == null)
{
return;
}
byte[] buffer;
if (Crypto.Verify(replica.PublicKey, message.SignedAheadBlocksOrTreeHashAndCounterViewNumber, out buffer) ==
false)
{
return;
}
viewChangesCount.AddOrUpdate(buffer.Sum(v => v), 1, (_, count) => count + 1);
var maxViewChangeCount = viewChangesCount
.OrderByDescending(vchc => vchc.Value)
.FirstOrDefault();
if (maxViewChangeCount.Key == 0 || maxViewChangeCount.Value < activeReplicas.Length - 1)
{
return;
}
replica.Tee.UpdateView(
replica.PrimaryReplica.PublicKey,
signedByPrimaryReplicaAheadBlocksOrTreeHashAndCounterViewNumber,
encryptedViewKey);
}
static bool Replicate(Replica replica)
{
int result;
string stdOut, stdErr;
Logger.LogInfo($"Replicating {replica}");
string cmdLine = string.Format(
"cm replicate --push \"br:{0}@{1}@{2}\" {3}@{4}",
replica.SrcBranch,
replica.SrcRepo,
replica.SrcServer,
replica.DstRepo,
replica.DstServer);
Logger.LogInfo($"Executing: '{cmdLine}'");
result = CmdRunner.CmdRunner.ExecuteCommandWithResult(
cmdLine,
Environment.CurrentDirectory,
out stdOut,
out stdErr,
false);
if (result == 0)
{
Logger.LogInfo("The replication process succeeded.");
return(true);
}
Logger.LogError(
string.Format(
"Replicating a branch failed.{0}" +
"Command line: '{1}'{0}" +
"cm stdout: {2}{0}" +
"cm stderr: {3}{0}",
Environment.NewLine,
cmdLine,
stdOut,
stdErr));
return(false);
}
public Node GetNode(Cluster cluster, Partition partition, Replica replica, bool isRead)
{
// Handle default case first.
if (replica == Replica.SEQUENCE)
{
return(GetSequenceNode(cluster, partition));
}
if (replica == Replica.MASTER || !isRead)
{
return(cluster.GetMasterNode(partition));
}
if (replica == Replica.MASTER_PROLES)
{
return(cluster.GetMasterProlesNode(partition));
}
return(cluster.GetRandomNode());
}
private async Task DistributeToEndpoint(Service service, Replica replica, string endpoint, InflightMessage message, CancellationToken cancelToken)
{
//TODO: security
var failureDetected = false;
var failureReason = Empty;
try
{
var uriBuilder = new UriBuilder(new Uri(endpoint))
{
Path = Format(CultureInfo.InvariantCulture, MessageIngestUrlFormat,
HttpUtility.UrlEncode(message.Type))
};
var resp = await HttpClient.PostAsync(uriBuilder.Uri,
new StringContent(message.Payload, Encoding.UTF8, "application/json"),
cancelToken);
if (!resp.IsSuccessStatusCode && resp.StatusCode != HttpStatusCode.NotFound)
{
failureDetected = true;
failureReason = $"Status Code returned - {resp.StatusCode}";
}
}
catch (Exception e)
{
failureDetected = true;
failureReason = e.Message;
}
finally
{
if (failureDetected)
{
_bb?.Publish(GetEndpointFailureMessage(service, replica, endpoint, failureReason));
}
else
{
_bb?.Publish(GetEndpointSuccessMessage(service, replica, endpoint));
}
}
}
public static List <BatchNode> GenerateList(Cluster cluster, BatchPolicy policy, Key[] keys)
{
Node[] nodes = cluster.Nodes;
if (nodes.Length == 0)
{
throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Command failed because cluster is empty.");
}
// Create initial key capacity for each node as average + 25%.
int keysPerNode = keys.Length / nodes.Length;
keysPerNode += (int)((uint)keysPerNode >> 2);
// The minimum key capacity is 10.
if (keysPerNode < 10)
{
keysPerNode = 10;
}
Replica replica = policy.replica;
Replica replicaSC = Partition.GetReplicaSC(policy);
// Split keys by server node.
List <BatchNode> batchNodes = new List <BatchNode>(nodes.Length);
for (int i = 0; i < keys.Length; i++)
{
Node node = Partition.GetNodeBatchRead(cluster, keys[i], replica, replicaSC, 0, 0);
BatchNode batchNode = FindBatchNode(batchNodes, node);
if (batchNode == null)
{
batchNodes.Add(new BatchNode(node, keysPerNode, i));
}
else
{
batchNode.AddKey(i);
}
}
return(batchNodes);
}
/// <summary>
/// </summary>
/// <param name="replicaObj"></param>
/// <param name="partitionGuid"></param>
public ReplicaEntity(Replica replicaObj, Guid partitionGuid)
{
Assert.IsNotNull(replicaObj, "Replica object can't be null");
this.Id = replicaObj.Id;
this.HealthState = replicaObj.HealthState;
this.ReplicaStatus = replicaObj.ReplicaStatus;
this.LastInBuildDuration = replicaObj.LastInBuildDuration;
this.NodeName = replicaObj.NodeName;
this.ServiceKind = replicaObj.ServiceKind;
this.ReplicaRole = ReplicaRole.Unknown;
this.PartitionId = partitionGuid;
// Check if stateful service and if yes, assign appropriate replica role.
var statefulReplica = replicaObj as StatefulServiceReplica;
if (statefulReplica != null)
{
this.ReplicaRole = statefulReplica.ReplicaRole;
}
}
public void BuildPendingReplicasForMappedRepoTest()
{
string srcBranch = "br:/main/task-001";
string srcRepo = "default";
string srcServer = "JAIR:8087";
List <string> filteredRepos = new List <string>();
List <string> dstServers = new List <string>()
{
"ssl://myserver.mydomain.com:9095",
"calavera.home:7074"
};
List <RepoMapping> repoMappings = new List <RepoMapping>();
repoMappings.Add(new RepoMapping(
srcRepo, "default_myserver", dstServers[0]));
repoMappings.Add(new RepoMapping(
srcRepo, "default_calavera", dstServers[1]));
List <Replica> pendingReplicas =
Replica.BuildPendingReplicas(
srcBranch,
srcRepo,
srcServer,
filteredRepos,
dstServers,
repoMappings);
Assert.AreEqual(2, pendingReplicas.Count);
Replica firstExpectedReplica = new Replica(
srcBranch, srcRepo, srcServer, "default_myserver", dstServers[0]);
Replica secondExpectedReplica = new Replica(
srcBranch, srcRepo, srcServer, "default_calavera", dstServers[1]);
AssertReplicasEqual(firstExpectedReplica, pendingReplicas[0]);
AssertReplicasEqual(secondExpectedReplica, pendingReplicas[1]);
}
void AssertReplicasEqual(Replica left, Replica right)
{
Assert.AreEqual(
left.SrcBranch, right.SrcBranch,
"The SrcBranch property does not match.");
Assert.AreEqual(
left.SrcRepo, right.SrcRepo,
"The SrcRepo property does not match.");
Assert.AreEqual(
left.SrcServer, right.SrcServer,
"The SrcServer property does not match.");
Assert.AreEqual(
left.DstRepo, right.DstRepo,
"The DstRepo property does not match.");
Assert.AreEqual(
left.DstServer, right.DstServer,
"The DstServer property does not match.");
}
public static Node GetNodeBatchRead(Cluster cluster, Key key, Replica replica, Replica replicaSC, uint sequence, uint sequenceSC)
{
// Must copy hashmap reference for copy on write semantics to work.
Dictionary <string, Partitions> map = cluster.partitionMap;
Partitions partitions;
if (!map.TryGetValue(key.ns, out partitions))
{
throw new AerospikeException.InvalidNamespace(key.ns, map.Count);
}
if (partitions.scMode)
{
replica = replicaSC;
sequence = sequenceSC;
}
Partition p = new Partition(partitions, key, replica, false);
p.sequence = sequence;
return(p.GetNodeRead(cluster));
}
static void RunAfterReplicationWrite(
List <string> filteredRepos,
List <string> dstServers,
List <RepoMapping> mappings,
string branchSpec,
ErrorEmailSender emailSender)
{
Logger.LogInfo("Running as after-replicationwrite trigger...");
Branch branchToReplicate =
Branch.ParsePlasticBranchEnvironVar(branchSpec);
List <Replica> pendingReplicas =
Replica.BuildPendingReplicas(
branchToReplicate.BranchName,
branchToReplicate.RepositoryName,
branchToReplicate.ServerName,
filteredRepos,
dstServers,
mappings);
Logger.LogInfo(
$"Found {pendingReplicas.Count} destinations to replicate to.");
List <Replica> failedReplicas = new List <Replica>();
foreach (Replica pendingReplica in pendingReplicas)
{
if (!Replicate(pendingReplica))
{
failedReplicas.Add(pendingReplica);
}
}
NotifyFailedReplicas(
"after-replicationwrite",
failedReplicas,
emailSender);
}
void ApplyToCorrespondingReplica(Replica replica, Action <Replica> func)
{
Action <GameObject> impl = (go) => {
var correspondingReplicas = go.GetComponentsInChildren <Replica>();
foreach (var correspondingReplica in correspondingReplicas)
{
if (correspondingReplica.Id == replica.Id)
{
func(correspondingReplica);
break;
}
}
};
if (replica.isClient)
{
var otherReplica = ServerReplicaManager.Main.GetReplica(replica.Id);
if (otherReplica != null)
{
impl(otherReplica.gameObject);
}
}
if (replica.isServer)
{
foreach (var replicaManager in ClientReplicaManager.All)
{
var otherReplica = replicaManager.GetReplica(replica.Id);
if (otherReplica == null)
{
continue;
}
impl(otherReplica.gameObject);
break;
}
}
}
public static List <BatchNode> GenerateList(Cluster cluster, BatchPolicy policy, List <BatchRead> records)
{
Node[] nodes = cluster.ValidateNodes();
// Create initial key capacity for each node as average + 25%.
int max = records.Count;
int keysPerNode = max / nodes.Length;
keysPerNode += (int)((uint)keysPerNode >> 2);
// The minimum key capacity is 10.
if (keysPerNode < 10)
{
keysPerNode = 10;
}
Replica replica = policy.replica;
Replica replicaSC = Partition.GetReplicaSC(policy);
// Split keys by server node.
List <BatchNode> batchNodes = new List <BatchNode>(nodes.Length);
for (int i = 0; i < max; i++)
{
Node node = Partition.GetNodeBatchRead(cluster, records[i].key, replica, replicaSC, 0, 0);
BatchNode batchNode = FindBatchNode(batchNodes, node);
if (batchNode == null)
{
batchNodes.Add(new BatchNode(node, keysPerNode, i));
}
else
{
batchNode.AddKey(i);
}
}
return(batchNodes);
}
private void CheckReplicas(IDictionary <long, Replica> expectedReplicas, BlockListAsLongs
decodedBlocks)
{
NUnit.Framework.Assert.AreEqual(expectedReplicas.Count, decodedBlocks.GetNumberOfBlocks
());
IDictionary <long, Replica> reportReplicas = new Dictionary <long, Replica>(expectedReplicas
);
foreach (BlockListAsLongs.BlockReportReplica replica in decodedBlocks)
{
NUnit.Framework.Assert.IsNotNull(replica);
Replica expected = Sharpen.Collections.Remove(reportReplicas, replica.GetBlockId(
));
NUnit.Framework.Assert.IsNotNull(expected);
NUnit.Framework.Assert.AreEqual("wrong bytes", expected.GetNumBytes(), replica.GetNumBytes
());
NUnit.Framework.Assert.AreEqual("wrong genstamp", expected.GetGenerationStamp(),
replica.GetGenerationStamp());
NUnit.Framework.Assert.AreEqual("wrong replica state", expected.GetState(), replica
.GetState());
}
NUnit.Framework.Assert.IsTrue(reportReplicas.IsEmpty());
}
private void addConnection(Socket s)
{
lock (mutex)
{
int n = replicas.Length;
Replica[] newReplicas = new Replica[n+1];
Array.Copy(replicas, 0, newReplicas, 0, n);
Replica replica = new Replica();
newReplicas[n] = replica;
replica.host = s.RemoteEndPoint.ToString();
replica.socket = s;
replica.isDynamic = true;
replicas = newReplicas;
nHosts += 1;
SynchronizeThread syncThread = new SynchronizeThread(this, n);
Thread t = new Thread(new ThreadStart(syncThread.run));
replica.syncThread = t;
t.Start();
}
}
/// <summary>
/// Copy constructor.
/// </summary>
public Policy(Policy other)
{
this.priority = other.priority;
this.consistencyLevel = other.consistencyLevel;
this.replica = other.replica;
this.timeout = other.timeout;
this.maxRetries = other.maxRetries;
this.sleepBetweenRetries = other.sleepBetweenRetries;
this.sendKey = other.sendKey;
}
public Node GetReadNode(Partition partition, Replica replica)
{
switch (replica)
{
case Replica.MASTER:
return GetMasterNode(partition);
case Replica.MASTER_PROLES:
return GetMasterProlesNode(partition);
default:
case Replica.RANDOM:
return GetRandomNode();
}
}
