public AuctionItemActor(
ActorHost actorHost,
IClaptrapActorCommonService claptrapActorCommonService,
IClock clock) : base(actorHost, claptrapActorCommonService)
{
_clock = clock;
}
public void ExceptionMessage_HasDomainSet()
{
var kinoDomain = Guid.NewGuid().ToString();
securityProvider.Setup(m => m.GetDomain(KinoMessages.Exception.Identity)).Returns(kinoDomain);
try
{
actorHost = new ActorHost(actorHandlersMap,
new AsyncQueue <AsyncMessageContext>(),
new AsyncQueue <ActorRegistration>(),
securityProvider.Object,
localRouterSocket.Object,
internalRegistrationSender.Object,
localSocketFactory.Object,
logger.Object);
actorHost.AssignActor(new ExceptionActor());
var messageIn = Message.CreateFlowStartMessage(new SimpleMessage());
receivingSocket.SetupMessageReceived(messageIn);
//
StartActorHost(actorHost);
//
Func <Message, bool> assertCallbackPropertiesCopied = messageOut => messageOut.Equals(KinoMessages.Exception) &&
messageOut.Domain == kinoDomain;
localRouterSocket.WaitUntilMessageSent(assertCallbackPropertiesCopied);
}
finally
{
actorHost.Stop();
}
}
/// <summary>
/// On my test code I want to pass the mock statemanager all the time.
/// </summary>
/// <param name="actorStateManager">Mock StateManager.</param>
/// <returns>TestActor.</returns>
private TestActor CreateTestDemoActor(IActorStateManager actorStateManager)
{
var host = ActorHost.CreateForTest <TestActor>();
var testActor = new TestActor(host, actorStateManager);
return(testActor);
}
public SeatUpdateCountMinionActor(ActorHost actorHost,
IClaptrapActorCommonService claptrapActorCommonService,
IEventSerializer <EventJsonModel> eventSerializer) :
base(actorHost, claptrapActorCommonService)
{
_eventSerializer = eventSerializer;
}
protected ClaptrapBoxActor(ActorHost actorHost,
IClaptrapActorCommonService claptrapActorCommonService)
: base(actorHost)
{
_actorHost = actorHost;
ClaptrapActorCommonService = claptrapActorCommonService;
}
public async Task ActorMultipleTest()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key1 = new ActorKey("Cache/Test1");
ICache cache1 = actorHost.GetActor <ICache>(key1);
count.Should().Be(1);
ActorKey key2 = new ActorKey("Cache/Test2");
ICache cache2 = actorHost.GetActor <ICache>(key2);
count.Should().Be(2);
(await actorHost.Deactivate <ICache>(key1)).Should().BeTrue();
count.Should().Be(1);
(await actorHost.Deactivate <ICache>(key2)).Should().BeTrue();
count.Should().Be(0);
await actorHost.DeactivateAll();
}
public async Task ActorMethodTest()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key1 = new ActorKey("Cache/Test1");
ICache cache1 = actorHost.GetActor <ICache>(key1);
count.Should().Be(1);
const string firstText = "first";
bool test = await cache1.IsCached(firstText);
test.Should().BeFalse();
await cache1.Add(firstText);
test = await cache1.IsCached(firstText);
test.Should().BeTrue();
(await actorHost.Deactivate <ICache>(key1)).Should().BeTrue();;
count.Should().Be(0);
await actorHost.DeactivateAll();
}
public DemoActor(ActorHost host, BankService bank)
: base(host)
{
// BankService is provided by dependency injection.
// See Program.cs
this.bank = bank;
}
public GameEvent(ActorHost host)
: base(host)
{
_gameId = host.Id.GetId();
_homeScore = 0;
_visitorScore = 0;
}
public TestActor(ActorHost host, IActorStateManager stateManager = null)
: base(host)
{
if (stateManager != null)
{
this.StateManager = stateManager;
}
}
public OrderingProcessActor(ActorHost host, IEventBus eventBus, IOptions <OrderingSettings> settings,
ILogger <OrderingProcessActor> logger)
: base(host)
{
_eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public AccountBalanceBalanceMinion(
ActorHost actorHost,
IClaptrapActorCommonService claptrapActorCommonService,
ILogger <AccountBalanceBalanceMinion> logger) :
base(actorHost, claptrapActorCommonService)
{
_logger = logger;
}
public TranscriptionActor(ActorHost host, ILogger <TranslationOnProcessing> logger, IConfiguration configuration, DaprClient Client, AzureCognitiveServicesClient CogsClient, WebPubSubServiceClient ServiceClient)
: base(host)
{
_client = Client;
_logger = logger;
_configuration = configuration;
_cogsClient = CogsClient;
_serviceClient = new TraduireNotificationService(ServiceClient);
}
/// <summary>
/// On my test code I want to pass the mock statemanager all the time.
/// </summary>
/// <param name="actorStateManager">Mock StateManager.</param>
/// <returns>TestActor.</returns>
private TestActor CreateTestDemoActor(IActorStateManager actorStateManager)
{
var actorTypeInformation = ActorTypeInformation.Get(typeof(TestActor));
var loggerFactory = new LoggerFactory();
var host = new ActorHost(actorTypeInformation, ActorId.CreateRandom(), JsonSerializerDefaults.Web, loggerFactory, ActorProxy.DefaultProxyFactory, new DaprHttpInteractor());
var testActor = new TestActor(host, actorStateManager);
return(testActor);
}
public OrderingProcessActor(
ActorHost host,
IEventBus eventBus,
IOptions <OrderingSettings> settings)
: base(host)
{
_eventBus = eventBus;
_settings = settings;
}
/// <summary>
/// On my test code I want to pass the mock statemanager all the time.
/// </summary>
/// <param name="actorStateManager">Mock StateManager.</param>
/// <returns>TestActor.</returns>
private TestActor CreateTestDemoActor(IActorStateManager actorStateManager)
{
var actorTypeInformation = ActorTypeInformation.Get(typeof(TestActor));
var loggerFactory = new LoggerFactory();
var host = new ActorHost(actorTypeInformation, ActorId.CreateRandom(), loggerFactory);
var testActor = new TestActor(host, actorStateManager);
return(testActor);
}
/// <summary>
/// Initializes a new instance of DeviceActor
/// </summary>
public DeviceActor(ActorHost actorHost, MessageProcessor messageProcessor, ISecretProvider secretProvider)
: base(actorHost)
{
Guard.NotNull(messageProcessor, nameof(messageProcessor));
Guard.NotNull(secretProvider, nameof(secretProvider));
_secretProvider = secretProvider;
_messageProcessor = messageProcessor;
}
public AccountBalanceBalanceMinion(
ActorHost actorHost,
IClaptrapActorCommonService claptrapActorCommonService,
ILogger <AccountBalanceBalanceMinion> logger,
IEventSerializer <EventJsonModel> eventSerializer) :
base(actorHost, claptrapActorCommonService)
{
_logger = logger;
_eventSerializer = eventSerializer;
}
public async Task Given2Actors_WhenCreatedAndDeletedDifferentTask_ShouldPass()
{
int count = 0;
int count2 = 0;
const int max = 10;
const int maxLoop = 10;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => CountControl(ref count, y)))
.Register <ICache2>(() => new StringCache2(y => CountControl(ref count2, y)));
for (int loop = 0; loop < maxLoop; loop++)
{
_output.WriteLine($"Loop: {loop}");
await Enumerable.Range(0, max)
.Select(x => new Task[]
{
Task.Run(() => {
ActorKey key = new ActorKey($"cache/test/{x}");
ICache cache = actorHost.GetActor <ICache>(key);
cache.GetActorKey().Should().Be(key);
cache.GetActorHost().Should().Be(actorHost);
}),
Task.Run(() => {
ActorKey key2 = new ActorKey($"cache/test/{x}");
ICache2 cache2 = actorHost.GetActor <ICache2>(key2);
cache2.GetActorKey().Should().Be(key2);
cache2.GetActorHost().Should().Be(actorHost);
}),
})
.SelectMany(x => x)
.WhenAll();
count.Should().Be(max);
count2.Should().Be(max);
await Enumerable.Range(0, max)
.Select(x => new Task <bool>[]
{
Task.Run(async() => await actorHost.Deactivate <ICache>(new ActorKey($"cache/test/{x}"))),
Task.Run(async() => await actorHost.Deactivate <ICache2>(new ActorKey($"cache/test/{x}"))),
})
.SelectMany(x => x)
.WhenAll();
count.Should().Be(0);
count2.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
count2.Should().Be(0);
}
}
public override void Initialize()
{
World = new World();
var p = Load();
Player = World.InjectPlayer(p);
Player.Initialize();
base.Initialize();
}
public SampleActor(ActorHost host
, IRemindableWrapper remindableWrapper = null
, IActorStateManager actorStateManager = null
)
: base(host)
{
this.configSetting1 = "configSetting1";
this.configSetting2 = "configSetting2";
this.remindableWrapper = remindableWrapper ?? new RemindableWrapper(RegisterReminderAsync);
this.actorStateManager = actorStateManager ?? this.StateManager;
}
public void RemovePlayer(ActorHost host)
{
if (Simulation == null)
{
throw new NotSupportedException();
}
if (Simulation.State != SimulationState.Running && Simulation.State != SimulationState.Paused)
{
throw new NotSupportedException();
}
Simulation.RemovePlayer(host);
}
/// <summary>
/// Create transparent proxy for instance of actor class
/// </summary>
/// <param name="context">work context</param>
/// <param name="instance">instance of actor class</param>
/// <param name="manager">actor manager</param>
/// <returns>proxy</returns>
public static T Create(IActorBase instance, ActorHost actorHost)
{
instance.VerifyNotNull(nameof(instance));
actorHost.VerifyNotNull(nameof(actorHost));
object proxyObject = Create <T, ActorProxy <T> >();
ActorProxy <T> proxy = (ActorProxy <T>)proxyObject;
proxy._instance = instance;
proxy._actorHost = actorHost;
return((T)proxyObject);
}
public async Task CanTestStartingAndStoppinReminder()
{
var reminders = new List <ActorReminder>();
var timerManager = new Mock <ActorTimerManager>(MockBehavior.Strict);
timerManager
.Setup(tm => tm.RegisterReminderAsync(It.IsAny <ActorReminder>()))
.Callback <ActorReminder>(reminder => reminders.Add(reminder))
.Returns(Task.CompletedTask);
timerManager
.Setup(tm => tm.UnregisterReminderAsync(It.IsAny <ActorReminderToken>()))
.Callback <ActorReminderToken>(reminder => reminders.RemoveAll(t => t.Name == reminder.Name))
.Returns(Task.CompletedTask);
var host = ActorHost.CreateForTest <CoolTestActor>(new ActorTestOptions()
{
TimerManager = timerManager.Object,
});
var actor = new CoolTestActor(host);
// Start the reminder
var message = new Message()
{
Text = "Remind me to tape the hockey game tonite.",
};
await actor.StartReminderAsync(message);
var reminder = Assert.Single(reminders);
Assert.Equal("record", reminder.Name);
Assert.Equal(TimeSpan.FromSeconds(5), reminder.Period);
Assert.Equal(TimeSpan.Zero, reminder.DueTime);
var state = JsonSerializer.Deserialize <Message>(reminder.State);
Assert.Equal(message.Text, state.Text);
// Simulate invoking the reminder interface
for (var i = 0; i < 10; i++)
{
await actor.ReceiveReminderAsync(reminder.Name, reminder.State, reminder.DueTime, reminder.Period);
}
// Stop the reminder
await actor.StopReminderAsync();
Assert.Empty(reminders);
}
public async Task GivenActor_WhenDeactivatedAll_ActorCountShouldBeZero()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key = new ActorKey("cache/test");
ICache cache = actorHost.GetActor <ICache>(key);
count.Should().Be(1);
await actorHost.DeactivateAll();
count.Should().Be(0);
}
/// <summary>
/// Initializes a new instance of the <see cref="HashTagActor"/> class.
/// </summary>
/// <param name="host">Actor Service hosting the actor.</param>
public HashTagActor(ActorHost host)
: base(host)
{
// TODO: ActorHost may need to have IHostBuilder reference to allow user to interact web host.
// For example, getting logger factory given by WebHost
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddConsole();
});
this.logger = loggerFactory.CreateLogger <HashTagActor>();
}
public static IServiceCollection AddPathServiceActorHost(this IServiceCollection services, int capacity = 10000)
{
services.VerifyNotNull(nameof(services));
services.AddSingleton <IActorHost>(x =>
{
ILoggerFactory loggerFactory = x.GetRequiredService <ILoggerFactory>();
IActorHost host = new ActorHost(capacity, loggerFactory);
host.AddPathServiceActors(x);
return(host);
});
return(services);
}
public override void Initialize()
{
World = new World();
var p = Load();
//foreach (var item in ItemDefinitionManager.GetBlockDefinitions())
//{
// p.Inventory.Add(new InventorySlot() { Definition = item, Amount = 1 });
//}
Player = World.InjectPlayer(p);
Player.Initialize();
base.Initialize();
}
public async Task Given2Actors_WhenCreatedAndDeletedDifferentKeyRange_ShouldPass()
{
int count = 0;
int count2 = 0;
const int max = 1000;
const int maxLoop = 10;
using IActorHost actorHost = new ActorHost(100000, _loggerFactory)
.Register <ICache>(() => new StringCache(y => CountControl(ref count, y)))
.Register <ICache2>(() => new StringCache2(y => CountControl(ref count2, y)));
for (int loop = 0; loop < maxLoop; loop++)
{
_output.WriteLine($"Loop: {loop}");
await Enumerable.Range(0, max)
.Select((x, i) => new Task[]
{
Task.Run(() => actorHost.GetActor <ICache>(new ActorKey($"cache/test/{i}"))),
Task.Run(() => actorHost.GetActor <ICache2>(new ActorKey($"cache/test/{i+100}"))),
})
.SelectMany(x => x)
.WhenAll();
count.Should().Be(max);
count2.Should().Be(max);
var results = await Enumerable.Range(0, max)
.Select((x, i) => new Task <bool>[]
{
Task.Run(async() => await actorHost.Deactivate <ICache>(new ActorKey($"cache/test/{i}"))),
Task.Run(async() => await actorHost.Deactivate <ICache2>(new ActorKey($"cache/test/{i+100}"))),
})
.SelectMany(x => x)
.WhenAll();
results.All(x => x == true).Should().BeTrue();
count.Should().Be(0);
count2.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
count2.Should().Be(0);
}
}
public async Task ActorCodeBuilder_BuildDispatcher()
{
var host = ActorHost.CreateForTest <TestActor>();
var dispatcher = ActorCodeBuilder.GetOrCreateMethodDispatcher(typeof(ITestActor));
var methodId = MethodDescription.Create("test", typeof(ITestActor).GetMethod("GetCountAsync"), true).Id;
var impl = new TestActor(host);
var request = new ActorRequestMessageBody(0);
var response = new WrappedRequestMessageFactory();
var body = (WrappedMessage)await dispatcher.DispatchAsync(impl, methodId, request, response, default);
dynamic bodyValue = body.Value;
Assert.Equal(5, (int)bodyValue.retVal);
}
