public string ResolveVersion(string input) { var key = IDFSTR.FirstOrDefault(x => x.Value.Contains(input.ToUpper())).Key; if (key == null) { return(null); } var downloaded = DownloadMainfest(); try { return(ResolveVersionFromMainfestFile(key)); } catch (Exception ex) { Log.Error($"Failed to read '{Config.ManifestJsonFilePath}'", ex); if (downloaded) { throw; } Log.Warn($"Failed to executed {nameof(ResolveVersionFromMainfestFile)}; Mainfest was already downloaded, downloading it again, so it's up-to-date", ex); DownloadMainfest(true); return(ResolveVersionFromMainfestFile(key)); } }
private void ProcessStateChange(ProcessStateChange obj) { var(key, target) = _targetProcesses.FirstOrDefault(p => p.Key.Contains(obj.Name)); if (string.IsNullOrWhiteSpace(key)) { return; } target.Tell(obj); }
/// <summary> /// 获取枚举字段 /// </summary> /// <param name="enumType"></param> /// <returns></returns> public static EnumField[] GetEnumFields(string enumType) { if (enumType == null) { throw new ArgumentNullException("enumType"); } KeyValuePair <Type, EnumField[]> keyValuePair = EnumFiledCache.FirstOrDefault((KeyValuePair <Type, EnumField[]> x) => x.Key.Name == enumType || x.Key.FullName == enumType); if (keyValuePair.Key == null) { return(Array.Empty <EnumField>()); } return(GetEnumFields(keyValuePair.Key)); }
public int?FindDistanceWithRecursion(Point start, Point end) { var queue = new Queue <(Point Point, int Distance, int Level)>(); var visited = new HashSet <(Point, int)>(); queue.Enqueue((start, 0, 0)); while (queue.Count > 0) { var(point, distance, level) = queue.Dequeue(); if (point == end && level == 0) { return(distance); } if (visited.Contains((point, level))) { continue; } visited.Add((point, level)); foreach (var(neighbour, resLevel) in AdjacentFunction(point, level)) { queue.Enqueue((neighbour, distance + 1, resLevel)); } } return(null); IEnumerable <(Point Point, int Level)> AdjacentFunction(Point point, int level) { var entity = _mapArr[point]; if (entity is PortalEntity pe) { var(matchingPortal, _) = _mapArr.FirstOrDefault(x => x.Value.Identifier == entity.Identifier && x.Key != point); if (matchingPortal is null) { return(GetAdjacentNonWalls(point, level)); } var newLevel = pe.PortalType == PortalType.Outer ? level - 1 : level + 1; return(GetAdjacentNonWalls(point, level).Concat(new[] { (matchingPortal, newLevel) }));
public ConfiguredProject GetInnerConfiguredProject(ITargetFramework target) { return(_configuredProjectsByTargetFramework.FirstOrDefault((x, t) => t.Equals(x.Key), target).Value); }
public ReplicatorActor(ReplicaId myself, ReplicatorSettings settings) { this.myself = myself; this.settings = settings; replicatorRelativePath = Self.Path.ToStringWithoutAddress(); Receive <ClusterEvent.MemberUp>(up => { if (HasRole(up.Member) && up.Member.Address != cluster.SelfAddress) { // send invitation to a new member var path = up.Member.Address.ToString() + replicatorRelativePath; Context.ActorSelection(path).Tell(new Invitation(myself, Self)); } }); Receive <ClusterEvent.IMemberEvent>(_ => { /* ignore */ }); Receive <Broadcast <T> >(bcast => { var version = localVersion.Increment(myself); var versioned = new Versioned <T>(version, bcast.Message); var send = new Send <T>(myself, myself, versioned); if (log.IsInfoEnabled) { log.Info("Sending {0} to: {1}", send, string.Join(", ", members)); } foreach (var member in members) { member.Value.Forward(send); } var pendingAck = new PendingAck <T>(myself, versioned, DateTime.UtcNow, members.Keys.ToImmutableHashSet()); this.pendingAcks = pendingAcks.Add(pendingAck); this.localVersion = version; }); Receive <Send <T> >(send => { if (AlreadySeen(send.Versioned.Version)) { log.Info("Received duplicate message {0}", send); } else { var receivers = members.Remove(send.Origin); var forward = send.WithLastSeenBy(myself); if (log.IsInfoEnabled) { log.Info("Broadcasting message {0} to: {1}", forward, string.Join(", ", receivers.Values)); } foreach (var member in receivers.Values) { member.Forward(forward); } if (members.TryGetValue(send.LastSeenBy, out var sender)) { sender.Tell(new SendAck(myself, send.Versioned.Version), ActorRefs.NoSender); } var deliver = new Deliver <T>(send.Origin, send.Versioned); Self.Forward(deliver); this.pendingDelivery = pendingDelivery.Add(deliver); this.pendingAcks = pendingAcks.Add(new PendingAck <T>(myself, send.Versioned, DateTime.UtcNow, receivers.Keys.ToImmutableHashSet())); } }); Receive <SendAck>(ack => { log.Info("Received ACK from {0} (version: {1})", Sender, ack.Version); var pendingAck = this.pendingAcks.First(x => x.Versioned.Version == ack.Version); var membersLeft = pendingAck.Members.Remove(ack.ReplicaId); this.pendingAcks = pendingAcks.Remove(pendingAck); if (!membersLeft.IsEmpty) { this.pendingAcks = pendingAcks.Add(pendingAck.WithMembers(membersLeft)); } }); Receive <Deliver <T> >(deliver => { TryToCasuallyDeliver(deliver); remoteVersions = remoteVersions.SetItem(deliver.Origin, deliver.Versioned.Version); latestStableVersion = UpdateStableVersion(remoteVersions); }); Receive <Resend>(_ => { var now = DateTime.UtcNow; var builder = pendingAcks.ToBuilder(); foreach (var ack in pendingAcks) { if (now - ack.Timestamp > settings.RetryTimeout) { builder.Remove(ack); var send = new Send <T>(myself, myself, ack.Versioned); foreach (var replicaId in ack.Members) { if (members.TryGetValue(replicaId, out var member)) { member.Tell(send, ActorRefs.NoSender); } } builder.Add(ack.WithTimestamp(now)); } } pendingAcks = builder.ToImmutable(); }); Receive <Invitation>(invitation => { log.Info("Received invitation from {0} (ID: {1})", invitation.ReplicatorRef, invitation.ReplicaId); members = members.Add(invitation.ReplicaId, invitation.ReplicatorRef); Context.Watch(invitation.ReplicatorRef); }); Receive <StableReq>(sync => { var reply = sync.Versions.Where(ver => latestStableVersion >= ver).ToArray(); Sender.Tell(new StableRep(reply)); }); Receive <Subscribe <T> >(subscribe => { subscribers = subscribers.Add(subscribe.Ref); if (subscribe.Ack != null) { subscribe.Ref.Tell(subscribe.Ack); } }); Receive <Unsubscribe>(unsubscribe => { subscribers = subscribers.Remove(unsubscribe.Ref); if (unsubscribe.Ack != null) { unsubscribe.Ref.Tell(unsubscribe.Ack); } }); Receive <Terminated>(terminated => { subscribers = subscribers.Remove(terminated.ActorRef); var replicaId = members.FirstOrDefault(kv => Equals(kv.Value, terminated.ActorRef)); members = members.Remove(replicaId.Key); }); resendTask = Context.System.Scheduler .ScheduleTellOnceCancelable(settings.ResendInterval, Self, Resend.Instance, ActorRefs.NoSender); }