private static void CreateActorSystem()
{
ActorSystem = ActorSystem.Create("FeatureAdminActorSystem",
@"akka {
stdout - loglevel = WARNING
loglevel = WARNING
log - config - on - start = on
actor {
debug {
receive = on
autoreceive = on
lifecycle = on
event-stream = on
unhandled = on
}
}"
);
//// Setup Autofac
ContainerBuilder builder = new ContainerBuilder();
#if (SP2013)
builder.RegisterType <Backends.Sp2013.Services.SpDataService>().As <IDataService>().SingleInstance();
#else
builder.RegisterType <Backends.Demo.Services.DemoDataService>().As <IDataService>().SingleInstance();
#endif
builder.RegisterType <Actors.LocationActor>();
builder.RegisterType <Actors.FeatureDefinitionActor>();
IContainer container = builder.Build();
var propsResolver = new AutoFacDependencyResolver(container, ActorSystem);
}
public static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterType<SampleUserService>().As<IUserService>();
builder.RegisterType<SampleStationService>().As<IStationService>();
builder.RegisterType<UserActor>();
builder.RegisterType<StationCoordinatorActor>();
builder.RegisterType<StationActor>();
Container = builder.Build();
var system = ActorSystem.Create("UserActorSystem");
// Create the dependency resolver for the actor system
var propsResolver = new AutoFacDependencyResolver(Container, system);
IActorRef jayActor = system.ActorOf(system.DI().Props<UserActor>(), "Jay");
jayActor.Tell(new User() { Id = 5, Name = "Jay" });
IActorRef stationCoordinatorActor = system.ActorOf(system.DI().Props<StationCoordinatorActor>(), "StationCoordinatorActor");
jayActor.Tell(new SendPerformedMessage(699));
Console.Read();
jayActor.Tell(new SendPerformedMessage(700));
Console.Read();
system.Shutdown();
system.AwaitTermination();
Console.WriteLine("Shutdown");
Console.Read();
}
public bool Start(HostControl hostControl)
{
// Akka
_actorSystem = ActorSystem.Create("Euricom-Cruise2018-Demo", ConfigurationHelper.GetAkkaConfigurationSettings());
// Autofac
_bootStrapper = BootStrapper.Instance;
_bootStrapper.ConfigureContainer(_actorSystem);
var dependencyResolver = new AutoFacDependencyResolver(_bootStrapper.Container, _actorSystem);
// Akka Infrastructure
var deadLetterLogger = _actorSystem.ActorOf(Props.Create <DeadLetterLogger>(), "deadLetterLogger");
var addressBook = _actorSystem.ActorOf(Props.Create(() => new AddressBook(null)), AddressBook.Name);
Domain.DomainExtensionProvider.Instance.Apply(_actorSystem);
Projections.ProjectionExtensionProvider.Instance.Apply(_actorSystem);
System.Threading.Thread.Sleep(5000);
// Service bus
_serviceBus = _bootStrapper.Container.Resolve <IBusControl>();
_serviceBus.Start();
return(true);
}
public void Correct_Message_Received_When_Using_TestChildActor_Test()
{
//Setup stuff for this testcase
Mock <ISomeService> mockSomeService = new Mock <ISomeService>();
mockSomeService.Setup(x => x.ReturnValue(It.IsAny <string>())).Returns("In a test mock");
ContainerOperations.Instance.AddExtraModulesCallBack = builder =>
{
builder.Register(x => mockSomeService.Object)
.As <ISomeService>()
.SingleInstance();
};
var system = ContainerOperations.Instance.Container.Resolve <ActorSystem>();
IDependencyResolver resolver = new AutoFacDependencyResolver(ContainerOperations.Instance.Container, system);
var mySupervisorActor = system.ActorOf(system.DI().Props <MySupervisorActor>(), "MySupervisorActor");
mySupervisorActor.Tell(new StartMessage(), TestActor);
// Assert
AwaitCondition(() => HasMessages, TimeSpan.FromSeconds(10));
var message = ExpectMsg <ChildSucceededMessage>();
Assert.AreEqual("MyChildActor", message.FromWho);
}
public static void Main(String[] args)
{
var builder = new ContainerBuilder();
builder
.RegisterType <WorldContextFactory>()
.SingleInstance();
builder.RegisterType <SessionsManagerActor>();
builder.RegisterType <WorldContextActor>();
var container = builder.Build();
ReinitializeDatabase(container.Resolve <WorldContextFactory>());
var akkaConfig = ConfigurationFactory.ParseString(File.ReadAllText(@"Properties/ServerConfig.hocon"));
using (var system = ActorSystem.Create("HabitableZoneServer", akkaConfig))
{
var propsResolver = new AutoFacDependencyResolver(container, system);
var mgr = system.ActorOf(
system.DI().Props <SessionsManagerActor>(),
"sessionsManager");
var worldContextActor = system.ActorOf(
system.DI().Props <WorldContextActor>(),
"worldContext");
Console.ReadLine();
system.Terminate();
system.WhenTerminated.Wait();
}
}
static void Main(string[] args)
{
#region DI things
var builder = new ContainerBuilder();
builder.RegisterType<NotificationAnalyzer>().As<INotificationAnalyzer>();
builder.RegisterType<PushNotificationActor>();
var container = builder.Build();
#endregion
NotificationsActorSystem = ActorSystem.Create("NotificationsActorSystem");
IDependencyResolver resolver = new AutoFacDependencyResolver(container, NotificationsActorSystem);
Props notificationActor = Props.Create<NotificationActor>();
IActorRef pushNotificationActorRef = NotificationsActorSystem.ActorOf(notificationActor, "NotificationActor");
Console.ReadKey();
Console.WriteLine("Sending notification");
pushNotificationActorRef.Tell(new NotificationMessage("*****@*****.**", "New Job"));
//This is for reaching from lower level actor to high level actor
//NotificationsActorSystem.ActorSelection("user/NotificationActor/PushNotificationActor")
// .Tell(new NotificationMessage("*****@*****.**", "New Job"));
Console.ReadKey();
NotificationsActorSystem.Terminate();
}
static void Main(string[] args)
{
LogSetup.ConfigureLogger();
var akkaConfFile = Environment.GetEnvironmentVariable("AKKA_CONF_FILENAME");
// Get actor configuration
using (var reader = new StreamReader(File.OpenRead(akkaConfFile ?? "akka.conf")))
{
var config = ConfigurationFactory.ParseString(reader.ReadToEnd());
// Join the cluster
using (var system = ActorSystem.Create("dockka-system", config))
{
var container = DependencyInjection.ConfigureDependencyInjection();
container.RegisterType <AddPersonActor>();
var propsResolver = new AutoFacDependencyResolver(container.Build(), system);
// Start the actor
system.ActorOf(system.DI().Props <AddPersonActor>(), "addPerson");
// Wait indefinitely
if (string.IsNullOrEmpty(akkaConfFile))
{
Console.ReadKey();
}
else
{
Thread.Sleep(Timeout.Infinite);
}
}
}
}
/// <inheritdoc />
public virtual IEntityActorRef <TActorType> Create(ActorCreationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
//Also on the Actor registeration we resolve the lifetimescope
//and attach it so we don't need to send a dispose message.
//Do not directly dispose this, needs to be disposed by the Actor stop.
var lifetimeScope = Container.BeginLifetimeScope();
Props props = new AutoFacDependencyResolver(lifetimeScope, System)
.Create <TActorType>();
//We cannot use type name, because it's not unique for Actor name
//I also don't have a good way to seed in unique identifiers.
//We must rely on Akka to produce a unique key.
IActorRef actorRef = context.ActorReferenceFactory.ActorOf(props);
if (actorRef.IsNobody())
{
throw new InvalidOperationException($"Failed to create Actor: {typeof(TActorType).Name}. Path: {actorRef.Path}");
}
//We adapt this to the type-containing actor type interface.
return(new EntityActorGenericAdapter <TActorType>(actorRef));
}
private static void CreateActorSystem()
{
// see also https://doc.akka.io/docs/akka/2.5/general/configuration.html#custom-application-conf
ActorSystem = ActorSystem.Create("FeatureAdminActorSystem",
@"akka {
stdout - loglevel = WARNING
loglevel = WARNING
log - config - on - start = on
actor {
debug {
receive = on
autoreceive = on
lifecycle = on
event-stream = on
unhandled = on
}
}"
);
//// Setup Autofac
ContainerBuilder builder = new ContainerBuilder();
//#if (SP2013)
// builder.RegisterType<Backends.Sp2013.Services.SpDataService>().As<IDataService>();
//#else
// builder.RegisterType<Backends.Demo.Services.DemoDataService>().As<IDataService>();
//#endif
builder.RegisterType <Actors.LocationActor>();
builder.RegisterType <Actors.FeatureDefinitionActor>();
IContainer container = builder.Build();
var propsResolver = new AutoFacDependencyResolver(container, ActorSystem);
}
public void Register(IContainer container, Action <ContainerBuilder> postBuildOperation = null, ActorSystem actorSystem = null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
ActorSystem = actorSystem ?? ActorSystem.Create(typeof(ApplicationActorSystem).Name);
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(AppDomain.CurrentDomain.GetAssemblies()).Where(t => typeof(ReceiveActor).IsAssignableFrom(t));
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var type in assembly.GetTypes().Where(type => type.IsAssignableTo <ActorBase>()))
{
if (type.IsGenericType)
{
builder.RegisterGeneric(type);
}
else
{
builder.RegisterType(type);
}
}
}
postBuildOperation?.Invoke(builder);
builder.Update(container);
IDependencyResolver resolver = new AutoFacDependencyResolver(container, ActorSystem);
}
public static ActorSystem WithContainer(this ActorSystem system, IContainer container)
{
// It's the way, how we add dependency injection ot Akka.net
// ReSharper disable once UnusedVariable
var propsResolver = new AutoFacDependencyResolver(container, system);
return(system);
}
private void ConfigureDependecies()
{
var builder = new Autofac.ContainerBuilder();
builder.RegisterType<Calculator>().As<ICalculator>().SingleInstance();
builder.RegisterType<CalculatingActor>();
var container = builder.Build();
var resolver = new AutoFacDependencyResolver(container, system);
}
public DuplicateFinder(ILifetimeScope lifetimeScope)
{
var actorSystem = ActorSystem.Create("DuplicateFinderActorSystem");
var autoFacDependencyResolver = new AutoFacDependencyResolver(lifetimeScope, actorSystem);
_duplicateFinderOrchestratorActor = actorSystem.ActorOf(actorSystem.DI().Props <DuplicateFinderOrchestratorActor>(),
nameof(DuplicateFinderOrchestratorActor));
}
static void Main(string[] args)
{
ConfigureAutofac();
ResolveLogger();
using (var system = ActorSystem.Create(SystemName))
{
Logger.WriteVerbose("Actor system created");
var resolver = new AutoFacDependencyResolver(Container, system);
system.ActorOf(resolver.Create <PlaybackActor>(), PlaybackActorName);
bool running = true;
do
{
Console.WriteLine("Enter a command and hit Enter");
Console.WriteLine("eg 'play <user id> <movie title>'");
Console.WriteLine("eg 'stop <user id>'");
Console.WriteLine("(enter 'exit' to quit)");
var command = Console.ReadLine();
if (command.StartsWith("play", StringComparison.InvariantCultureIgnoreCase))
{
var parts = command.Split(new[] { ' ' }, 3);
var userId = int.Parse(parts[1]);
var movieTitle = parts[2];
var message = new PlayMovieMessage(movieTitle, userId);
system.ActorSelection($"/user/{PlaybackActorName}/{UserCoordinatorActorName}").Tell(message);
}
if (command.StartsWith("stop", StringComparison.InvariantCultureIgnoreCase))
{
var parts = command.Split(new[] { ' ' }, 2);
var userId = int.Parse(parts[1]);
var message = new StopMovieMessage(userId);
system.ActorSelection($"/user/{PlaybackActorName}/{UserCoordinatorActorName}").Tell(message);
}
if (command.StartsWith("exit", StringComparison.InvariantCultureIgnoreCase))
{
running = false;
}
} while (running);
system.Terminate().GetAwaiter().GetResult();
Logger.WriteDebug("Actor system terminated");
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
static void Main(string[] args)
{
var system = ContainerOperations.Instance.Container.Resolve <ActorSystem>();
IDependencyResolver resolver = new AutoFacDependencyResolver(ContainerOperations.Instance.Container, system);
var myBinaryAlgorithmActor = system.ActorOf(system.DI().Props <BinaryAlgorithm>(), "Algorithm");
myBinaryAlgorithmActor.Tell(new Run <BinaryChromosome>(new AlgorithmConfig <BinaryChromosome>(2, 1, 10000, 5000, 5, new RankingSelection <BinaryChromosome>(), new BinaryCrossover(), new CrossoverConfig(80, 2))));
Console.ReadKey();
}
/// <summary>
/// Creates a new instance of the <see cref="AutoFacDependencyResolver"/> class
/// associated with the <see cref="ActorSystem"/>
/// </summary>
/// <param name="system">The actor system to plug into</param>
/// <param name="container">The container used to resolve references</param>
/// <param name="dependencyResolver">The Autofac dependency resolver instance created</param>
/// <exception cref="ArgumentNullException">
/// If the <paramref name="container"/> parameter is null.
/// </exception>
public static ActorSystem UseAutofac(this ActorSystem system, ILifetimeScope container, out IDependencyResolver dependencyResolver)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
dependencyResolver = new AutoFacDependencyResolver(container, system);
return(system);
}
private static void SetupActorSystem()
{
var _actorSystem = Akka.Actor.ActorSystem.Create("MainActorSystem");
var propsResolver = new AutoFacDependencyResolver(_container, _actorSystem);
var _coordinatorActor = _actorSystem.ActorOf(_actorSystem.DI().Props <BrokerCoordinatorActor>(), "brooker-coordinator");
_actorSystem.Scheduler.ScheduleTellRepeatedly(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(5), _coordinatorActor, new SendAliveMessage(), _coordinatorActor);
}
/// <summary>
/// Starts the service.
/// </summary>
public void Start()
{
_seekerLogger.Info("Seeker service is starting.");
_system = ActorSystem.Create("seeker-system");
SeekerContext.ActorSystem = _system;
var resolver = new AutoFacDependencyResolver(AutofacContext.Container, _system);
InitializeActors();
_seekerLogger.Info("Seeker service started.");
}
static void Main(string[] args)
{
var system = ContainerOperations.Instance.Container.Resolve <ActorSystem>();
IDependencyResolver resolver = new AutoFacDependencyResolver(ContainerOperations.Instance.Container, system);
var mySupervisorActor = system.ActorOf(system.DI().Props <MySupervisorActor>(), "MySupervisorActor");
mySupervisorActor.Tell(new StartMessage());
Console.ReadLine();
}
public void Start()
{
_system = Akka.Actor.ActorSystem.Create(_settings.SystemName);
// Create the dependency resolver
IDependencyResolver resolver = new AutoFacDependencyResolver(IoC.Container, _system);
PingActor = _system.ActorOf(_system.DI().Props <PingActor>(), ActorNames.PingActor);
Console.WriteLine($"Starting actor system: {_settings.SystemName}");
}
public Bootstrapper()
{
ActorSystem = ActorSystem.Create("AkkaSample");
var builder = new ContainerBuilder();
ConfigureActors(builder);
Container = builder.Build();
Resolver = new AutoFacDependencyResolver(Container, ActorSystem);
}
public void Start()
{
if (!_initialised)
{
var hoconConfig = ConfigurationFactory.ParseString(AkkaHoconConfig.Hocon);
Container = _containerBuilder.Build();
ActorSystem = ActorSystem.Create("Win10NoUpActorSystem", hoconConfig);
DependencyResolver = new AutoFacDependencyResolver(Container, ActorSystem);
RootActor = ActorSystem.ActorOf(DependencyResolver.Create <TRootActor>(), $"rootActor-{nameof(TRootActor)}");
_initialised = true;
}
}
private static void CreateActorSystem()
{
var builder = new ContainerBuilder();
builder.RegisterType <DemoPaymentGateway>().As <IPaymentGateway>();
builder.RegisterType <PaymentWorkerActor>();
var container = builder.Build();
ActorSystem = ActorSystem.Create("PaymentProcessing");
IDependencyResolver resolver = new AutoFacDependencyResolver(container, ActorSystem);
}
private static void ScheduleBackEndJobCoordinator(AutoFacDependencyResolver propsResolver)
{
Log.Information("ScheduleBackEndJobCoordinator {0}", propsResolver.ToString());
var trackerRouter = system.ActorOf(Props.Create(() => new EmptyRemoteJobActor()).WithRouter(FromConfig.Instance), "trackerroute");
var backEndJobCoordinationActor = system.ActorOf(Props.Create(() => new BackEndJobCoordinationActor(trackerRouter)),
"BackEndJobCoordinationActor");
system.Scheduler
.ScheduleTellRepeatedly(100, 3000, backEndJobCoordinationActor,
new JobConfigLoadOrUpdateMessage(), backEndJobCoordinationActor);
}
private static void Main(string[] args)
{
using (var system = ActorSystem.Create("Sample"))
{
var resolver = new AutoFacDependencyResolver(CompositeRoot(), system);
var rootActor = system.ActorOf(system.DI().Props <RootActor>(), "RootActor");
rootActor.Tell(new Start {
});
Console.ReadLine();
}
}
public void It_should_be_delivered()
{
//Arrange
var fromEmailAddress = "*****@*****.**";
var toEmailAddress = "*****@*****.**";
var emailSender = Container.Resolve <IEmailSender>();
var system = ActorSystem.Create("MyActorSystem");
var propsResolver = new AutoFacDependencyResolver(Container, system);
//Act
emailSender.SendEmail(fromEmailAddress);
//Assert
A.CallTo(() => FakeEmailSender.SendEmail(null)).WithAnyArguments().MustHaveHappened();
}
private static void CreateAndRegisterActors(IContainer container, ActorSystem system)
{
var propsResolver = new AutoFacDependencyResolver(container, system);
system.AddDependencyResolver(propsResolver);
var builder = new ContainerBuilder();
var actorSystemAdapter = container.Resolve<IActorSystemAdapter>(new TypedParameter(typeof(ActorSystem), system));
builder.RegisterInstance(actorSystemAdapter).AsImplementedInterfaces().SingleInstance();
builder.RegisterInstance(system).AsSelf().SingleInstance();
builder.Update(container);
ResolveSingletonActors(actorSystemAdapter);
}
public void Start()
{
_actorSystem = ActorSystem.Create(ParseActorSystemName(), Logging.GetAkkaLoggingConfig());
var resolver = new AutoFacDependencyResolver(_iocContainer, _actorSystem);
_rootActor = _actorSystem.ActorOf(resolver.Create <SourceActor>(), "source");
string ParseActorSystemName()
{
var hyphonated = Regex.Replace(_hostSettings.ServiceName, @"[\s|_]+", "-");
var filtered = Regex.Replace(hyphonated, "[^A-z0-9]", string.Empty);
return(filtered.ToLower());
}
}
public void Start()
{
Log.Information("Starting System bankka");
_system = ActorSystem.Create("bankka", GetConfig());
var options = new DbContextOptionsBuilder <BankkaContext>()
.UseInMemoryDatabase("bankka")
.Options;
var container = CreateContainer(options);
_resolver = new AutoFacDependencyResolver(container, _system);
_customerClerkActor = _system.ActorOf(_system.DI().Props <CustomerClerkActor>().WithRouter(FromConfig.Instance), "customerClerks");
_accountClerkRouter = _system.ActorOf(_system.DI().Props <AccountClerkActor>().WithRouter(FromConfig.Instance), "accountClerks");
}
public void It_should_be_delivered()
{
//Arrange
var fromEmailAddress = "*****@*****.**";
var toEmailAddress = "*****@*****.**";
var system = ActorSystem.Create("MyActorSystem");
var propsResolver = new AutoFacDependencyResolver(Container, system);
var emailSenderActorRef = system.ActorOf(system.DI().Props <EmailSenderActor>(), "EmailSenderActor");
//Act
emailSenderActorRef.Ask(new SendEmailMessage(toEmailAddress), TimeSpan.FromSeconds(3)).Wait();
//Assert
A.CallTo(() => FakeEmailSender.SendEmail(null)).WithAnyArguments().MustHaveHappened();
}
private static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterType <SimpleTrendingMovieAnalyzer>().As <ITrendingMovieAnalyzer>();
builder.RegisterType <TrendingMoviesActor>();
var container = builder.Build();
var logger = new LoggerConfiguration()
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
Serilog.Log.Logger = logger;
MovieStreamingActorSystem = ActorSystem.Create("MovieStreamingActorSystem");
var resolver = new AutoFacDependencyResolver(container, MovieStreamingActorSystem);
MovieStreamingActorSystem.ActorOf(Props.Create <PlaybackActor>(), "Playback");
do
{
ShortPause();
Console.WriteLine();
Console.WriteLine("enter a command and hit enter");
var command = Console.ReadLine();
if (command.StartsWith("play"))
{
int userId = int.Parse(command.Split(',')[1]);
string movieTitle = command.Split(',')[2];
var message = new PlayMovieMessage(movieTitle, userId);
MovieStreamingActorSystem.ActorSelection("/user/Playback/UserCoordinator").Tell(message);
}
if (command.StartsWith("stop"))
{
int userId = int.Parse(command.Split(',')[1]);
var message = new StopMovieMessage(userId);
MovieStreamingActorSystem.ActorSelection("/user/Playback/UserCoordinator").Tell(message);
}
} while (true);
}
private static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterType<SimpleTrendingMovieAnalyzer>().As<ITrendingMovieAnalyzer>();
builder.RegisterType<TrendingMoviesActor>();
var container = builder.Build();
var logger = new LoggerConfiguration()
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
Serilog.Log.Logger = logger;
MovieStreamingActorSystem = ActorSystem.Create("MovieStreamingActorSystem");
var resolver = new AutoFacDependencyResolver(container, MovieStreamingActorSystem);
MovieStreamingActorSystem.ActorOf(Props.Create<PlaybackActor>(), "Playback");
do
{
ShortPause();
Console.WriteLine();
Console.WriteLine("enter a command and hit enter");
var command = Console.ReadLine();
if (command.StartsWith("play"))
{
int userId = int.Parse(command.Split(',')[1]);
string movieTitle = command.Split(',')[2];
var message = new PlayMovieMessage(movieTitle, userId);
MovieStreamingActorSystem.ActorSelection("/user/Playback/UserCoordinator").Tell(message);
}
if (command.StartsWith("stop"))
{
int userId = int.Parse(command.Split(',')[1]);
var message = new StopMovieMessage(userId);
MovieStreamingActorSystem.ActorSelection("/user/Playback/UserCoordinator").Tell(message);
}
} while (true);
}
static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterType <SimpleTrendingMovieAnalyzer>().As <ITrendingMovieAnalyzer>();
builder.RegisterType <TrendingMoviesActor>();
var container = builder.Build();
MovieStreamingActorSystem = ActorSystem.Create("MovieStreamingActorSystem");
IDependencyResolver resolver = new AutoFacDependencyResolver(container, MovieStreamingActorSystem);
MovieStreamingActorSystem.ActorOf(Props.Create <PlaybackActor>(), "Playback");
do
{
ShortPause();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.DarkGray;
ColorConsole.WriteLineGray("enter a command and hit enter");
var command = Console.ReadLine();
if (command.StartsWith("play"))
{
int userId = int.Parse(command.Split(',')[1]);
string movieTitle = command.Split(',')[2];
var message = new PlayMovieMessage(movieTitle, userId);
MovieStreamingActorSystem.ActorSelection("/user/Playback/UserCoordinator").Tell(message);
}
else if (command.StartsWith("stop"))
{
int userId = int.Parse(command.Split(',')[1]);
var message = new StopMovieMessage(userId);
MovieStreamingActorSystem.ActorSelection("/user/Playback/UserCoordinator").Tell(message);
}
else if (command == "exit")
{
Terminate();
}
} while (true);
}
private static void CreateAndRegisterActors(IContainer container, ActorSystem system)
{
var propsResolver = new AutoFacDependencyResolver(container, system);
system.AddDependencyResolver(propsResolver);
var builder = new ContainerBuilder();
var actorSystemAdapter = container.Resolve <IActorSystemAdapter>(new TypedParameter(typeof(ActorSystem), system));
builder.RegisterInstance(actorSystemAdapter).AsImplementedInterfaces().SingleInstance();
builder.RegisterInstance(system).AsSelf().SingleInstance();
builder.Update(container);
ResolveSingletonActors(actorSystemAdapter);
}
public void It_should_be_delivered()
{
//Arrange
const string fromEmailAddress = "*****@*****.**";
const string toEmailAddress = "*****@*****.**";
const string subject = "Hello";
const string body = "hello";
var system = ActorSystem.Create("MyActorSystem");
var propsResolver = new AutoFacDependencyResolver(Container, system);
var emailSenderActorRef = system.ActorOf(system.DI().Props <EmailSenderActor>(), "EmailSenderActor");
//Act
emailSenderActorRef.Ask(new SendEmailMessage(toEmailAddress, fromEmailAddress, subject, body), TimeSpan.FromSeconds(3)).Wait();
//Assert
A.CallTo(() => FakeEmailSender.SendEmail(toEmailAddress, fromEmailAddress, subject, body)).MustHaveHappened();
}
static void Main(string[] args)
{
// Create and build your container
var builder = new Autofac.ContainerBuilder();
//builder.RegisterType<WorkerService>().As<IWorkerService>();
builder.RegisterType <Worker>();
var container = builder.Build();
// Create the ActorSystem and Dependency Resolver
var system = ActorSystem.Create("MySystem");
var propsResolver = new AutoFacDependencyResolver(container, system);
var worker1Ref = system.ActorOf(system.DI().Props <Worker>(), "Worker1");
worker1Ref.Tell("参数");
Console.ReadLine();
}
private static void WithHashPool()
{
var builder = new ContainerBuilder();
builder.RegisterType<TypedWorker>();
var container = builder.Build();
using (var system = ActorSystem.Create("MySystem"))
{
var propsResolver =
new AutoFacDependencyResolver(container, system);
var router = system.ActorOf(system.DI().Props<TypedWorker>().WithRouter(FromConfig.Instance), "router1");
Task.Delay(500).Wait();
Console.WriteLine("Sending Messages");
for (var i = 0; i < 5; i++)
{
for (var j = 0; j < 7; j++)
{
var msg = new TypedActorMessage { Id = j, Name = Guid.NewGuid().ToString() };
var ms = new AnotherMessage { Id = j, Name = msg.Name };
var envelope = new ConsistentHashableEnvelope(ms, msg.Id);
router.Tell(msg);
router.Tell(envelope);
}
}
Console.WriteLine("Hit Enter to close");
Console.ReadLine();
}
}
public void Start()
{
ServerMetadata.Hostname = Dns.GetHostName();
ServerMetadata.Port = Port;
string hocon = File.ReadAllText("YakkaServer.hocon");
string configHocon = string.Format(hocon, ServerMetadata.Hostname, ServerMetadata.Port);
var config = ConfigurationFactory.ParseString(configHocon);
_system = ActorSystem.Create("YakkaServer", config);
var container = ConfigureAutofacContainer();
var resolver = new AutoFacDependencyResolver(container, _system);
//Create root level actors
_system.ActorOf(Props.Create(() => new ConsoleWriterActor()), ServerActorPaths.ConsoleActor.Name);
_system.ActorOf(Props.Create(() => new MessagingActor()), ServerActorPaths.MessagingActor.Name);
_system.ActorOf(Props.Create(() => new ConnectionActor()), ServerActorPaths.ConnectionActor.Name);
_system.ActorOf(Props.Create(() => new ClientsActor()), ServerActorPaths.ClientsActor.Name);
}
public ActorSystem Create(string name)
{
ActorSystem statsActorSystem = ActorSystem.Create(name);
IDependencyResolver resolver = new AutoFacDependencyResolver(_lifetimeScope, statsActorSystem);
return statsActorSystem;
}
