public void Init(ClientConfig config)
{
// register defaults
Register(ServiceNames.Map, (type, id) =>
{
var clientConfig = _client.GetClientConfig();
var nearCacheConfig = clientConfig.GetNearCacheConfig(id);
var proxyType = nearCacheConfig != null ? typeof(ClientMapNearCacheProxy <,>) : typeof(ClientMapProxy <,>);
return(ProxyFactory(proxyType, type, ServiceNames.Map, id));
});
Register(ServiceNames.Queue,
(type, id) => ProxyFactory(typeof(ClientQueueProxy <>), type, ServiceNames.Queue, id));
Register(ServiceNames.MultiMap,
(type, id) => ProxyFactory(typeof(ClientMultiMapProxy <,>), type, ServiceNames.MultiMap, id));
Register(ServiceNames.List,
(type, id) => ProxyFactory(typeof(ClientListProxy <>), type, ServiceNames.List, id));
Register(ServiceNames.Set,
(type, id) => ProxyFactory(typeof(ClientSetProxy <>), type, ServiceNames.Set, id));
Register(ServiceNames.Topic,
(type, id) => ProxyFactory(typeof(ClientTopicProxy <>), type, ServiceNames.Topic, id));
Register(ServiceNames.AtomicLong,
(type, id) => ProxyFactory(typeof(ClientAtomicLongProxy), type, ServiceNames.AtomicLong, id));
Register(ServiceNames.Lock, (type, id) => ProxyFactory(typeof(ClientLockProxy), type, ServiceNames.Lock, id));
Register(ServiceNames.CountDownLatch,
(type, id) => ProxyFactory(typeof(ClientCountDownLatchProxy), type, ServiceNames.CountDownLatch, id));
Register(ServiceNames.PNCounter,
(type, id) => ProxyFactory(typeof(ClientPNCounterProxy), type, ServiceNames.PNCounter, id));
Register(ServiceNames.Semaphore,
(type, id) => ProxyFactory(typeof(ClientSemaphoreProxy), type, ServiceNames.Semaphore, id));
Register(ServiceNames.Ringbuffer,
(type, id) => ProxyFactory(typeof(ClientRingbufferProxy <>), type, ServiceNames.Ringbuffer, id));
Register(ServiceNames.ReplicatedMap,
(type, id) => ProxyFactory(typeof(ClientReplicatedMapProxy <,>), type, ServiceNames.ReplicatedMap, id));
Register(ServiceNames.IdGenerator, delegate(Type type, string id)
{
var atomicLong = _client.GetAtomicLong("IdGeneratorService.ATOMIC_LONG_NAME" + id);
return(Activator.CreateInstance(typeof(ClientIdGeneratorProxy), ServiceNames.IdGenerator, id, atomicLong) as
ClientProxy);
});
foreach (var proxyFactoryConfig in config.GetProxyFactoryConfigs())
{
try
{
ClientProxyFactory clientProxyFactory = null;
var type = Type.GetType(proxyFactoryConfig.GetClassName());
if (type != null)
{
clientProxyFactory = (ClientProxyFactory)Activator.CreateInstance(type);
}
Register(proxyFactoryConfig.GetService(), clientProxyFactory);
}
catch (Exception e)
{
Logger.Severe(e);
}
}
}
public BaseHandlerIntegrationTest()
{
var _applicationConfiguration = new ApplicationConfiguration();
var configurationRoot = TestHelper.GetConfigurationRoot(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
configurationRoot.Bind(_applicationConfiguration);
var consoleWriter = new ConsoleWriter(SerilogFixture.UsefullLogger <ConsoleWriter>());
var authTokenFactory = new OAuthTokenFactory(SerilogFixture.UsefullLogger <OAuthTokenFactory>(), _applicationConfiguration);
var clientFactory = new ClientProxyFactory(SerilogFixture.UsefullLogger <ClientProxyFactory>(), authTokenFactory, _applicationConfiguration);
//var fileHandler = new FileHandlerMock() {ReadFile = FileHandlerMock.WithReadFileAsNoOp(), WriteFile = FileHandlerMock.WithWriteFileAsNoOp()}.Build();
var fileHandler = new FileHandler(SerilogFixture.UsefullLogger <FileHandler>());
SchemaClient = clientFactory.GetClientProxy <ISquidexAppSchemaClient>("aut-developer");
SchemaImportSystemUnderTest = new SchemaImportHandler(SerilogFixture.UsefullLogger <SchemaImportHandler>(), clientFactory, consoleWriter, null);
SchemaExportSystemUnderTest = new SchemaExportHandler(SerilogFixture.UsefullLogger <SchemaExportHandler>(), clientFactory, consoleWriter, null);
SchemaDeleteSystemUnderTest = new SchemaDeleteHandler(SerilogFixture.UsefullLogger <SchemaDeleteHandler>(), clientFactory, consoleWriter, null);
SchemaListSystemUnderTest = new SchemaListHandler(SerilogFixture.UsefullLogger <SchemaListHandler>(), clientFactory, consoleWriter, null);
//var schemaTagHandler = new SchemaTagHandler(SerilogFixture.UsefullLogger<ContentDeleteSystemUnderTest>(), clientFactory, null);
ContentClient = clientFactory.GetClientProxy <ISquidexContentClient>("aut-developer");
ContentImportSystemUnderTest = new ContentImportHandler(SerilogFixture.UsefullLogger <ContentImportHandler>(), clientFactory, consoleWriter, null);
ContentExportSystemUnderTest = new ContentExportHandler(SerilogFixture.UsefullLogger <ContentExportHandler>(), clientFactory, consoleWriter, null);
ContentDeleteSystemUnderTest = new ContentDeleteHandler(SerilogFixture.UsefullLogger <ContentDeleteHandler>(), clientFactory, consoleWriter, null);
ContentPostSystemUnderTest = new ContentPostHandler(SerilogFixture.UsefullLogger <ContentImportHandler>(), clientFactory, consoleWriter, null);
AttachmentClient = clientFactory.GetClientProxy <ISquidexAttachmentClient>("aut-developer");
AttachmentImportSystemUnderTest = new AssetImportHandler(SerilogFixture.UsefullLogger <AssetImportHandler>(), clientFactory, consoleWriter, null);
AttachmentExportSystemUnderTest = new AssetExportHandler(SerilogFixture.UsefullLogger <AssetExportHandler>(), clientFactory, consoleWriter, null);
AttachmentDeleteSystemUnderTest = new AssetDeleteHandler(SerilogFixture.UsefullLogger <AssetDeleteHandler>(), clientFactory, consoleWriter, null);
AttachmentListSystemUnderTest = new AssetListHandler(SerilogFixture.UsefullLogger <AssetListHandler>(), clientFactory, consoleWriter, null);
AttachmentTagSystemUnderTest = new AssetTagHandler(SerilogFixture.UsefullLogger <AssetTagHandler>(), clientFactory, consoleWriter, null);
AssetUpdateContentSystemUnderTest = new AssetUpdateContentHandler(SerilogFixture.UsefullLogger <AssetUpdateContentHandler>(), clientFactory, consoleWriter, null);
}
static void Main(string[] args)
{
var proxy = ClientProxyFactory.Create()
.UseCastleDynamicClientProxy()
.UseJsonNetSerializer()
.UseDefaultChannel($"{IPUtility.GetLocalIntranetIP().MapToIPv4()}:5566")
.GetClientProxy();
var mathService = proxy.Create <IMathService>();
var random = new Random();
var req = new SumReq {
A = random.Next(100000), B = random.Next(100000)
};
var result = mathService.SumAsync(req).GetAwaiter().GetResult();
if (result.Code == 0)
{
Console.WriteLine("Call Math Service Add {0}+{1}={2}", req.A, req.B, result.Data?.Total);
}
else
{
Console.WriteLine("Call Math Service Error,Code={0}", result.Code);
}
Console.WriteLine("Press any key to exit !");
Console.ReadKey();
}
public void Register(string serviceName, ClientProxyFactory factory)
{
if (_proxyFactories.ContainsKey(serviceName))
{
throw new ArgumentException("Factory for service: " + serviceName + " is already registered!");
}
_proxyFactories.GetOrAdd(serviceName, factory);
}
public void BuildFactoryWithoutError()
{
var clientProxy = new Mock <IClientProxy>();
var proxy = ClientProxyFactory.Create()
.AddDependencyServices(services => { services.AddSingleton(clientProxy.Object); })
.GetClientProxy();
Assert.NotNull(proxy);
}
public void AddDependencyServicesTest()
{
IServiceCollection container = new ServiceCollection();
var factory = ClientProxyFactory.Create(container);
factory.AddDependencyServices(services => { services.AddSingleton <IFooService, FooService>(); });
var provider = container.BuildServiceProvider();
var fooService = provider.GetRequiredService <IFooService>();
Assert.NotNull(fooService);
}
static void Main(string[] args)
{
/* default route */
var factory = ClientProxyFactory.Create()
.UseCastleDynamicClientProxy()
.ConfigureLogging(logger => logger.AddConsole())
.UseMessagePackSerializer()
.UseDefaultChannel($"{IPUtility.GetLocalIntranetIP().MapToIPv4()}:5566");
/* service discovery route
* var factory = ClientProxyFactory.Create()
* .ConfigureLogging(logger =>logger.AddConsole())
* .UseCastleDynamicProxy()
* .UseMessagePackSerializer()
* .UseConsulDnsServiceDiscovery(); //默认配置 localhost
*/
var proxy = factory.GetProxyInstance();
var mathService = proxy.Create <IMathService>();
var i = 0;
var random = new Random();
while (i++ < 100)
{
var req = new SumReq {
A = random.Next(100000), B = random.Next(100000)
};
var result = mathService.SumAsync(req).Result;
Console.WriteLine("Call Math Service ,return_code={0}", result.Code);
if (result.Code == 0)
{
Console.WriteLine("Call Math Service Add {0}+{1}={2}", req.A, req.B, result.Data?.Total);
}
Console.WriteLine("============= count:{0}", i);
}
Console.WriteLine("Press any key to exit !");
Console.ReadKey();
}
private static void Main(string[] args)
{
var proxy = ClientProxyFactory.Create()
.UseCastleDynamicClientProxy()
.UseMessagePackSerializer()
.UseDefaultChannel($"{IPUtility.GetLocalIntranetIP().MapToIPv4()}:5566")
.GetClientProxy();
var service = proxy.Create <IQuickStartService>();
// 项目中应保证异步到底的调用
var res = service.SayHelloAsync(new SayHelloReq {
Name = "Maxi"
}).GetAwaiter().GetResult();
Console.WriteLine(res?.Data?.GreetingWords);
Console.WriteLine("Press any key to exit !");
Console.ReadKey();
}
public ClientProxy GetOrCreateProxy <T>(string service, string id)
{
var ns = new ObjectNamespace(service, id);
ClientProxy proxy = null;
_proxies.TryGetValue(ns, out proxy);
if (proxy != null)
{
return(proxy);
}
ClientProxyFactory factory = null;
_proxyFactories.TryGetValue(service, out factory);
if (factory == null)
{
throw new ArgumentException("No factory registered for service: " + service);
}
var clientProxy = factory(typeof(T), id);
InitializeWithRetry(clientProxy);
return(_proxies.GetOrAdd(ns, clientProxy));
}
public void ConfigureTest()
{
IServiceCollection container = new ServiceCollection();
var factory = ClientProxyFactory.Create(container);
factory.Configure <FooOptions>(o => {
o.Option1 = "111";
o.Option2 = 222;
});
var provider = container.BuildServiceProvider();
var options = provider.GetRequiredService <IOptions <FooOptions> >();
Assert.NotNull(options);
Assert.NotNull(options.Value);
Assert.Equal("111", options.Value.Option1);
Assert.Equal(222, options.Value.Option2);
}