static async Task<SyntaxNode> GetNewRootWithAddedNamespaces(Document document, SyntaxNode relativeToNode,
CancellationToken cancellationToken, ImmutableHashSet<string> namespaceQualifiedStrings)
{
var namespaceWithUsings = relativeToNode
.GetAncestorsOrThis<NamespaceDeclarationSyntax>()
.FirstOrDefault(ns => ns.DescendantNodes().OfType<UsingDirectiveSyntax>().Any());
var root = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxNode newRoot;
var usings = namespaceQualifiedStrings
.Select(ns => UsingDirective(ParseName(ns).WithAdditionalAnnotations(Simplifier.Annotation)));
if (namespaceWithUsings != null)
{
var newNamespaceDeclaration = namespaceWithUsings.WithUsings(namespaceWithUsings.Usings.AddRange(usings));
newRoot = root.ReplaceNode(namespaceWithUsings, newNamespaceDeclaration);
}
else
{
var compilationUnit = (CompilationUnitSyntax)root;
newRoot = compilationUnit.WithUsings(compilationUnit.Usings.AddRange(usings));
}
return newRoot;
}
/// <summary>
/// Update the locally stored replication progress of remote replicas with the sequence numbers given in <paramref name="info"/>.
/// Replication progress that is greater than the corresponding sequence number in <paramref name="info"/> is reset to that
/// </summary>
public Task SynchronizeReplicationProgress(ReplicationEndpointInfo info)
{
ImmutableHashSet <string> logNames = Endpoint.CommonLogNames(info);
var tasks = logNames.Select(name => SynchronizeReplicationProgress(info, name));
return(Task.WhenAll(tasks));
}
private void SetStates(
Block <T> block,
IReadOnlyList <ActionEvaluation <T> > actionEvaluations)
{
HashDigest <SHA256> blockHash = block.Hash;
IAccountStateDelta lastStates = actionEvaluations.Count > 0
? actionEvaluations[actionEvaluations.Count - 1].OutputStates
: null;
ImmutableHashSet <Address> updatedAddresses =
actionEvaluations.Select(
a => a.OutputStates.UpdatedAddresses
).Aggregate(
ImmutableHashSet <Address> .Empty,
(a, b) => a.Union(b)
);
ImmutableDictionary <Address, object> totalDelta =
updatedAddresses.Select(
a => new KeyValuePair <Address, object>(
a,
lastStates?.GetState(a)
)
).ToImmutableDictionary();
Store.SetBlockStates(
blockHash,
new AddressStateMap(totalDelta)
);
var chainId = Id.ToString();
Store.StoreStateReference(chainId, updatedAddresses, block);
Store.IncreaseTxNonce(chainId, block);
}
// Cognitive Complexity 5
public static ContentView GetContentView(string contentId, IReadOnlyCollection <string> requestedUriTypes)
{
ImmutableHashSet <string> subsetUriTypes = AllSupportedUriTypes.Intersect(requestedUriTypes);
if (!subsetUriTypes.Any())
{
throw new Exception("message");
}
return(new ContentView
{
ResultStatus = AllSupportedUriTypes.SetEquals(subsetUriTypes) ? ResultStatusComplete : ResultStatusPartial,
Uris = subsetUriTypes.Select(uriType =>
{
if (IsViewerA(uriType))
{
return $"https://{ViewerA}/{contentId}";
}
else if (IsViewerC(uriType))
{
return $"https://{ViewerC}/{contentId}";
}
else
{
return $"https://{ViewerD}/{contentId}";
}
})
});
}
internal void SetStates(
Block <T> block,
IReadOnlyList <ActionEvaluation> actionEvaluations,
bool buildStateReferences
)
{
HashDigest <SHA256> blockHash = block.Hash;
IAccountStateDelta lastStates = actionEvaluations.Count > 0
? actionEvaluations[actionEvaluations.Count - 1].OutputStates
: null;
ImmutableHashSet <Address> updatedAddresses =
actionEvaluations.Select(
a => a.OutputStates.UpdatedAddresses
).Aggregate(
ImmutableHashSet <Address> .Empty,
(a, b) => a.Union(b)
);
ImmutableDictionary <Address, object> totalDelta =
updatedAddresses.Select(
a => new KeyValuePair <Address, object>(
a,
lastStates?.GetState(a)
)
).ToImmutableDictionary();
Store.SetBlockStates(
blockHash,
new AddressStateMap(totalDelta)
);
if (buildStateReferences)
{
Store.StoreStateReference(Id, updatedAddresses, block.Hash, block.Index);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ClusterClient" /> class.
/// </summary>
/// <param name="settings">The settings used to configure the client.</param>
/// <exception cref="ArgumentException">
/// This exception is thrown when the settings contains no initial contacts.
/// </exception>
public ClusterClient(ClusterClientSettings settings)
{
if (settings.InitialContacts.Count == 0)
{
throw new ArgumentException("Initial contacts for cluster client cannot be empty");
}
_settings = settings;
_failureDetector = new DeadlineFailureDetector(_settings.AcceptableHeartbeatPause, _settings.HeartbeatInterval);
_contactPaths = settings.InitialContacts.ToImmutableHashSet();
_initialContactsSelections = _contactPaths.Select(Context.ActorSelection).ToArray();
_contacts = _initialContactsSelections;
SendGetContacts();
_contactPathsPublished = ImmutableHashSet <ActorPath> .Empty;
_subscribers = ImmutableList <IActorRef> .Empty;
_heartbeatTask = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
settings.HeartbeatInterval,
settings.HeartbeatInterval,
Self,
HeartbeatTick.Instance,
Self);
_refreshContactsCancelable = null;
ScheduleRefreshContactsTick(settings.EstablishingGetContactsInterval);
Self.Tell(RefreshContactsTick.Instance);
_buffer = new Queue <Tuple <object, IActorRef> >();
}
public static List <List <Unacked> > PartitionMessageId(this ImmutableHashSet <Unacked> source)
{
return(source
.Select((x, i) => new { Index = i, Value = x })
.GroupBy(x => x.Value.PartitionIndex)
.Select(x => x.Select(v => v.Value).ToList())
.ToList());
}
private static string GenerateGraphQLTypes(GenerationContext generationContext)
{
var generatableTypeProvider = new GeneratableTypeProvider(generationContext.Visitors);
ImmutableHashSet <IGeneratableType> generatableTypes = generatableTypeProvider.FromSchemaFilePath(generationContext.GraphqlSchemaFilePath);
IEnumerable <string> generatedTypes = generatableTypes.Select(type => type.ToString());
return(string.Join(Environment.NewLine, generatedTypes));
}
public Scan(ImmutableHashSet <Point2d> clay)
{
_map = new Dictionary <Point2d, CellType>(clay.Select(p => KeyValuePair.Create(p, CellType.Clay)))
{
[WaterSpring] = CellType.Spring,
};
var(xRange, yRange) = Point2d.FindSpaceOfPoints(_map.Keys);
_gridDimensions = new Area2d(xRange.Pad(3), yRange);
}
/// <summary>
/// Returns a semi-indented JSON version of this object
/// </summary>
/// <returns></returns>
public static string ToJson <T>(this ImmutableHashSet <T> hashSet, string name) where T : IAltHash
{
var jObj = new StringBuilder();
jObj.AppendLine($"\"{name}\":{{");
jObj.AppendLine(string.Join(",", hashSet.Select(r => $"\"{r.GetAltHashCode}\": {r}")));
jObj.AppendLine("}");
return(jObj.ToString());
}
public void RegisterMetrics(TelemetryClient telemetry)
{
foreach (var sc in _statsCollectors)
{
sc.RegisterMetrics(telemetry);
}
// Metrics have been registered, start the event listeners
_eventListeners = _statsCollectors
.Select(sc => new DotNetEventListener(sc, _errorHandler))
.ToArray();
}
public void RegisterMetrics(IMetrics metrics)
{
// Metrics have been registered, start the event listeners
_eventListeners = _statsCollectors
.Select(sc => new DotNetEventListener(sc, _errorHandler, _enabledDebugging, metrics))
.ToArray();
_processInfoStatsCollector = new ProcessInfoStatsCollector(metrics);
_processInfoStatsCollector.Start();
SetupConstantMetrics(metrics);
}
public void A_remote_round_robin_pool_with_resizer_must_be_locally_instantiated_on_a_remote_node_after_several_resize_rounds()
{
Within(TimeSpan.FromSeconds(5), () =>
{
RunOn(() =>
{
EnterBarrier("start", "broadcast-end", "end");
}, _config.First, _config.Second, _config.Third);
RunOn(() =>
{
EnterBarrier("start");
var actor = Sys.ActorOf(new RoundRobinPool(
nrOfInstances: 1,
resizer: new TestResizer()
).Props(Props.Create <SomeActor>()), "service-hello2");
actor.Should().BeOfType <RoutedActorRef>();
actor.Tell(RouterMessage.GetRoutees);
// initial nrOfInstances 1 + initial resize => 2
ExpectMsg <Routees>().Members.Count().Should().Be(2);
ImmutableHashSet <IActorRef> repliesFrom = ImmutableHashSet.Create <IActorRef>();
for (int i = 3; i <= 9; i++)
{
//each message triggers a resize, incrementing number of routees with 1
actor.Tell("hit");
var routees = actor.AskAndWait <Routees>(new GetRoutees(), GetTimeoutOrDefault(null));
routees.Members.Count().Should().Be(i);
repliesFrom = repliesFrom.Add(ExpectMsg <IActorRef>());
}
EnterBarrier("broadcast-end");
actor.Tell(new Broadcast(PoisonPill.Instance));
EnterBarrier("end");
repliesFrom.Count.Should().Be(7);
var repliesFromAddresses = repliesFrom.Select(x => x.Path.Address).ToImmutableHashSet();
repliesFromAddresses.Should().BeEquivalentTo(new List <Address>
{
Node(_config.First).Address,
Node(_config.Second).Address,
Node(_config.Third).Address
});
Sys.Stop(actor);
}, _config.Fourth);
EnterBarrier("done");
});
}
public static string Stringify(this object o, bool quoteStrings = false, bool nilIsEmpty = false)
{
if (o == null)
{
return(nilIsEmpty ? "" : "nil");
}
if (o.Equals(true))
{
return("true");
}
if (o.Equals(false))
{
return("false");
}
var s = o switch
{
string strng => quoteStrings ? "'" + strng + "'" : strng,
IStringify str => str.Stringify(quoteStrings),
ImmutableDictionary <object, object> arr => "{" + string.Join(' ', arr.Select(item => item.Key.Stringify(quoteStrings) + " " + item.Value.Stringify(quoteStrings))) + "}",
ImmutableHashSet <object> arr => "#{" + string.Join(' ', arr.Select(item => item.Stringify(quoteStrings))) + "}",
object[] array => "[" + string.Join(' ', array.Select(item => item.Stringify(quoteStrings))) + "]",
ImmutableArray <object> arr => "[" + string.Join(' ', arr.Select(item => item.Stringify(quoteStrings))) + "]",
IEnumerable <object> list => "(" + string.Join(' ', list.Select(item => item.Stringify(quoteStrings))) + ")",
_ => o.ToString()
};
return(s);
}
// public static string Stringify(this object o)
// {
// if (o == null) return "nil";
// if (o.Equals(true)) return "true";
// if (o.Equals(false)) return "false";
// var s = o switch
// {
// string strng => strng,
// IStringify str => str.Stringify(),
// ImmutableDictionary<object, object> arr => "{" + string.Join(' ', arr.Select(item => item.Key.Stringify() + " " + item.Value.Stringify())) + "}",
// ImmutableHashSet<object> arr => "#{" + string.Join(' ', arr.Select(item => item.Stringify())) + "}",
// object[] array => "[" + string.Join(' ', array.Select(item => item.Stringify())) + "]",
// ImmutableArray<object> arr => "[" + string.Join(' ', arr.Select(item => item.Stringify())) + "]",
// IEnumerable<object> list => "(" + string.Join(' ', list.Select(item => item.Stringify())) + ")",
// _ => o.ToString()
// };
// return s;
// }
}
protected virtual HashSet <string> GetFilesToCompile(string moniker, ImmutableHashSet <string> sharedInputs)
{
// This is a HashSet because we allow files to be both inputs and shared inputs, and we don't want to compile the same file twice,
// plus Roslyn needs to call Contains on this quite a lot in order to ensure its only compiling the right files so we want that to be fast.
// When it comes to compiling the files there is no difference between shared and normal design time inputs, we just track differently because
// shared are included in every DLL.
var files = new HashSet <string>(sharedInputs.Count + 1, StringComparers.Paths);
// All monikers are project relative paths by defintion (anything else is a link, and linked files can't be TempPE inputs) so we can convert
// them to full paths using MakeRooted.
files.AddRange(sharedInputs.Select(UnconfiguredProject.MakeRooted));
files.Add(UnconfiguredProject.MakeRooted(moniker));
return(files);
}
internal static async Task <ConflictResolution> RenameSymbolAsync(
Solution solution,
ISymbol symbol,
string newName,
RenameOptionSet optionSet,
ImmutableHashSet <ISymbol> nonConflictSymbols,
CancellationToken cancellationToken)
{
Contract.ThrowIfNull(solution);
Contract.ThrowIfNull(symbol);
Contract.ThrowIfTrue(string.IsNullOrEmpty(newName));
cancellationToken.ThrowIfCancellationRequested();
using (Logger.LogBlock(FunctionId.Renamer_RenameSymbolAsync, cancellationToken))
{
var project = solution.GetOriginatingProject(symbol);
if (project != null)
{
var client = await RemoteHostClient.TryGetClientAsync(solution.Workspace, cancellationToken).ConfigureAwait(false);
if (client != null)
{
var result = await client.TryRunRemoteAsync <SerializableConflictResolution>(
WellKnownServiceHubServices.CodeAnalysisService,
nameof(IRemoteRenamer.RenameSymbolAsync),
solution,
new object[]
{
SerializableSymbolAndProjectId.Create(symbol, project, cancellationToken),
newName,
SerializableRenameOptionSet.Dehydrate(optionSet),
nonConflictSymbols?.Select(s => SerializableSymbolAndProjectId.Dehydrate(solution, s, cancellationToken)).ToArray(),
},
callbackTarget : null,
cancellationToken).ConfigureAwait(false);
if (result.HasValue)
{
return(await result.Value.RehydrateAsync(solution, cancellationToken).ConfigureAwait(false));
}
}
}
}
return(await RenameSymbolInCurrentProcessAsync(
solution, symbol, newName, optionSet,
nonConflictSymbols, cancellationToken).ConfigureAwait(false));
}
internal static void Print(ImmutableHashSet <Point3d> bugs)
{
var builder = new StringBuilder();
var depths = bugs
.Select(b => b.Z)
.Distinct()
.OrderBy(x => x)
.ToList();
foreach (var depth in depths)
{
Print(builder, depth, bugs);
builder.AppendLine();
}
Console.WriteLine(builder.ToString());
/// <summary>
/// Delete events from a local log identified by <paramref name="logName"/> with a sequence number less than or equal to
/// <paramref name="toSequenceNr"/>. Deletion is split into logical deletion and physical deletion. Logical deletion is
/// supported by any storage backend and ensures that deleted events are not replayed any more. It has
/// immediate effect. Logically deleted events can still be replicated to remote <see cref="ReplicationEndpoint"/>s.
/// They are only physically deleted if the storage backend supports that (currently LevelDB only). Furthermore,
/// physical deletion only starts after all remote replication endpoints identified by <paramref name="remoteEndpointIds"/>
/// have successfully replicated these events. Physical deletion is implemented as reliable background
/// process that survives event log restarts.
///
/// Use with care! When events are physically deleted they cannot be replicated any more to new replication
/// endpoints (i.e. those that were unknown at the time of deletion). Also, a location with deleted events
/// may not be suitable any more for disaster recovery of other locations.
/// </summary>
/// <param name="logName">Events are deleted from the local log with this name.</param>
/// <param name="toSequenceNr">Sequence number up to which events shall be deleted (inclusive).</param>
/// <param name="remoteEndpointIds">
/// A set of remote <see cref="ReplicationEndpoint"/> ids that must have replicated events
/// to their logs before they are allowed to be physically deleted at this endpoint.
/// </param>
/// <returns>
/// The sequence number up to which events have been logically deleted. When the returned task
/// completes logical deletion is effective. The returned sequence number can differ from the requested
/// one, if:
///
/// - the log's current sequence number is smaller than the requested number. In this case the current
/// sequence number is returned.
/// - there was a previous successful deletion request with a higher sequence number. In this case that
/// number is returned.
/// </returns>
public async Task <long> Delete(string logName, long toSequenceNr, ImmutableHashSet <string> remoteEndpointIds)
{
var remoteLogIds = remoteEndpointIds
.Select(id => ReplicationEndpointInfo.LogId(id, logName))
.ToImmutableHashSet();
var response = await Logs[logName].Ask(new Delete(toSequenceNr, remoteEndpointIds), timeout: Settings.WriteTimeout);
switch (response)
{
case DeleteSuccess s: return(s.DeletedTo);
case DeleteFailure f: throw f.Cause;
default: throw new InvalidOperationException($"Expected either [{nameof(DeleteSuccess)}] or [{nameof(DeleteFailure)}] but got [{response.GetType().FullName}]");
}
}
public void ObserveDecision(
IDecision decision,
ImmutableHashSet <UniqueAddress> nodesToDown
)
{
var downMyself = nodesToDown.Contains(SelfUniqueAddress);
var indirectlyConnectedLogMessage = decision.IsIndirectlyConnected
? $", indirectly connected [{string.Join(", ", Strategy.IndirectlyConnected)}]"
: "";
Log.Warning(
$"SBR took decision {decision} and is downing [{string.Join(", ", nodesToDown.Select(i => i.Address))}]{(downMyself ? " including myself, " : "")}, " +
$"[{Strategy.Unreachable.Count}] unreachable of [{Strategy.Members.Count}] members" +
indirectlyConnectedLogMessage +
$", full reachability status: [{Strategy.Reachability}]");
}
public void Process(ImmutableHashSet <EvalStack> set)
{
if (G == null)
{
throw new NullReferenceException("Need to init G for node " + _id);
}
var x = set.Except(_I);
if (!x.IsEmpty)
{
_I = _I.Union(x);
_O = _I.Select(s => G(s)).ToImmutableHashSet();
foreach (var n in _targets)
{
n.Process(_O);
}
}
}
/// <summary>
/// Provide completions for the specified location.
/// </summary>
/// <param name="location">
/// The <see cref="SourceLocation"/> where completions are requested.
/// </param>
/// <param name="projectDocument">
/// The <see cref="ProjectDocument"/> that contains the <paramref name="location"/>.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> that can be used to cancel the operation.
/// </param>
/// <returns>
/// A <see cref="Task{TResult}"/> that resolves either a <see cref="CompletionList"/>s, or <c>null</c> if no completions are provided.
/// </returns>
public override async Task <CompletionList> ProvideCompletions(SourceLocation location, ProjectDocument projectDocument, CancellationToken cancellationToken = default(CancellationToken))
{
if (location == null)
{
throw new ArgumentNullException(nameof(location));
}
if (projectDocument == null)
{
throw new ArgumentNullException(nameof(projectDocument));
}
List <CompletionItem> completions = new List <CompletionItem>();
using (await projectDocument.Lock.ReaderLockAsync())
{
Range replaceRange = location.Position.ToEmptyRange();
completions.AddRange(
WellKnownItemAttributes
.Select(attributeName => new CompletionItem
{
Label = attributeName,
Detail = "Attribute",
Kind = CompletionItemKind.Field,
SortText = GetItemSortText(attributeName),
TextEdit = new TextEdit
{
NewText = $"{attributeName}=\"$1\"$0".WithPadding(PaddingType.None),
Range = replaceRange.ToLsp()
},
InsertTextFormat = InsertTextFormat.Snippet
})
);
}
if (completions.Count == 0)
{
return(null);
}
return(new CompletionList(completions, isIncomplete: false));
}
public void RegisterMetrics(TCollectorRegistry registry)
{
#if PROMV2
var metrics = new MetricFactory(registry);
#elif PROMV3
var metrics = Metrics.WithCustomRegistry(registry);
#endif
foreach (var sc in _statsCollectors)
{
sc.RegisterMetrics(metrics);
}
// Metrics have been registered, start the event listeners
_eventListeners = _statsCollectors
.Select(sc => new DotNetEventListener(sc, _errorHandler, _enabledDebugging))
.ToArray();
SetupConstantMetrics(metrics);
}
/// <inheritdoc/>
public override string ToString()
{
string FormatWatchingRefs()
{
if (!_watchingRefs.Any())
{
return("");
}
return($"{string.Join(", ", _watchingRefs.Select(r => r.Item2.Path.Name + "-> " + r.Item1.Path.Name))}");
}
string FormatWatchingAddresses()
{
if (!_watchingAddresses.Any())
{
return("");
}
return(string.Join(",", WatchingAddresses));
}
return($"Stats(watching={_watching}, watchingNodes={_watchingNodes}, watchingRefs=[{FormatWatchingRefs()}], watchingAddresses=[{FormatWatchingAddresses()}])");
}
private void ProcessTxIds(TxIds message)
{
if (!(message.Remote is BoundPeer peer))
{
_logger.Information(
$"Ignores a {nameof(TxIds)} message because it was sent by an invalid peer: " +
"{PeerAddress}.",
message.Remote?.Address.ToHex()
);
return;
}
_logger.Debug(
$"Received a {nameof(TxIds)} message: {{@TxIds}}.",
message.Ids.Select(txid => txid.ToString())
);
IStagePolicy <T> stagePolicy = BlockChain.StagePolicy;
ImmutableHashSet <TxId> newTxIds = message.Ids
.Where(id => !_demandTxIds.ContainsKey(id))
.Where(id => !stagePolicy.HasStaged(BlockChain, id, true))
.ToImmutableHashSet();
if (!newTxIds.Any())
{
_logger.Debug("No unaware transactions to receive.");
return;
}
_logger.Debug(
"Unaware transactions to receive: {@TxIds}.",
newTxIds.Select(txid => txid.ToString())
);
foreach (TxId txid in newTxIds)
{
_demandTxIds.TryAdd(txid, peer);
}
}
internal static async Task <ConflictResolution> ResolveConflictsAsync(
RenameLocations renameLocationSet,
string replacementText,
ImmutableHashSet <ISymbol> nonConflictSymbols,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (Logger.LogBlock(FunctionId.Renamer_FindRenameLocationsAsync, cancellationToken))
{
var solution = renameLocationSet.Solution;
var client = await RemoteHostClient.TryGetClientAsync(solution.Workspace, cancellationToken).ConfigureAwait(false);
if (client != null)
{
var result = await client.TryRunRemoteAsync <SerializableConflictResolution>(
WellKnownServiceHubServices.CodeAnalysisService,
nameof(IRemoteRenamer.ResolveConflictsAsync),
solution,
new object[]
{
renameLocationSet.Dehydrate(solution, cancellationToken),
replacementText,
nonConflictSymbols?.Select(s => SerializableSymbolAndProjectId.Dehydrate(solution, s, cancellationToken)).ToArray(),
},
callbackTarget : null,
cancellationToken).ConfigureAwait(false);
if (result.HasValue)
{
return(await result.Value.RehydrateAsync(solution, cancellationToken).ConfigureAwait(false));
}
}
}
return(await ResolveConflictsInCurrentProcessAsync(
renameLocationSet, replacementText, nonConflictSymbols, cancellationToken).ConfigureAwait(false));
}
public override string ToString()
{
Func <string> formatWatchingRefs = () =>
{
if (!_watchingRefs.Any())
{
return("");
}
return
($"{_watchingRefs.Select(r => r.Item2.Path.Name + "-> " + r.Item1.Path.Name).Aggregate((a, b) => a + ", " + b)}");
};
Func <string> formatWatchingAddresses = () =>
{
if (!_watchingAddresses.Any())
{
return("");
}
return(string.Join(",", WatchingAddresses));
};
return($"Stats(watching={_watching}, watchingNodes={_watchingNodes}, watchingRefs=[{formatWatchingRefs()}], watchingAddresses=[{formatWatchingAddresses()}])");
}
private void EvaluateActions(Block <T> block)
{
HashDigest <SHA256>?prevHash = block.PreviousHash;
IAccountStateDelta[] deltas = block.EvaluateActions(address =>
{
IImmutableDictionary <Address, object> result =
GetStates(new[] { address }, prevHash);
try
{
return(result[address]);
}
catch (KeyNotFoundException)
{
return(null);
}
}).ToArray();
IAccountStateDelta lastStates = deltas.LastOrDefault();
ImmutableHashSet <Address> updatedAddresses =
deltas.Select(d => d.UpdatedAddresses).Aggregate(
ImmutableHashSet <Address> .Empty,
(a, b) => a.Union(b)
);
IImmutableDictionary <Address, object> totalDelta =
updatedAddresses.Select(
a => new KeyValuePair <Address, object>(
a,
lastStates?.GetState(a)
)
).ToImmutableDictionary();
Store.SetBlockStates(
block.Hash,
new AddressStateMap(totalDelta)
);
}
private Receive Active(IActorRef receptionist)
{
return(message =>
{
if (message is Send)
{
var send = (Send)message;
receptionist.Forward(new PublishSubscribe.Send(send.Path, send.Message, send.LocalAffinity));
}
else if (message is SendToAll)
{
var sendToAll = (SendToAll)message;
receptionist.Forward(new PublishSubscribe.SendToAll(sendToAll.Path, sendToAll.Message));
}
else if (message is Publish)
{
var publish = (Publish)message;
receptionist.Forward(new PublishSubscribe.Publish(publish.Topic, publish.Message));
}
else if (message is HeartbeatTick)
{
if (!_failureDetector.IsAvailable)
{
_log.Info("Lost contact with [{0}], reestablishing connection", receptionist);
SendGetContacts();
ScheduleRefreshContactsTick(_settings.EstablishingGetContactsInterval);
Context.Become(Establishing);
_failureDetector.HeartBeat();
}
else
{
receptionist.Tell(ClusterReceptionist.Heartbeat.Instance);
}
}
else if (message is ClusterReceptionist.HeartbeatRsp)
{
_failureDetector.HeartBeat();
}
else if (message is RefreshContactsTick)
{
receptionist.Tell(ClusterReceptionist.GetContacts.Instance);
}
else if (message is ClusterReceptionist.Contacts)
{
var contacts = (ClusterReceptionist.Contacts)message;
// refresh of contacts
if (contacts.ContactPoints.Count > 0)
{
_contactPaths = contacts.ContactPoints.Select(ActorPath.Parse).ToImmutableHashSet();
_contacts = _contactPaths.Select(Context.ActorSelection).ToArray();
}
PublishContactPoints();
}
else if (message is ActorIdentity)
{
// ok, from previous establish, already handled
}
else
{
return ContactPointMessages(message);
}
return true;
});
}
private bool Establishing(object message)
{
ICancelable connectTimerCancelable = null;
if (_settings.ReconnectTimeout.HasValue)
{
connectTimerCancelable = Context.System.Scheduler.ScheduleTellOnceCancelable(
_settings.ReconnectTimeout.Value,
Self,
ReconnectTimeout.Instance,
Self);
}
if (message is ClusterReceptionist.Contacts)
{
var contacts = (ClusterReceptionist.Contacts)message;
if (contacts.ContactPoints.Count > 0)
{
_contactPaths = contacts.ContactPoints.Select(ActorPath.Parse).ToImmutableHashSet();
_contacts = _contactPaths.Select(Context.ActorSelection).ToArray();
_contacts.ForEach(c => c.Tell(new Identify(null)));
}
PublishContactPoints();
}
else if (message is ActorIdentity)
{
var actorIdentify = (ActorIdentity)message;
var receptionist = actorIdentify.Subject;
if (receptionist != null)
{
_log.Info("Connected to [{0}]", receptionist.Path);
ScheduleRefreshContactsTick(_settings.RefreshContactsInterval);
SendBuffered(receptionist);
Context.Become(Active(receptionist));
connectTimerCancelable?.Cancel();
_failureDetector.HeartBeat();
}
else
{
// ok, use another instead
}
}
else if (message is HeartbeatTick)
{
_failureDetector.HeartBeat();
}
else if (message is RefreshContactsTick)
{
SendGetContacts();
}
else if (message is Send)
{
var send = (Send)message;
Buffer(new PublishSubscribe.Send(send.Path, send.Message, send.LocalAffinity));
}
else if (message is SendToAll)
{
var sendToAll = (SendToAll)message;
Buffer(new PublishSubscribe.SendToAll(sendToAll.Path, sendToAll.Message));
}
else if (message is Publish)
{
var publish = (Publish)message;
Buffer(new PublishSubscribe.Publish(publish.Topic, publish.Message));
}
else if (message is ReconnectTimeout)
{
_log.Warning("Receptionist reconnect not successful within {0} stopping cluster client", _settings.ReconnectTimeout);
Context.Stop(Self);
}
else
{
return(ContactPointMessages(message));
}
return(true);
}
public ClusterClient(ClusterClientSettings settings)
{
if (settings.InitialContacts.Count == 0)
{
throw new ArgumentException("Initial contacts for cluster client cannot be empty");
}
_settings = settings;
_failureDetector = new DeadlineFailureDetector(_settings.AcceptableHeartbeatPause, _settings.HeartbeatInterval);
_contactPaths = settings.InitialContacts.ToImmutableHashSet();
_initialContactsSelections = _contactPaths.Select(Context.ActorSelection).ToArray();
_contacts = _initialContactsSelections;
SendGetContacts();
_contactPathsPublished = ImmutableHashSet<ActorPath>.Empty;
_subscribers = ImmutableList<IActorRef>.Empty;
_heartbeatTask = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
settings.HeartbeatInterval,
settings.HeartbeatInterval,
Self,
HeartbeatTick.Instance,
Self);
_refreshContactsCancelable = null;
ScheduleRefreshContactsTick(settings.EstablishingGetContactsInterval);
Self.Tell(RefreshContactsTick.Instance);
_buffer = new Queue<Tuple<object, IActorRef>>();
}
private bool Establishing(object message)
{
ICancelable connectTimerCancelable = null;
if (_settings.ReconnectTimeout.HasValue)
{
connectTimerCancelable = Context.System.Scheduler.ScheduleTellOnceCancelable(
_settings.ReconnectTimeout.Value,
Self,
ReconnectTimeout.Instance,
Self);
}
if (message is ClusterReceptionist.Contacts)
{
var contacts = (ClusterReceptionist.Contacts)message;
if (contacts.ContactPoints.Count > 0)
{
_contactPaths = contacts.ContactPoints.Select(ActorPath.Parse).ToImmutableHashSet();
_contacts = _contactPaths.Select(Context.ActorSelection).ToArray();
_contacts.ForEach(c => c.Tell(new Identify(null)));
}
PublishContactPoints();
}
else if (message is ActorIdentity)
{
var actorIdentify = (ActorIdentity)message;
var receptionist = actorIdentify.Subject;
if (receptionist != null)
{
_log.Info("Connected to [{0}]", receptionist.Path);
ScheduleRefreshContactsTick(_settings.RefreshContactsInterval);
SendBuffered(receptionist);
Context.Become(Active(receptionist));
connectTimerCancelable?.Cancel();
_failureDetector.HeartBeat();
}
else
{
// ok, use another instead
}
}
else if (message is HeartbeatTick)
{
_failureDetector.HeartBeat();
}
else if (message is RefreshContactsTick)
{
SendGetContacts();
}
else if (message is Send)
{
var send = (Send)message;
Buffer(new PublishSubscribe.Send(send.Path, send.Message, send.LocalAffinity));
}
else if (message is SendToAll)
{
var sendToAll = (SendToAll)message;
Buffer(new PublishSubscribe.SendToAll(sendToAll.Path, sendToAll.Message));
}
else if (message is Publish)
{
var publish = (Publish)message;
Buffer(new PublishSubscribe.Publish(publish.Topic, publish.Message));
}
else if (message is ReconnectTimeout)
{
_log.Warning("Receptionist reconnect not successful within {0} stopping cluster client", _settings.ReconnectTimeout);
Context.Stop(Self);
}
else
{
return ContactPointMessages(message);
}
return true;
}
private Receive Active(IActorRef receptionist)
{
return message =>
{
if (message is Send)
{
var send = (Send)message;
receptionist.Forward(new PublishSubscribe.Send(send.Path, send.Message, send.LocalAffinity));
}
else if (message is SendToAll)
{
var sendToAll = (SendToAll)message;
receptionist.Forward(new PublishSubscribe.SendToAll(sendToAll.Path, sendToAll.Message));
}
else if (message is Publish)
{
var publish = (Publish)message;
receptionist.Forward(new PublishSubscribe.Publish(publish.Topic, publish.Message));
}
else if (message is HeartbeatTick)
{
if (!_failureDetector.IsAvailable)
{
_log.Info("Lost contact with [{0}], restablishing connection", receptionist);
SendGetContacts();
ScheduleRefreshContactsTick(_settings.EstablishingGetContactsInterval);
Context.Become(Establishing);
_failureDetector.HeartBeat();
}
else
{
receptionist.Tell(ClusterReceptionist.Heartbeat.Instance);
}
}
else if (message is ClusterReceptionist.HeartbeatRsp)
{
_failureDetector.HeartBeat();
}
else if (message is RefreshContactsTick)
{
receptionist.Tell(ClusterReceptionist.GetContacts.Instance);
}
else if (message is ClusterReceptionist.Contacts)
{
var contacts = (ClusterReceptionist.Contacts)message;
// refresh of contacts
if (contacts.ContactPoints.Count > 0)
{
_contactPaths = contacts.ContactPoints.Select(ActorPath.Parse).ToImmutableHashSet();
_contacts = _contactPaths.Select(Context.ActorSelection).ToArray();
}
PublishContactPoints();
}
else if (message is ActorIdentity)
{
// ok, from previous establish, already handled
}
else
{
return ContactPointMessages(message);
}
return true;
};
}
private Tuple<IEnumerable<Cell>, int> GetPointsFromClearing(ImmutableHashSet<Cell> allCells)
{
IEnumerable<Cell> newCells = allCells.ToList();
int addPoints = 0;
foreach (int row in allCells.Select(c => c.Y).Distinct().
Where(row => CheckRowFull(allCells, row)))
{
int rowNumber = row;
newCells = newCells.Where(c => c.Y != rowNumber).ToList();
var shiftCells = newCells.Where(r => r.Y < rowNumber).Select(c => new Cell(c.X, c.Y+1)).ToList();
newCells = newCells.Where(r => r.Y > rowNumber).Union(shiftCells);
addPoints++;
}
return new Tuple<IEnumerable<Cell>, int>(newCells, addPoints);
}
public override string ToString()
{
return($"{DocumentId?.ToString() ?? ProjectId.ToString()}, ({InvocationReasons.ToString()}), LowPriority:{IsLowPriority}, ActiveMember:{ActiveMember != null}, Retry:{IsRetry}, ({string.Join("|", Analyzers.Select(a => a.GetType().Name))})");
}
public static void writeClustering(ImmutableHashSet <ImmutableHashSet <AST.Address> > clustering, string filename)
{
var mclustering = new HashSet <HashSet <AST.Address> >(clustering.Select(cl => new HashSet <AST.Address>(cl)));
writeClustering(mclustering, filename);
}
//State transition to JOINING - new node joining.
//Received `Join` message and replies with `Welcome` message, containing
// current gossip state, including the new joining member.
public void Joining(UniqueAddress node, ImmutableHashSet<string> roles)
{
if(node.Address.Protocol != _cluster.SelfAddress.Protocol)
{
_log.Warning("Member with wrong protocol tried to join, but was ignored, expected [{0}] but was [{1}]",
_cluster.SelfAddress.Protocol, node.Address.Protocol);
}
else if (node.Address.System != _cluster.SelfAddress.System)
{
_log.Warning(
"Member with wrong ActorSystem name tried to join, but was ignored, expected [{0}] but was [{1}]",
_cluster.SelfAddress.System, node.Address.System);
}
else
{
var localMembers = _latestGossip.Members;
// check by address without uid to make sure that node with same host:port is not allowed
// to join until previous node with that host:port has been removed from the cluster
var alreadyMember = localMembers.Any(m => m.Address == node.Address);
var isUnreachable = !_latestGossip.Overview.Reachability.IsReachable(node);
if (alreadyMember) _log.Info("Existing member [{0}] is trying to join, ignoring", node);
else if (isUnreachable) _log.Info("Unreachable member [{0}] is trying to join, ignoring", node);
else
{
// remove the node from the failure detector
_cluster.FailureDetector.Remove(node.Address);
// add joining node as Joining
// add self in case someone else joins before self has joined (Set discards duplicates)
var newMembers = localMembers
.Add(Member.Create(node, roles))
.Add(Member.Create(_cluster.SelfUniqueAddress, _cluster.SelfRoles));
var newGossip = _latestGossip.Copy(members: newMembers);
UpdateLatestGossip(newGossip);
_log.Info("Node [{0}] is JOINING, roles [{1}]", node.Address,
roles.Select(r => r.ToString()).Aggregate("", (a, b) => a + ", " + b));
if (!node.Equals(SelfUniqueAddress))
{
Sender.Tell(new InternalClusterAction.Welcome(SelfUniqueAddress, _latestGossip));
}
Publish(_latestGossip);
}
}
}
