public static IDepartmentAppService CreateDepartmentAppService() { var builder = new ServiceUriBuilder(AppName_EnterpriseContact, ServiceName_EnterpriseContactService); return(proxyFactory.CreateServiceProxy <IDepartmentAppService>( builder.ToUri(), listenerName: ListenerName_DepartmentAppService)); }
public async Task <List <User> > GetUsersAsync(CancellationToken cancellationToken) { var userStoreProxy = _serviceProxyFactory.CreateServiceProxy <IUserStore>(_userStoreServiceUri); var usersInPartition = await userStoreProxy.GetUsersAsync(cancellationToken); return(usersInPartition); }
public static IConversationCtrlAppService CreateConversationCtrlAppService() { var builder = new ServiceUriBuilder(AppName_InstantMessage, ServiceName_ConversationCtrlStateService); return(proxyFactory.CreateServiceProxy <IConversationCtrlAppService>( builder.ToUri())); }
public static IClientAppService CreateClientAppService() { var builder = new ServiceUriBuilder(AppName_ConfigMgmt, ServiceName_SystemConfigStateService); return(proxyFactory.CreateServiceProxy <IClientAppService>( builder.ToUri(), listenerName: ListenerName_ClientAppService)); }
private async Task CallValidationService(ServiceCoreRequest value) { IValidationService proxy = proxyFactory.CreateServiceProxy <IValidationService>( new Uri( string.Concat(Context.CodePackageActivationContext.ApplicationName, "/Microsoft.IoT.ServiceFabric.Validation")), new ServicePartitionKey(0L), TargetReplicaSelector.PrimaryReplica); using (MeasureTime measure = new MeasureTime()) { ServiceResponse <ValidationServiceResponse> response = await proxy.ValidateMessage(value); response.IsSuccess = response != null; telemetry.TrackEvent( "Core-Validation-Call", new Dictionary <string, string>() { { "Id", value.Id } }, new Dictionary <string, double>() { { "CoreElapsed", measure.Elapsed.TotalMilliseconds } }); } }
private async Task SaveResultsToDataService(string correlationId, IEnumerable <string> results) { var fundingCalcResultsService = _serviceProxyFactory.CreateServiceProxy <IFundingCalcResults>( _validationResultsServiceUri, new ServicePartitionKey(0), TargetReplicaSelector.PrimaryReplica, "dataServiceRemotingListener"); await fundingCalcResultsService.SaveFCResultsAsync(correlationId, results); }
public long Add(int a, int b) { var calculatorClient = proxyFactory.CreateServiceProxy <ICalculatorService>( new Uri("fabric:/CalculatorApplication/CalculatorService"), targetReplicaSelector: Microsoft.ServiceFabric.Services.Communication.Client.TargetReplicaSelector.RandomInstance); return(calculatorClient.Add(1, 2).Result); }
public async Task <string> GetTest() { ServiceEventSource.Current.ServiceMessage(serviceContext, $"GetTest()"); var chessClient = proxyFactory.CreateServiceProxy <IChessFabrickStatefulService>(chessStatefulUri, new ServicePartitionKey(new Random().Next(0, 4))); string message = await chessClient.HelloChessAsync(); await Clients.All.SendAsync("Test", message); return("Test"); }
public async Task PerformMove() { ActorEventSource.Current.ActorMessage(this, $"PerformMove({gameId})"); await Task.Delay(rand.Next(800, 1600)); var chessClient = proxyFactory.CreateServiceProxy <IChessFabrickStatefulService>(chessStatefulUri, ChessFabrickUtils.GuidPartitionKey(gameId)); var game = await chessClient.ActiveGameStateAsync(gameId); while (true) { try { var board = new Board(); board.PerformMoves(game.GameInfo.MoveHistory); var move = GetRandomMove(board); await chessClient.MovePieceAsync(gameId, ChessFabrickUtils.BOT_NAME, move.Item1, move.Item2); return; } catch (Exception ex) { ActorEventSource.Current.ActorMessage(this, $"PerformMoveException({gameId}): \n{ex}"); } } }
public static IAttachmentAppService CreateAttachmentAppService(string itemId) { var builder = new ServiceUriBuilder(AppName_Attachment, ServiceName_AttachmentStateService); return(proxyFactory.CreateServiceProxy <IAttachmentAppService>(builder.ToUri(), new ServicePartitionKey(HashUtil.getLongHashCode(itemId)))); }
public async Task OnGetAsync() { Message = "Your contact page."; var builder = new ServiceUriBuilder("SampleState"); //use native serialization //var proxy = ServiceProxy.Create<ISampleRemotingService>(builder.ToUri()); //use bson serialization var proxyFactory = new ServiceProxyFactory((c) => { return(new FabricTransportServiceRemotingClientFactory( serializationProvider: new BsonSerializationProvider())); }); var proxy = proxyFactory.CreateServiceProxy <ISampleRemotingService>(builder.ToUri()); Peoples = await proxy.GetPeoplesAsync(new FilterDto { Search = "abc", Page = 5 }); var bus = Bus.Factory.CreateUsingRabbitMq(cfg => { var host = cfg.Host(new Uri("rabbitmq://localhost"), h => { h.Username("guest"); h.Password("guest"); }); }); await bus.Publish(new FilterDto { Search = "abc", Page = 5 }); }
public async Task CallAsync <TService>(string traceId, Uri uri, Expression <Func <TService, Task> > callMethod) where TService : IService { var proxyFactory = new ServiceProxyFactory(c => new ServiceRemotingClientFactoryWrapper(traceId, new WcfServiceRemotingClientFactory(callbackClient: c))); var service = proxyFactory.CreateServiceProxy <TService>(uri); var success = true; var stopwatch = Stopwatch.StartNew(); var started = DateTime.Now; try { await callMethod.Compile().Invoke(service); } catch (Exception exception) { success = false; logger.LogError(ServiceFabricEvent.Exception, exception, exception.Message); throw; } finally { stopwatch.Stop(); logger.LogDependency(callMethod, started, stopwatch.Elapsed, success); } }
public async Task <UserModel> Authenticate(string userName, string password) { var userClient = proxyFactory.CreateServiceProxy <IChessFabrickPlayersStatefulService>(userServiceUri, ChessFabrickUtils.NamePartitionKey(userName)); var player = await userClient.PlayerInfoAsync(userName); if (player == null) { throw new ArgumentException("Authentication failed."); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(appSettings.Secret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, player.Name) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); var user = new UserModel { Player = player, Token = tokenHandler.WriteToken(token) }; return(user); }
private async void button_AddMathService_Click(object sender, EventArgs e) { int number1 = int.Parse(textBox_MathServiceNumber1.Text); int number2 = int.Parse(textBox_MathServiceNumber2.Text); //var uri = new Uri("fabric:/SampleSFV2/MathService"); ServiceProxyFactory proxyFactory = new ServiceProxyFactory((c) => { FabricTransportRemotingSettings settings = new FabricTransportRemotingSettings(); return(new FabricTransportServiceRemotingClientFactory(settings)); }); try { IMathCalculator service = proxyFactory.CreateServiceProxy <IMathCalculator>(_mathServiceUri, listenerName: "MathCalculator_v2"); int result = await service.Add(number1, number2); MessageBox.Show("Result= " + result); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
private IMyBackend GetServiceClientWithTransportSettings() { var builder = new ServiceUriBuilder(BackendServiceName); //var x509Credentials = new X509Credentials //{ // FindType = X509FindType.FindByThumbprint, // FindValue = "053a87f6c1e3d08ec7fc28522a2cf1921c9daa5e", // StoreLocation = StoreLocation.LocalMachine, // StoreName = "My", // ProtectionLevel = ProtectionLevel.EncryptAndSign //}; //x509Credentials.RemoteCommonNames.Add("jacksch.westus.cloudapp.azure.com"); //var transportSettings = new FabricTransportSettings //{ // SecurityCredentials = x509Credentials, // MaxMessageSize = 10000000 //}; var serviceProxyFactory = new ServiceProxyFactory((c) => new FabricTransportServiceRemotingClientFactory()); return(serviceProxyFactory.CreateServiceProxy <IMyBackend>(builder.ToUri())); }
public async Task <IServiceFabricCacheStoreService> GetCacheStoreProxy(string cacheKey) { // Try to locate a cache store if one is not configured if (_serviceUri == null) { _serviceUri = await LocateCacheStoreAsync(); if (_serviceUri == null) { throw new CacheStoreNotFoundException("Cache store not found in Service Fabric cluster. Try setting the 'CacheStoreServiceUri' configuration option to the location of your cache store."); } } var partitionInformation = await GetPartitionInformationForCacheKey(cacheKey); return(_cacheStores.GetOrAdd(partitionInformation.Id, key => { var info = (Int64RangePartitionInformation)partitionInformation; var resolvedPartition = new ServicePartitionKey(info.LowKey); var proxyFactory = new ServiceProxyFactory((c) => { return new FabricTransportServiceRemotingClientFactory(); }); return proxyFactory.CreateServiceProxy <IServiceFabricCacheStoreService>(_serviceUri, resolvedPartition, Microsoft.ServiceFabric.Services.Communication.Client.TargetReplicaSelector.Default, _endpointName); })); }
private async void button_AddNumbers_Click(object sender, EventArgs e) { //int number1 = int.Parse(textBox_Number1.Text); //int number2 = int.Parse(textBox_Number2.Text); //var uri = _evilMathServiceUri; int number1 = 10; int number2 = 100; Uri uri = new Uri("fabric:/SampleSFV2/EvilMathTeacherService"); ServiceProxyFactory proxyFactory = new ServiceProxyFactory((c) => { FabricTransportRemotingSettings settings = new FabricTransportRemotingSettings(); return(new FabricTransportServiceRemotingClientFactory(settings)); }); try { IQuestionnaire service = proxyFactory.CreateServiceProxy <IQuestionnaire>(uri, listenerName: "Questionnaire_v2"); int result = await service.AddTwoNumbers(number1, number2); MessageBox.Show("Result= " + result); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
public ProductController() { var proxyFactory = new ServiceProxyFactory(c => new FabricTransportServiceRemotingClientFactory()); _service = proxyFactory.CreateServiceProxy <IProductCatalogService>( new Uri("fabric:/ECommerce/ECommerce.ProductCatalog"), new ServicePartitionKey(0)); }
private IProductCatalogService GetProductCatalogService() { var proxyFactory = new ServiceProxyFactory(c => new FabricTransportServiceRemotingClientFactory()); return(proxyFactory.CreateServiceProxy <IProductCatalogService>(new Uri("fabric:/ECommerce/ECommerce.ProductCatalog"), new ServicePartitionKey(0))); }
public async Task <List <string> > GetAll(CancellationToken cancellationToken) { var address = new Uri($"{this._applicationName}/{MODULEMANAGERSERVICE}"); var service = _proxyFactory.CreateServiceProxy <IModuleManager>(address); return(await service.GetModuleIds(cancellationToken)); }
public async Task <IActionResult> Start(string id) { try { var message = new ServiceMessage(); message.CommChannel = "Remoting"; message.SessionId = id; message.StampOne.Visited = true; message.StampOne.TimeNow = DateTime.UtcNow; //var storage = await _manager.GetOrAddAsync<IReliableDictionary<string, ServiceMessage>>("storage"); //using (var tx = _manager.CreateTransaction()) //{ // await storage.AddAsync(tx, message.MessageId, message); // await tx.CommitAsync(); //} var partitionKey = new ServicePartitionKey(1); var proxyFactory = new ServiceProxyFactory((c) => { //return new FabricTransportServiceRemotingClientFactory( serializationProvider: new ServiceRemotingJsonSerializationProvider()); return(new FabricTransportServiceRemotingClientFactory()); }); var service = proxyFactory.CreateServiceProxy <IServiceTwo>(new Uri(Endpoint), partitionKey, listenerName: "RemotingV2"); //var service = ServiceProxy.Create<IServiceTwo>(new Uri(Endpoint), partitionKey); await service.VisitByRemotingAsync(message); return(Ok(new { id = id })); } catch (Exception e) { return(BadRequest(e.Message)); } }
public async Task <IEnumerable <Student> > Get(string subject) { var students = new List <Student>(); Enum.TryParse(subject, out Subject subjectEnum); var partitions = await FabricClient.QueryManager.GetPartitionListAsync(_actorServiceUri); foreach (var p in partitions) { // ReSharper disable once PossibleNullReferenceException var minKey = (p.PartitionInformation as Int64RangePartitionInformation).LowKey; var proxy = _serviceProxyFactory.CreateServiceProxy <IStudentActorService>(_actorServiceUri, new ServicePartitionKey(minKey)); var result = await proxy.GetStudentsBySubjectAsync(subjectEnum, CancellationToken.None); if (result != null) { students.AddRange(result); } } return(students); }
public async Task <TService> ResolveServiceAsync <TService>(Uri location, ServicePartitionKey partition, TargetReplicaSelector selector, string listener, TimeSpan timeout, CancellationToken cancellation) where TService : ITestableService { return(await ResolveDependencyAsync(async() => { if (_proxyFactory == null) { throw new Exception("Proxy factory is not initialized"); } Logger.LogInformation($"{typeof(TService).Name}: Creating proxy for service - {location}"); var proxy = _proxyFactory.CreateServiceProxy <TService>(location, partition, selector, listener); Logger.LogInformation($"{typeof(TService).Name}: Proxy for service created"); if (proxy == null) { throw new Exception($"Proxy '{typeof(TService).Name}' was not resolved correctly"); } var result = await proxy.TestAsync() .ConfigureAwait(false); if (result == false) { throw new Exception("Service was not initialized correctly"); } Logger.LogInformation($"{typeof(TService).Name}: Proxy for service connected"); return proxy; }, timeout, cancellation) .ConfigureAwait(false)); }
public static IControlAppService CreateGroupFileControlAppService() { var builder = new ServiceUriBuilder(AppName_GroupFile, ServiceName_GroupFileService); return(proxyFactory.CreateServiceProxy <IControlAppService>( builder.ToUri(), listenerName: ListenerName_ControlAppService)); }
public async Task <IEnumerable <ApiMovie> > Get(string text) { var partitionKey = await GetSearchPartitionKeyAsync(text); //var _searchService = ServiceProxy.Create<ISearchService>( // _searchServiceUri, // partitionKey); /* Remoting V2 does not support for complex type defaultly * Here overwriten serialize provider as json serialization to deserialize the response */ var proxyFactory = new ServiceProxyFactory((c) => { return(new FabricTransportServiceRemotingClientFactory( serializationProvider: new ServiceRemotingJsonSerializationProvider())); }); var _searchService = proxyFactory.CreateServiceProxy <ISearchService>( _searchServiceUri, partitionKey); var results = await _searchService.SearchMovies(new SearchParameters { Select = new[] { "tmsId", "title", "longDescription" }, SearchTerm = text }); return(results?.Select(i => new ApiMovie() { Id = i.tmsId, Title = i.title, LongDescription = i.longDescription, ShortDescription = i.shortDescription })); }
private static IRoadService GetRoadServiceProxy() { var serviceUri = new Uri($"fabric:/ServiceFabricApplication/RoadServiceFacade"); var proxyFactory = new ServiceProxyFactory(_ => new FabricTransportServiceRemotingClientFactory()); return(proxyFactory.CreateServiceProxy <IRoadService>(serviceUri)); }
/// <inheritdoc/> public async Task CallAsync <TService>( CustomHeaders customHeaders, Uri uri, Expression <Func <TService, Task> > callMethod) where TService : IService { var proxyFactory = new ServiceProxyFactory(c => new ExtendedServiceRemotingClientFactory(new FabricTransportServiceRemotingClientFactory(remotingCallbackMessageHandler: c), customHeaders)); var service = proxyFactory.CreateServiceProxy <TService>(uri); var success = true; var stopwatch = Stopwatch.StartNew(); var started = DateTime.Now; try { await callMethod.Compile().Invoke(service); } catch (Exception exception) { success = false; _logger.LogError(ServiceFabricEvent.Exception, exception, exception.Message); throw; } finally { stopwatch.Stop(); _logger.LogDependency(callMethod, started, stopwatch.Elapsed, success); } }
public async Task VisitByRemotingAsync(ServiceMessage message) { message.StampThree.Visited = true; message.StampThree.TimeNow = DateTime.UtcNow; var storage = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, ServiceMessage> >("storage1"); using (var tx = this.StateManager.CreateTransaction()) { await storage.AddAsync(tx, message.MessageId, message); await tx.CommitAsync(); } //var service = ServiceProxy.Create<IServiceFour>(new Uri(Service4Uri), new ServicePartitionKey(1)); var proxyFactory = new ServiceProxyFactory((c) => { //return new FabricTransportServiceRemotingClientFactory(serializationProvider: new ServiceRemotingJsonSerializationProvider()); return(new FabricTransportServiceRemotingClientFactory()); }); var service = proxyFactory.CreateServiceProxy <IServiceFour>(new Uri(Service4Uri), new ServicePartitionKey(1), listenerName: "RemotingV2"); await service.VisitByRemotingAsync(message); }
private ICpuBurnerService GetBurner(long partition) { var proxyFactory = new ServiceProxyFactory(c => new FabricTransportServiceRemotingClientFactory()); return(proxyFactory.CreateServiceProxy <ICpuBurnerService>( new Uri("fabric:/Pluralsight.SfProd/Pluralsight.SfProd.CpuBurner"), new ServicePartitionKey(partition))); }
public TServiceInterface CreateServiceProxy <TServiceInterface>(Uri serviceUri, ServicePartitionKey partitionKey = null, TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default, string listenerName = null) where TServiceInterface : IService { TServiceInterface proxy = serviceProxyFactory.CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector, listenerName); methodNameProvider.AddMethodsForProxyOrService(proxy.GetType().GetInterfaces(), typeof(IService)); return(proxy); }