IDisposable IHandlersManager.AddLink(string sourceMethod, string destinationMethod)
{
var source = _descriptors.First(z => z.Method == sourceMethod);
LspHandlerDescriptor descriptor = null;
descriptor = GetDescriptor(
destinationMethod,
source.HandlerType,
source.Handler,
source.RequestProcessType.HasValue ? new JsonRpcHandlerOptions {
RequestProcessType = source.RequestProcessType.Value
} : null,
source.TypeDescriptor,
source.HandlerType,
source.RegistrationType,
source.CapabilityType
);
Interlocked.Exchange(ref _descriptors, _descriptors.Add(descriptor));
var cd = new CompositeDisposable();
if (descriptor.Handler is ITextDocumentIdentifier textDocumentIdentifier)
{
cd.Add(_textDocumentIdentifiers.Add(textDocumentIdentifier));
}
return(new LspHandlerDescriptorDisposable(new[] { descriptor }, cd));
}
private bool RespectsAllConstraints(ImmutableHashSet <Substitution> substitutions)
{
return(substitutions.All(sub => sub.typeParameter
.GetAllConstraints()
.All(constraint => IsAssignableTo(sub.typeArgument,
substitutions.First(s => s.typeParameter.Equals(constraint)).typeArgument))));
}
public ClusterRouterGroupSettings(int totalInstances, bool allowLocalRoutees, string useRole, ImmutableHashSet<string> routeesPaths) : base(totalInstances, allowLocalRoutees, useRole)
{
RouteesPaths = routeesPaths;
if(routeesPaths == null || routeesPaths.IsEmpty || string.IsNullOrEmpty(routeesPaths.First())) throw new ArgumentException("routeesPaths must be defined", "routeesPaths");
//todo add relative actor path validation
}
public static string GetDefaultFixAllTitle(
FixAllScope fixAllScope,
ImmutableHashSet <string> diagnosticIds,
Document?triggerDocument,
Project triggerProject
)
{
var diagnosticId = diagnosticIds.First();
return(fixAllScope switch
{
FixAllScope.Custom
=> string.Format(WorkspaceExtensionsResources.Fix_all_0, diagnosticId),
FixAllScope.Document
=> string.Format(
WorkspaceExtensionsResources.Fix_all_0_in_1,
diagnosticId,
triggerDocument !.Name
),
FixAllScope.Project
=> string.Format(
WorkspaceExtensionsResources.Fix_all_0_in_1,
diagnosticId,
triggerProject.Name
),
FixAllScope.Solution
=> string.Format(
WorkspaceExtensionsResources.Fix_all_0_in_Solution,
diagnosticId
),
_ => throw ExceptionUtilities.UnexpectedValue(fixAllScope),
});
public override int GetHashCode()
{
if (Count == 0)
{
return(0);
}
return(HashCode.Combine(_set.First()));
}
public ClusterRouterGroupSettings(int totalInstances, bool allowLocalRoutees, string useRole, ImmutableHashSet <string> routeesPaths) : base(totalInstances, allowLocalRoutees, useRole)
{
RouteesPaths = routeesPaths;
if (routeesPaths == null || routeesPaths.IsEmpty || string.IsNullOrEmpty(routeesPaths.First()))
{
throw new ArgumentException("routeesPaths must be defined", "routeesPaths");
}
//todo add relative actor path validation
}
internal CopyAbstractValue(ImmutableHashSet <AnalysisEntity> analysisEntities, CopyAbstractValueKind kind)
{
Debug.Assert(analysisEntities.IsEmpty != kind.IsKnown());
Debug.Assert(kind != CopyAbstractValueKind.KnownReferenceCopy || analysisEntities.All(a => !a.Type.IsValueType));
if (kind == CopyAbstractValueKind.KnownValueCopy &&
analysisEntities.Count == 1 &&
!analysisEntities.First().Type.IsValueType)
{
kind = CopyAbstractValueKind.KnownReferenceCopy;
}
AnalysisEntities = analysisEntities;
Kind = kind;
}
public ClusterRouterGroupSettings(int totalInstances, bool allowLocalRoutees, string useRole, ImmutableHashSet <string> routeesPaths) : base(totalInstances, allowLocalRoutees, useRole)
{
RouteesPaths = routeesPaths;
if (routeesPaths == null || routeesPaths.IsEmpty || string.IsNullOrEmpty(routeesPaths.First()))
{
throw new ArgumentException("routeesPaths must be defined", "routeesPaths");
}
//validate that all routeesPaths are relative
foreach (var path in routeesPaths)
{
if (RelativeActorPath.Unapply(path) == null)
{
throw new ArgumentException(string.Format("routeesPaths [{0}] is not a valid relative actor path.", path), "routeesPaths");
}
}
}
public void ClusterClient_must_reestablish_connection_to_receptionist_after_server_restart()
{
Within(30.Seconds(), () =>
{
RunOn(() =>
{
_remainingServerRoleNames.Count.Should().Be(1);
var remainingContacts = _remainingServerRoleNames.Select(r => Node(r) / "system" / "receptionist").ToImmutableHashSet();
var c = Sys.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(remainingContacts)), "client4");
c.Tell(new ClusterClient.Send("/user/service2", "bonjour4", localAffinity: true));
var reply = ExpectMsg <ClusterClientSpecConfig.Reply>(10.Seconds());
reply.Msg.Should().Be("bonjour4-ack");
reply.Node.Should().Be(remainingContacts.First().Address);
// TODO: bug, cannot compare with a logsource
var logSource = $"{Sys.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress}/user/client4";
EventFilter.Info(start: "Connected to").ExpectOne(() =>
{
EventFilter.Info(start: "Lost contact").ExpectOne(() =>
{
// shutdown server
TestConductor.Shutdown(_remainingServerRoleNames.First()).Wait();
});
});
c.Tell(new ClusterClient.Send("/user/service2", "shutdown", localAffinity: true));
Thread.Sleep(2000); // to ensure that it is sent out before shutting down system
}, _config.Client);
RunOn(() =>
{
Sys.WhenTerminated.Wait(20.Seconds());
// start new system on same port
var port = Cluster.Get(Sys).SelfAddress.Port;
var sys2 = ActorSystem.Create(
Sys.Name,
ConfigurationFactory.ParseString($"akka.remote.dot-netty.tcp.port={port}").WithFallback(Sys.Settings.Config));
Cluster.Get(sys2).Join(Cluster.Get(sys2).SelfAddress);
var service2 = sys2.ActorOf(Props.Create(() => new ClusterClientSpecConfig.TestService(TestActor)), "service2");
ClusterClientReceptionist.Get(sys2).RegisterService(service2);
sys2.WhenTerminated.Wait(20.Seconds());
}, _remainingServerRoleNames.ToArray());
});
}
public BicepTelemetryEvent?GetTelemetryAboutSourceFiles(SemanticModel semanticModel, Uri uri, ImmutableHashSet <ISourceFile> sourceFiles, IEnumerable <Diagnostic> diagnostics)
{
var mainFile = sourceFiles.First(x => x.FileUri == uri) as BicepFile;
if (mainFile is null)
{
return(null);
}
Dictionary <string, string> properties = GetTelemetryPropertiesForMainFile(semanticModel, mainFile, diagnostics);
var referencedFiles = sourceFiles.Where(x => x.FileUri != uri);
var propertiesFromReferencedFiles = GetTelemetryPropertiesForReferencedFiles(referencedFiles);
properties = properties.Concat(propertiesFromReferencedFiles).ToDictionary(s => s.Key, s => s.Value);
return(BicepTelemetryEvent.CreateBicepFileOpen(properties));
}
/// <summary>
/// Asynchronously deregisters a handler.
/// </summary>
/// <param name="handlerFactory">The handler to deregister.</param>
/// <returns>
/// A task representing the asynchronous operation.
/// The value of the <see cref="Task{TResult}.Result"/> parameter contains a boolean value
/// indicating whether the handler was actually found and deregistered.
/// </returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="handlerFactory"/> is null.</exception>
public async Task <bool> DeregisterAsync(IContextualProvider <THandler> handlerFactory)
{
if (handlerFactory == null)
{
throw new ArgumentNullException(nameof(handlerFactory));
}
Debug.Assert(_handlers != null);
Debug.Assert(_lock != null);
using (await _lock.LockAsync())
{
if (!_handlers.Contains(handlerFactory))
{
return(false);
}
var handlers = _handlers.Remove(handlerFactory);
if (handlers.IsEmpty)
{
await _dispatchForwarding.UnregisterForwardingAsync();
}
if (handlers.IsEmpty && handlerFactory is IDeactivationNotifyable deactivationNotifyable)
{
await deactivationNotifyable.NotifyDeactivationAsync();
}
_handlers = handlers;
if (_handlers.Count == 1 && _handlers.First() is IActivationNotifyable activationNotifyable)
{
await activationNotifyable.NotifyActivationAsync();
}
return(true);
}
}
public static ImmutableHashSet <T> DeleteEntityReducer <T>(ImmutableHashSet <T> previousState, Delete <T> prescription) where T : IEntity
{
var entityToDelete = previousState.First(a => a.EntityId == prescription.Entity.EntityId);
return(previousState.Remove(entityToDelete));
}
public void Verify()
{
Assert.Equal((short)1, MyInt16);
Assert.Equal((int)2, MyInt32);
Assert.Equal((long)3, MyInt64);
Assert.Equal((ushort)4, MyUInt16);
Assert.Equal((uint)5, MyUInt32);
Assert.Equal((ulong)6, MyUInt64);
Assert.Equal((byte)7, MyByte);
Assert.Equal((sbyte)8, MySByte);
Assert.Equal('a', MyChar);
Assert.Equal("Hello", MyString);
Assert.Equal(3.3m, MyDecimal);
Assert.False(MyBooleanFalse);
Assert.True(MyBooleanTrue);
Assert.Equal(1.1f, MySingle);
Assert.Equal(2.2d, MyDouble);
Assert.Equal(new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc), MyDateTime);
Assert.Equal(new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)), MyDateTimeOffset);
Assert.Equal(new Guid("1B33498A-7B7D-4DDA-9C13-F6AA4AB449A6"), MyGuid);
Assert.Equal(new Uri("https://github.com/dotnet/runtime"), MyUri);
Assert.Equal(SampleEnum.Two, MyEnum);
Assert.Equal(SampleEnumInt64.MinNegative, MyInt64Enum);
Assert.Equal(SampleEnumUInt64.Max, MyUInt64Enum);
Assert.Equal(11, MySimpleStruct.One);
Assert.Equal(1.9999, MySimpleStruct.Two);
Assert.Equal(64, MySimpleTestStruct.MyInt64);
Assert.Equal("Hello", MySimpleTestStruct.MyString);
Assert.Equal(32, MySimpleTestStruct.MyInt32Array[0]);
Assert.Equal((short)1, MyInt16Array[0]);
Assert.Equal((int)2, MyInt32Array[0]);
Assert.Equal((long)3, MyInt64Array[0]);
Assert.Equal((ushort)4, MyUInt16Array[0]);
Assert.Equal((uint)5, MyUInt32Array[0]);
Assert.Equal((ulong)6, MyUInt64Array[0]);
Assert.Equal((byte)7, MyByteArray[0]);
Assert.Equal((sbyte)8, MySByteArray[0]);
Assert.Equal('a', MyCharArray[0]);
Assert.Equal("Hello", MyStringArray[0]);
Assert.Equal(3.3m, MyDecimalArray[0]);
Assert.False(MyBooleanFalseArray[0]);
Assert.True(MyBooleanTrueArray[0]);
Assert.Equal(1.1f, MySingleArray[0]);
Assert.Equal(2.2d, MyDoubleArray[0]);
Assert.Equal(new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc), MyDateTimeArray[0]);
Assert.Equal(new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)), MyDateTimeOffsetArray[0]);
Assert.Equal(new Guid("1B33498A-7B7D-4DDA-9C13-F6AA4AB449A6"), MyGuidArray[0]);
Assert.Equal(new Uri("https://github.com/dotnet/runtime"), MyUriArray[0]);
Assert.Equal(SampleEnum.Two, MyEnumArray[0]);
Assert.Equal(10, MyInt16TwoDimensionArray[0][0]);
Assert.Equal(11, MyInt16TwoDimensionArray[0][1]);
Assert.Equal(20, MyInt16TwoDimensionArray[1][0]);
Assert.Equal(21, MyInt16TwoDimensionArray[1][1]);
Assert.Equal(10, MyInt16TwoDimensionList[0][0]);
Assert.Equal(11, MyInt16TwoDimensionList[0][1]);
Assert.Equal(20, MyInt16TwoDimensionList[1][0]);
Assert.Equal(21, MyInt16TwoDimensionList[1][1]);
Assert.Equal(11, MyInt16ThreeDimensionArray[0][0][0]);
Assert.Equal(12, MyInt16ThreeDimensionArray[0][0][1]);
Assert.Equal(13, MyInt16ThreeDimensionArray[0][1][0]);
Assert.Equal(14, MyInt16ThreeDimensionArray[0][1][1]);
Assert.Equal(21, MyInt16ThreeDimensionArray[1][0][0]);
Assert.Equal(22, MyInt16ThreeDimensionArray[1][0][1]);
Assert.Equal(23, MyInt16ThreeDimensionArray[1][1][0]);
Assert.Equal(24, MyInt16ThreeDimensionArray[1][1][1]);
Assert.Equal(11, MyInt16ThreeDimensionList[0][0][0]);
Assert.Equal(12, MyInt16ThreeDimensionList[0][0][1]);
Assert.Equal(13, MyInt16ThreeDimensionList[0][1][0]);
Assert.Equal(14, MyInt16ThreeDimensionList[0][1][1]);
Assert.Equal(21, MyInt16ThreeDimensionList[1][0][0]);
Assert.Equal(22, MyInt16ThreeDimensionList[1][0][1]);
Assert.Equal(23, MyInt16ThreeDimensionList[1][1][0]);
Assert.Equal(24, MyInt16ThreeDimensionList[1][1][1]);
Assert.Equal("Hello", MyStringList[0]);
IEnumerator enumerator = MyStringIEnumerable.GetEnumerator();
enumerator.MoveNext();
{
// Verifying after deserialization.
if (enumerator.Current is JsonElement currentJsonElement)
{
Assert.Equal("Hello", currentJsonElement.GetString());
}
// Verifying test data.
else
{
Assert.Equal("Hello", enumerator.Current);
}
}
{
// Verifying after deserialization.
if (MyStringIList[0] is JsonElement currentJsonElement)
{
Assert.Equal("Hello", currentJsonElement.GetString());
}
// Verifying test data.
else
{
Assert.Equal("Hello", enumerator.Current);
}
}
enumerator = MyStringICollection.GetEnumerator();
enumerator.MoveNext();
{
// Verifying after deserialization.
if (enumerator.Current is JsonElement currentJsonElement)
{
Assert.Equal("Hello", currentJsonElement.GetString());
}
// Verifying test data.
else
{
Assert.Equal("Hello", enumerator.Current);
}
}
Assert.Equal("Hello", MyStringIEnumerableT.First());
Assert.Equal("Hello", MyStringIListT[0]);
Assert.Equal("Hello", MyStringICollectionT.First());
Assert.Equal("Hello", MyStringIReadOnlyCollectionT.First());
Assert.Equal("Hello", MyStringIReadOnlyListT[0]);
Assert.Equal("Hello", MyStringISetT.First());
enumerator = MyStringToStringIDict.GetEnumerator();
enumerator.MoveNext();
{
// Verifying after deserialization.
if (enumerator.Current is JsonElement currentJsonElement)
{
IEnumerator jsonEnumerator = currentJsonElement.EnumerateObject();
jsonEnumerator.MoveNext();
JsonProperty property = (JsonProperty)jsonEnumerator.Current;
Assert.Equal("key", property.Name);
Assert.Equal("value", property.Value.GetString());
}
// Verifying test data.
else
{
DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
Assert.Equal("key", entry.Key);
if (entry.Value is JsonElement element)
{
Assert.Equal("value", element.GetString());
}
else
{
Assert.Equal("value", entry.Value);
}
}
}
Assert.Equal("value", MyStringToStringGenericDict["key"]);
Assert.Equal("value", MyStringToStringGenericIDict["key"]);
Assert.Equal("value", MyStringToStringGenericIReadOnlyDict["key"]);
Assert.Equal("value", MyStringToStringImmutableDict["key"]);
Assert.Equal("value", MyStringToStringIImmutableDict["key"]);
Assert.Equal("value", MyStringToStringImmutableSortedDict["key"]);
Assert.Equal("myKey", MyStringToStringKeyValuePair.Key);
Assert.Equal("myValue", MyStringToStringKeyValuePair.Value);
Assert.Equal(2, MyStringStackT.Count);
Assert.True(MyStringStackT.Contains("Hello"));
Assert.True(MyStringStackT.Contains("World"));
string[] expectedQueue = { "Hello", "World" };
int i = 0;
foreach (string item in MyStringQueueT)
{
Assert.Equal(expectedQueue[i], item);
i++;
}
Assert.Equal("Hello", MyStringHashSetT.First());
Assert.Equal("Hello", MyStringLinkedListT.First());
Assert.Equal("Hello", MyStringSortedSetT.First());
Assert.Equal("Hello", MyStringIImmutableListT[0]);
Assert.Equal("Hello", MyStringIImmutableStackT.First());
Assert.Equal("Hello", MyStringIImmutableQueueT.First());
Assert.Equal("Hello", MyStringIImmutableSetT.First());
Assert.Equal("Hello", MyStringImmutableHashSetT.First());
Assert.Equal("Hello", MyStringImmutableListT[0]);
Assert.Equal("Hello", MyStringImmutableStackT.First());
Assert.Equal("Hello", MyStringImmutablQueueT.First());
Assert.Equal("Hello", MyStringImmutableSortedSetT.First());
Assert.Null(MyListOfNullString[0]);
}
