public virtual async Task <IActionResult> Add(int l, int r)
{
var adderGrain = OrleansClient.GetGrain <ICalculatorGrain>(Guid.NewGuid());
var result = await adderGrain.Add(l, r);
return(Ok(result));
}
public static Container RegisterConreignApi(this Container container, IOrleansClientInitializer initializer,
ConreignApiConfiguration configuration)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (initializer == null)
{
throw new ArgumentNullException(nameof(initializer));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
container.Register(() => Log.Logger.ForContext("ApplicationId", "Conreign.Api"), Lifestyle.Singleton);
container.Register(() => OrleansClient.Initialize(initializer).Result, Lifestyle.Singleton);
container.Register <GameHubCountersCollection>(Lifestyle.Singleton);
container.RegisterCollection <HubPipelineModule>(new[] { Assembly.GetExecutingAssembly() });
RegisterHubs(container);
container.RegisterSingleton(new SlowConnectionBehaviourOptions(TimeSpan.FromSeconds(3)));
container.RegisterClientHandlerFactory(c =>
{
// c.Behaviours.Add(typeof(SlowConnectionBehaviour<,>));
});
return(container);
}
protected void Application_Start()
{
OrleansClient.Initialize(Server.MapPath("~/DevTestClientConfiguration.xml"));
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
private static async Task TestHandler()
{
var config = ClientConfiguration.LocalhostSilo();
config.AddSimpleMessageStreamProvider(StreamConstants.ProviderName);
var host = new OrleansClientInitializer(config);
var client = await OrleansClient.Initialize(host);
var container = new Container();
container.RegisterClientHandlerFactory();
var handlerFactory = container.GetInstance <ClientHandlerFactory>();
using (var connection = await client.Connect(Guid.NewGuid()))
{
var handler = handlerFactory.Create(connection);
handler.Events.Subscribe(Write);
var meta = new Metadata();
var loginResponse = await handler.Handle(new LoginCommand(), meta);
Write(loginResponse);
meta = new Metadata {
AccessToken = loginResponse.AccessToken
};
var joinRoom = new JoinRoomCommand {
RoomId = "conreign"
};
await handler.Handle(joinRoom, meta);
var updatePlayer = new UpdatePlayerOptionsCommand
{
RoomId = "conreign",
Options = new PlayerOptionsData
{
Nickname = "smolyakoff",
Color = "#010101"
}
};
await handler.Handle(updatePlayer, meta);
var write = new SendMessageCommand
{
RoomId = "conreign",
Text = "Hello!"
};
await handler.Handle(write, meta);
var getState = new GetRoomStateCommand
{
RoomId = "conreign"
};
var state = await handler.Handle(getState, meta);
Write(state);
}
}
public async override Task TestApiReq3Async(Ice.Current current)
{
var zoneGrain13 = OrleansClient.GetGrain <IZoneGr>(13);
await zoneGrain13.PushMessageForTest($"来自于grain十三的消息，啦啦啦啦啦啦啦啦{Thread.CurrentThread.ManagedThreadId}");
var contcp = current.con.getInfo() as Ice.TCPConnectionInfo;
logger.Debug("TestApiReq3Async链接标识符 connectid -------- " + contcp.connectionId);
}
private static async Task RunOrleansBot(string roomId, int i, int total)
{
var config = ClientConfiguration.LoadFromFile("OrleansClientConfiguration.xml");
var host = new OrleansClientInitializer(config);
var client = await OrleansClient.Initialize(host);
using (var connection = await client.Connect(Guid.NewGuid()))
{
await RunBot(connection, roomId, i, total);
}
}
public OrleansSiloForTesting()
{
domain = AppDomain.CreateDomain("OrleansSiloForTesting", null, new AppDomainSetup
{
AppDomainInitializer = Start,
AppDomainInitializerArguments = new string[0],
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
});
var clientConfigFileName = ConfigurationFilePath("OrleansClientConfigurationForTesting.xml");
OrleansClient.Initialize(clientConfigFileName);
}
public async override Task <bool> JoinSceneReqAsync(byte sceneid, Ice.Current current = null)
{
var session = this.ObtainSession(current);
if (!session.IsLegalIdentify())
{
return(false);
}
var sceneGrain = OrleansClient.GetGrain <ISceneGr>(1); //仅一个场景
var ret = await sceneGrain.JoinAsync(session.Identity);
return(ret);
}
protected void Application_Start()
{
if (RoleEnvironment.IsAvailable)
{
// running in Azure
OrleansAzureClient.Initialize(Server.MapPath(@"~/AzureConfiguration.xml"));
}
else
{
// not running in Azure
OrleansClient.Initialize(Server.MapPath(@"~/LocalConfiguration.xml"));
}
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
public static async Task Start()
{
using (var client = await OrleansClient.StartWithRetries())
{
while (true)
{
var message = RequestQueue.Dequeue();
if (message == null)
{
await Task.Delay(1_000);
continue;
}
Console.WriteLine($"-- {message}");
Task.Run(async() => await client.Process(message));
}
}
}
static void Main()
{
Console.WriteLine("Make sure that local silo is started. Press Enter to proceed ...");
Console.ReadLine();
Console.Write("Enter number of clients: ");
var numberOfClients = int.Parse(Console.ReadLine() ?? Environment.ProcessorCount.ToString("D"));
Console.Write("Enter number of repeated pings per client (thousands): ");
var numberOfRepeatsPerClient = int.Parse(Console.ReadLine() ?? "15");
OrleansClient.Initialize("DevTestClientConfiguration.xml");
benchmark = new Benchmark(numberOfClients, numberOfRepeatsPerClient * 1000);
benchmark.Run();
Console.ReadLine();
}
public GameHub(
ILogger logger,
OrleansClient client,
GameHubCountersCollection counters,
ClientHandlerFactory clientHandlerFactory)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_client = client ?? throw new ArgumentNullException(nameof(client));
_countersCollection = counters ?? throw new ArgumentNullException(nameof(counters));
_clientHandlerFactory = clientHandlerFactory ??
throw new ArgumentNullException(nameof(clientHandlerFactory));
_errorSerializer = JsonSerializer.Create(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
_connectionsGauge = _logger.GaugeOperation("Hub.Connections", "connection(s)", () => Connections.Count);
}
public async override Task <RLResultRes> RegOrLoginReqAsync(string account, string pwd, Ice.Current current = null)
{
var acctGrain = OrleansClient.GetGrain <IAccountGr>(System.Guid.Empty); //统一的账户管理器
var to = await acctGrain.RegistOrLoginAsync(account, pwd);
RLResultRes res = new RLResultRes()
{
ret = to.ret
};
if (to.ret == 0)
{
res.idcode = to.idcode;
var session = current.BindSession(to.idcode, out _); //绑定应用层身份用于推送
session?.Push <string>("__identity__", to.idcode); //设置合法性标识用于验证是否拦截
logger.Debug($"{account} 绑定标识符 {to.idcode}");
}
return(res);
}
public async override Task TestApiReqAsync(Ice.Current current)
{
var zoneGrain1 = OrleansClient.GetGrain <IZoneGr>(1);
var zonekey1 = await ObserverClient.GetObserver <ZoneObserver, IZoneOb>(1);
//var ccc = ObserverClient.SubscribeWrap<IZoneOb>(zonekey1, ob => { zoneGrain1.SubscribeAsync(ob); });
//logger.Debug(zonekey1 + " -------- " + ccc);
//var zonekey2 = await ObserverClient.GetObserver<ZoneObserver, IZoneOb>(1);
//ccc = ObserverClient.SubscribeWrap<IZoneOb>(zonekey2, ob => { zoneGrain1.SubscribeAsync(ob); });
//logger.Debug(zonekey2 + " -------- " + ccc);
//var zoneGrain13 = OrleansClient.GetGrain<IZoneGr>(13);
//var zonekey3 = await ObserverClient.GetObserver<ZoneObserver, IZoneOb>(13);
//ccc = ObserverClient.SubscribeWrap<IZoneOb>(zonekey3, ob => { zoneGrain13.SubscribeAsync(ob); });
//logger.Debug(zonekey3 + " -------- " + ccc);
var contcp = current.con.getInfo() as Ice.TCPConnectionInfo;
logger.Debug("TestApiReqAsync链接标识符 connectid -------- " + contcp.connectionId);
}
public static void Main()
{
var args = new[]
{
"UseDevelopmentStorage=true" // # TopicStorageAccount
};
var hostDomain = AppDomain.CreateDomain("OrleansHost", null, new AppDomainSetup
{
AppDomainInitializer = StartSilo,
AppDomainInitializerArguments = args,
});
OrleansClient.Initialize("ClientConfiguration.xml");
RunClient();
Console.WriteLine("Press Enter to terminate ...");
Console.ReadLine();
hostDomain.DoCallBack(StopSilo);
}
const string URL = "http://devicetracker.cloudapp.net:8080/api/devices/processmessage"; // Change to point to the web site under test
/// <summary>
/// Start the simulation via the controller grain.
/// </summary>
/// <returns></returns>
public async Task Run()
{
OrleansClient.Initialize();
// create an aggregator grain to track results from the load test
IAggregatorGrain aggregator = AggregatorGrainFactory.GetGrain(0);
// set this SimulationController class as an observer on the aggregator grain
observer = await SimulationObserverFactory.CreateObjectReference(this); // convert our class into a grain reference
await aggregator.SetObserver(observer); // then set ourselves up to receive notifications on ReportResults()
// Instantiate the manager grains and start the simulations
// Pause between each batch to ramp up load gradually
for (int i = 0; i < BATCH_COUNT; i++)
{
Console.WriteLine("Starting batch #{0}", i + 1);
IManagerGrain manager = ManagerGrainFactory.GetGrain(i);
managers.Add(manager); // store grain reference
await manager.SetAggregator(aggregator); // link in the aggregator
await manager.StartSimulators(i *DELAY_STEPS *1000, BATCH_SIZE, URL); // start the sinulation
}
// Sleep for the duration of the test
Console.WriteLine("Running test...");
Thread.Sleep(RUN_TIME * 1000); // low value just for test
// Gradually stop simulators
foreach (var i in managers)
{
Console.WriteLine("Stopping step #{0}", managers.IndexOf(i) + 1);
await i.StopSimulators();
Thread.Sleep(DELAY_STEPS * 1000);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, OrleansClient orleansClient)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
orleansClient.Initialize();
app.UseMvc();
app.UseDeveloperExceptionPage();
}
public ValuesController(SignalRClient signalRClient, OrleansClient orleansClient)
{
_signalRClient = signalRClient;
_orleansClient = orleansClient;
}
internal static IdentityServer4.Models.Client ToModel(this OrleansClient orleansClient)
{
return Mapper.Map<IdentityServer4.Models.Client>(orleansClient);
}
