public static ActivationAddress ToActivationAddress(this GrainAddress addr) { return(ActivationAddress.GetAddress( SiloAddress.FromParsableString(addr.SiloAddress), LegacyGrainId.FromParsableString(addr.GrainId), ActivationId.GetActivationId(UniqueKey.Parse(addr.ActivationId.AsSpan())))); }
public async Task PersistenceProvider_Azure_ChangeWriteFormat(int?stringLength, bool useJsonForFirstWrite, bool useJsonForSecondWrite) { var testName = string.Format("{0}({1}={2},{3}={4},{5}={6})", nameof(PersistenceProvider_Azure_ChangeWriteFormat), nameof(stringLength), stringLength == null ? "default" : stringLength.ToString(), "json1stW", useJsonForFirstWrite, "json2ndW", useJsonForSecondWrite); var grainState = TestStoreGrainState.NewRandomState(stringLength); EnsureEnvironmentSupportsState(grainState); var grainId = LegacyGrainId.NewId(); var store = await InitAzureTableGrainStorage(useJsonForFirstWrite); await Test_PersistenceProvider_WriteRead(testName, store, grainState, grainId); grainState = TestStoreGrainState.NewRandomState(stringLength); grainState.ETag = "*"; store = await InitAzureTableGrainStorage(useJsonForSecondWrite); await Test_PersistenceProvider_WriteRead(testName, store, grainState, grainId); }
private GrainId RoundTripGrainIdToParsable(GrainId input) { string str = ((LegacyGrainId)input).ToParsableString(); GrainId output = LegacyGrainId.FromParsableString(str); return(output); }
public void GrainID_AsGuid() { string guidString = "0699605f-884d-4343-9977-f40a39ab7b2b"; Guid grainIdGuid = Guid.Parse(guidString); GrainId grainId = LegacyGrainId.GetGrainIdForTesting(grainIdGuid); //string grainIdToKeyString = grainId.ToKeyString(); string grainIdToFullString = ((LegacyGrainId)grainId).ToFullString(); string grainIdToGuidString = GrainIdToGuidString(grainId); string grainIdKeyString = grainId.Key.ToString(); output.WriteLine("Guid={0}", grainIdGuid); output.WriteLine("GrainId={0}", grainId); //output.WriteLine("GrainId.ToKeyString={0}", grainIdToKeyString); output.WriteLine("GrainId.Key.ToString={0}", grainIdKeyString); output.WriteLine("GrainIdToGuidString={0}", grainIdToGuidString); output.WriteLine("GrainId.ToFullString={0}", grainIdToFullString); // Equal: Public APIs //Assert.Equal(guidString, grainIdToKeyString); // GrainId.ToKeyString Assert.Equal(guidString, grainIdToGuidString); // GrainIdToGuidString // Equal: Internal APIs Assert.Equal(grainIdGuid, ((LegacyGrainId)grainId).GetPrimaryKey()); // GetPrimaryKey Guid // NOT-Equal: Internal APIs Assert.NotEqual(guidString, grainIdKeyString); // GrainId.Key.ToString }
private GrainReference MakeTestGrainReference() { GrainId regularGrainId = LegacyGrainId.GetGrainId(12345, Guid.NewGuid(), "foo/bar\\#baz?"); GrainReference grainRef = this.ClusterFixture.InternalGrainFactory.GetGrain(regularGrainId); return(grainRef); }
public void GrainState_Store_WriteRead() { string name = Guid.NewGuid().ToString();//TestContext.TestName; ILocalDataStore store = new HierarchicalKeyStore(2); GrainReference reference = this.fixture.InternalGrainFactory.GetGrain(LegacyGrainId.NewId()); var grainState = TestStoreGrainState.NewRandomState(); var state = grainState.State; Stopwatch sw = new Stopwatch(); sw.Start(); IList <Tuple <string, string> > keys = new[] { Tuple.Create("GrainType", name), Tuple.Create("GrainId", reference.GrainId.ToString()) }.ToList(); store.WriteRow(keys, AsDictionary(state), grainState.ETag); TimeSpan writeTime = sw.Elapsed; sw.Restart(); var data = store.ReadRow(keys); TimeSpan readTime = sw.Elapsed; output.WriteLine("{0} - Write time = {1} Read time = {2}", store.GetType().FullName, writeTime, readTime); Assert.Equal(state.A, data["A"]); // "A" Assert.Equal(state.B, data["B"]); // "B" Assert.Equal(state.C, data["C"]); // "C" }
public void Store_WriteRead() { string name = Guid.NewGuid().ToString();//TestContext.TestName; ILocalDataStore store = new HierarchicalKeyStore(2); GrainReference reference = fixture.InternalGrainFactory.GetGrain(LegacyGrainId.NewId()); var state = TestStoreGrainState.NewRandomState(); Stopwatch sw = new Stopwatch(); sw.Start(); var keys = GetKeys(name, reference); var stateProperties = AsDictionary(state.State); store.WriteRow(keys, stateProperties, state.ETag); TimeSpan writeTime = sw.Elapsed; sw.Restart(); var data = store.ReadRow(keys); TimeSpan readTime = sw.Elapsed; output.WriteLine("{0} - Write time = {1} Read time = {2}", store.GetType().FullName, writeTime, readTime); Assert.Equal(state.State.A, data["A"]); // "A" Assert.Equal(state.State.B, data["B"]); // "B" Assert.Equal(state.State.C, data["C"]); // "C" }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JObject jo = JObject.Load(reader); GrainId grainId = LegacyGrainId.FromParsableString(jo["GrainId"].ToObject <string>()); return(grainId); }
public async Task PersistenceProvider_Memory_FixedLatency_WriteRead() { const string testName = nameof(PersistenceProvider_Memory_FixedLatency_WriteRead); TimeSpan expectedLatency = TimeSpan.FromMilliseconds(200); MemoryGrainStorageWithLatency store = new MemoryGrainStorageWithLatency(testName, new MemoryStorageWithLatencyOptions() { Latency = expectedLatency, MockCallsOnly = true }, NullLoggerFactory.Instance, this.providerRuntime.ServiceProvider.GetService <IGrainFactory>()); GrainReference reference = this.fixture.InternalGrainFactory.GetGrain(LegacyGrainId.NewId()); var state = TestStoreGrainState.NewRandomState(); Stopwatch sw = new Stopwatch(); sw.Start(); await store.WriteStateAsync(testName, reference, state); TimeSpan writeTime = sw.Elapsed; this.output.WriteLine("{0} - Write time = {1}", store.GetType().FullName, writeTime); Assert.True(writeTime >= expectedLatency, $"Write: Expected minimum latency = {expectedLatency} Actual = {writeTime}"); sw.Restart(); var storedState = new GrainState <TestStoreGrainState>(); await store.ReadStateAsync(testName, reference, storedState); TimeSpan readTime = sw.Elapsed; this.output.WriteLine("{0} - Read time = {1}", store.GetType().FullName, readTime); Assert.True(readTime >= expectedLatency, $"Read: Expected minimum latency = {expectedLatency} Actual = {readTime}"); }
public OutsideRuntimeClient( ILoggerFactory loggerFactory, IOptions <ClientMessagingOptions> clientMessagingOptions, IOptions <TypeManagementOptions> typeManagementOptions, IOptions <StatisticsOptions> statisticsOptions, ApplicationRequestsStatisticsGroup appRequestStatistics, StageAnalysisStatisticsGroup schedulerStageStatistics, ClientStatisticsManager clientStatisticsManager, MessagingTrace messagingTrace) { this.loggerFactory = loggerFactory; this.statisticsOptions = statisticsOptions; this.appRequestStatistics = appRequestStatistics; this.schedulerStageStatistics = schedulerStageStatistics; this.ClientStatistics = clientStatisticsManager; this.messagingTrace = messagingTrace; this.logger = loggerFactory.CreateLogger <OutsideRuntimeClient>(); this.clientId = LegacyGrainId.NewClientId(); callbacks = new ConcurrentDictionary <CorrelationId, CallbackData>(); this.clientMessagingOptions = clientMessagingOptions.Value; this.typeMapRefreshInterval = typeManagementOptions.Value.TypeMapRefreshInterval; this.sharedCallbackData = new SharedCallbackData( msg => this.UnregisterCallback(msg.Id), this.loggerFactory.CreateLogger <CallbackData>(), this.clientMessagingOptions, this.appRequestStatistics, this.clientMessagingOptions.ResponseTimeout); }
private ActivationAddress GenerateActivationAddress() { var grainId = LegacyGrainId.GetGrainIdForTesting(Guid.NewGuid()); var siloAddr = SiloAddress.New(new IPEndPoint(IPAddress.Loopback, 5000), ++generation); return(ActivationAddress.NewActivationAddress(siloAddr, grainId)); }
public bool TryGetGrainType(Type grainClass, out GrainType grainType) { if (!LegacyGrainId.IsLegacyGrainType(grainClass)) { grainType = default; return(false); } Type canonicalGrainClass; if (grainClass.IsConstructedGenericType) { canonicalGrainClass = grainClass.GetGenericTypeDefinition(); } else { canonicalGrainClass = grainClass; } var isKeyExt = LegacyGrainId.IsLegacyKeyExtGrainType(canonicalGrainClass); var typeCode = GrainInterfaceUtils.GetGrainClassTypeCode(canonicalGrainClass); grainType = LegacyGrainId.GetGrainType(typeCode, isKeyExt); if (grainClass.IsGenericType) { grainType = GrainType.Create($"{grainType}`{canonicalGrainClass.GetGenericArguments().Length}"); } return(true); }
/// <summary> /// Create a subscriptionId that is unique per grainId, grainType, namespace combination. /// </summary> /// <param name="grainId"></param> /// <param name="streamId"></param> /// <returns></returns> private Guid MakeSubscriptionGuid(GrainId grainId, StreamId streamId) { // first int in guid is grain type code int grainIdTypeCode = LegacyGrainId.FromGrainId(grainId).TypeCode; return(MakeSubscriptionGuid(grainIdTypeCode, streamId)); }
public async Task <IPersistentStreamPullingManager> InitializePullingAgents( string streamProviderName, IQueueAdapterFactory adapterFactory, IQueueAdapter queueAdapter) { IStreamQueueBalancer queueBalancer = CreateQueueBalancer(streamProviderName); var managerId = LegacyGrainId.NewSystemTargetGrainIdByTypeCode(Constants.PULLING_AGENTS_MANAGER_SYSTEM_TARGET_TYPE_CODE); var pubsubOptions = this.ServiceProvider.GetOptionsByName <StreamPubSubOptions>(streamProviderName); var pullingAgentOptions = this.ServiceProvider.GetOptionsByName <StreamPullingAgentOptions>(streamProviderName); var manager = new PersistentStreamPullingManager( managerId, streamProviderName, this, this.PubSub(pubsubOptions.PubSubType), adapterFactory, queueBalancer, pullingAgentOptions, this.loggerFactory, this.siloDetails.SiloAddress); this.RegisterSystemTarget(manager); // Init the manager only after it was registered locally. var pullingAgentManager = manager.AsReference <IPersistentStreamPullingManager>(); // Need to call it as a grain reference though. await pullingAgentManager.Initialize(queueAdapter.AsImmutable()); return(pullingAgentManager); }
/// <inheritdoc /> public TGrainInterface GetGrain <TGrainInterface>(long primaryKey, string grainClassNamePrefix = null) where TGrainInterface : IGrainWithIntegerKey { Type interfaceType = typeof(TGrainInterface); var implementation = this.GetGrainClassData(interfaceType, grainClassNamePrefix); var grainId = LegacyGrainId.GetGrainId(implementation.GetTypeCode(interfaceType), primaryKey, null); return(this.Cast <TGrainInterface>(this.MakeGrainReferenceFromType(interfaceType, grainId.ToGrainId()))); }
/// <summary> /// Take responsibility for a set of new queues that were assigned to me via a new range. /// We first create one pulling agent for every new queue and store them in our internal data structure, then try to initialize the agents. /// ERROR HANDLING: /// The responsibility to handle initialization and shutdown failures is inside the Agents code. /// The manager will call Initialize once and log an error. It will not call initialize again and will assume initialization has succeeded. /// Same applies to shutdown. /// </summary> /// <param name="myQueues"></param> /// <param name="failOnInit"></param> /// <returns></returns> private async Task AddNewQueues(IEnumerable <QueueId> myQueues, bool failOnInit) { // Create agents for queues in range that we don't yet have. // First create them and store in local queuesToAgentsMap. // Only after that Initialize them all. var agents = new List <PersistentStreamPullingAgent>(); foreach (var queueId in myQueues) { if (queuesToAgentsMap.ContainsKey(queueId)) { continue; } try { var agentId = LegacyGrainId.NewSystemTargetGrainIdByTypeCode(Constants.PULLING_AGENT_SYSTEM_TARGET_TYPE_CODE); var agent = new PersistentStreamPullingAgent(agentId, streamProviderName, providerRuntime, this.loggerFactory, pubSub, queueId, this.options, this.Silo); providerRuntime.RegisterSystemTarget(agent); queuesToAgentsMap.Add(queueId, agent); agents.Add(agent); } catch (Exception exc) { logger.Error(ErrorCode.PersistentStreamPullingManager_07, "Exception while creating PersistentStreamPullingAgent.", exc); // What should we do? This error is not recoverable and considered a bug. But we don't want to bring the silo down. // If this is when silo is starting and agent is initializing, fail the silo startup. Otherwise, just swallow to limit impact on other receivers. if (failOnInit) { throw; } } } try { var initTasks = new List <Task>(); foreach (var agent in agents) { initTasks.Add(InitAgent(agent)); } await Task.WhenAll(initTasks); } catch { // Just ignore this exception and proceed as if Initialize has succeeded. // We already logged individual exceptions for individual calls to Initialize. No need to log again. } if (agents.Count > 0) { Log(ErrorCode.PersistentStreamPullingManager_08, "Added {0} new queues: {1}. Now own total of {2} queues: {3}", agents.Count, Utils.EnumerableToString(agents, agent => agent.QueueId.ToString()), NumberRunningAgents, PrintQueues(queuesToAgentsMap.Keys)); } }
/// <summary> /// Create a reference to a grain that we expect to support the stream consumer extension. /// </summary> /// <param name="grainFactory">The grain factory used to get consumer references.</param> /// <param name="streamId">The stream ID to use for the grain ID construction.</param> /// <param name="implTypeCode">The type code of the grain interface.</param> /// <returns></returns> private IStreamConsumerExtension MakeConsumerReference(IInternalGrainFactory grainFactory, StreamId streamId, int implTypeCode) { var keyExtension = grainsWithKeyExtensions.Contains(implTypeCode) ? streamId.Namespace : null; GrainId grainId = LegacyGrainId.GetGrainId(implTypeCode, streamId.Guid, keyExtension); return(grainFactory.GetGrain <IStreamConsumerExtension>(grainId)); }
public void GrainReference_Test1() { Guid guid = Guid.NewGuid(); GrainId regularGrainId = LegacyGrainId.GetGrainIdForTesting(guid); GrainReference grainRef = (GrainReference)this.environment.InternalGrainFactory.GetGrain(regularGrainId); TestGrainReference(grainRef); grainRef = (GrainReference)this.environment.InternalGrainFactory.GetGrain(regularGrainId); TestGrainReference(grainRef); }
/// <summary> /// Returns the <see langword="string"/> primary key of the grain. /// </summary> /// <param name="grain">The grain to find the primary key for.</param> /// <returns>A <see langword="string"/> representing the primary key for this grain.</returns> public static string GetPrimaryKeyString(this IAddressable grain) { var grainId = GetGrainId(grain); if (LegacyGrainId.TryConvertFromGrainId(grainId, out var legacyId)) { return(legacyId.GetPrimaryKeyString()); } return(grainId.Key.ToStringUtf8()); }
/// <inheritdoc /> public TGrainInterface GetGrain <TGrainInterface>(Guid primaryKey, string keyExtension, string grainClassNamePrefix = null) where TGrainInterface : IGrainWithGuidCompoundKey { GrainFactoryBase.DisallowNullOrWhiteSpaceKeyExtensions(keyExtension); Type interfaceType = typeof(TGrainInterface); var implementation = this.GetGrainClassData(interfaceType, grainClassNamePrefix); var grainId = LegacyGrainId.GetGrainId(implementation.GetTypeCode(interfaceType), primaryKey, keyExtension); return(this.Cast <TGrainInterface>(this.MakeGrainReferenceFromType(interfaceType, grainId.ToGrainId()))); }
public bool TryGetGrainType(Type grainClass, out GrainType grainType) { if (LegacyGrainId.IsLegacyGrainType(grainClass)) { grainType = LegacyGrainId.GetGrainId(GrainInterfaceUtils.GetGrainClassTypeCode(grainClass), Guid.Empty).ToGrainId().Type; return(true); } grainType = default; return(false); }
public void GrainIdShouldEncodeAndDecodePrimaryKeyGuidCorrectly() { const int repeat = 100; for (int i = 0; i < repeat; ++i) { Guid expected = Guid.NewGuid(); GrainId grainId = LegacyGrainId.GetGrainIdForTesting(expected); Guid actual = ((LegacyGrainId)grainId).Key.PrimaryKeyToGuid(); Assert.Equal(expected, actual); // Failed to encode and decode grain id } }
public void Serialize_GrainReference() { GrainId grainId = LegacyGrainId.NewId(); GrainReference input = (GrainReference)environment.InternalGrainFactory.GetGrain(grainId); object deserialized = OrleansSerializationLoop(environment.Serializer, environment.DeepCopier, input); var grainRef = Assert.IsAssignableFrom <GrainReference>(deserialized); //GrainReference copied as wrong type Assert.Equal(grainId, grainRef.GrainId); //GrainId different after copy Assert.Equal(input, grainRef); //Wrong contents after round-trip of input }
private ReminderEntry NewReminderEntry() { Guid guid = Guid.NewGuid(); return(new ReminderEntry { GrainRef = this.fixture.InternalGrainFactory.GetGrain(LegacyGrainId.NewId()), ReminderName = string.Format("TestReminder.{0}", guid), Period = TimeSpan.FromSeconds(5), StartAt = DateTime.UtcNow }); }
public void CodeGen_GrainId_TypeCode() { var g1Key = GetRandomGrainId(); ITestGrain g1 = this.GrainFactory.GetGrain <ITestGrain>(g1Key); LegacyGrainId id1 = ((GrainReference)g1).GrainId; var k1 = id1.Key; Assert.True(id1.IsGrain, "GrainReference should be for a grain"); Assert.Equal(UniqueKey.Category.Grain, k1.IdCategory); // "GrainId should be for self-managed type" Assert.Equal(g1Key, k1.PrimaryKeyToLong()); // "Encoded primary key should match" Assert.Equal(1146670029, k1.BaseTypeCode); // "Encoded type code data should match" }
public void CollectionTest_GrainId_TypeCode() { var g1Key = GetRandomGrainId(); ICollectionTestGrain g1 = this.GrainFactory.GetGrain <ICollectionTestGrain>(g1Key); LegacyGrainId id1 = ((GrainReference)g1).GrainId; UniqueKey k1 = id1.Key; output.WriteLine("GrainId={0} UniqueKey={1} PK={2} KeyType={3} IdCategory={4}", id1, k1, id1.GetPrimaryKeyLong(), k1.IdCategory, k1.BaseTypeCode); Assert.True(id1.IsGrain, "GrainReference should be for a grain"); Assert.Equal(UniqueKey.Category.Grain, k1.IdCategory); // "GrainId should be for self-managed type" Assert.Equal(g1Key, k1.PrimaryKeyToLong()); // "Encoded primary key should match" Assert.Equal(1381240679, k1.BaseTypeCode); // "Encoded type code data should match" }
public void ID_Interning_GrainID() { Guid guid = new Guid(); GrainId gid1 = LegacyGrainId.FromParsableString(guid.ToString("B")); GrainId gid2 = LegacyGrainId.FromParsableString(guid.ToString("N")); Assert.Equal(gid1, gid2); // Should be equal GrainId's // Round-trip through Serializer GrainId gid3 = this.environment.Serializer.Deserialize <GrainId>(environment.Serializer.SerializeToArray(gid1)); Assert.Equal(gid1, gid3); // Should be equal GrainId's Assert.Equal(gid2, gid3); // Should be equal GrainId's }
public void ID_Interning_GrainID() { Guid guid = new Guid(); GrainId gid1 = LegacyGrainId.FromParsableString(guid.ToString("B")); GrainId gid2 = LegacyGrainId.FromParsableString(guid.ToString("N")); Assert.Equal(gid1, gid2); // Should be equal GrainId's // Round-trip through Serializer GrainId gid3 = (GrainId)this.environment.SerializationManager.RoundTripSerializationForTesting(gid1); Assert.Equal(gid1, gid3); // Should be equal GrainId's Assert.Equal(gid2, gid3); // Should be equal GrainId's }
private static IGrainService GrainServiceFactory(Type serviceType, IServiceProvider services) { var grainServiceInterfaceType = serviceType.GetInterfaces().FirstOrDefault(x => x.GetInterfaces().Contains(typeof(IGrainService))); if (grainServiceInterfaceType == null) { throw new InvalidOperationException(String.Format($"Cannot find an interface on {serviceType.FullName} which implements IGrainService")); } var typeCode = GrainInterfaceUtils.GetGrainClassTypeCode(grainServiceInterfaceType); var grainId = (GrainId)LegacyGrainId.GetGrainServiceGrainId(0, typeCode); var grainService = (GrainService)ActivatorUtilities.CreateInstance(services, serviceType, grainId); return(grainService); }
private void RunTest(int numItems) { InvokeMethodRequest request = new InvokeMethodRequest(0, 2, 0, null); Message resp = this.messageFactory.CreateMessage(request, InvokeMethodOptions.None); resp.Id = new CorrelationId(); resp.SendingSilo = SiloAddress.New(new IPEndPoint(IPAddress.Loopback, 200), 0); resp.TargetSilo = SiloAddress.New(new IPEndPoint(IPAddress.Loopback, 300), 0); resp.SendingGrain = LegacyGrainId.NewId(); resp.TargetGrain = LegacyGrainId.NewId(); resp.IsAlwaysInterleave = true; Assert.True(resp.IsUsingInterfaceVersions); List <object> requestBody = new List <object>(); for (int k = 0; k < numItems; k++) { requestBody.Add(k + ": test line"); } resp.BodyObject = requestBody; string s = resp.ToString(); output.WriteLine(s); var resp1 = RoundTripMessage(resp); //byte[] serialized = resp.FormatForSending(); //Message resp1 = new Message(serialized, serialized.Length); Assert.Equal(resp.Category, resp1.Category); //Category is incorrect" Assert.Equal(resp.Direction, resp1.Direction); //Direction is incorrect Assert.Equal(resp.Id, resp1.Id); //Correlation ID is incorrect Assert.Equal(resp.IsAlwaysInterleave, resp1.IsAlwaysInterleave); //Foo Boolean is incorrect Assert.Equal(resp.CacheInvalidationHeader, resp1.CacheInvalidationHeader); //Bar string is incorrect Assert.True(resp.TargetSilo.Equals(resp1.TargetSilo)); Assert.True(resp.TargetGrain.Equals(resp1.TargetGrain)); Assert.True(resp.SendingGrain.Equals(resp1.SendingGrain)); Assert.True(resp.SendingSilo.Equals(resp1.SendingSilo)); //SendingSilo is incorrect Assert.True(resp1.IsUsingInterfaceVersions); List <object> responseList = Assert.IsAssignableFrom <List <object> >(resp1.BodyObject); Assert.Equal <int>(numItems, responseList.Count); //Body list has wrong number of entries for (int k = 0; k < numItems; k++) { Assert.IsAssignableFrom <string>(responseList[k]); //Body list item " + k + " has wrong type Assert.Equal((string)(requestBody[k]), (string)(responseList[k])); //Body list item " + k + " is incorrect } }