public async Task <string> TKStatelessSet(int partition, string name, int value)
{
var start = DateTime.Now;
ITKStateless proxy = null;
//For single partitions
if (partition == -1)
{
proxy = ServiceProxy.Create <ITKStateless>(new Uri("fabric:/TK_2016MainSFFunctions/TKStateless")
);
}
else
{
proxy = ServiceProxy.Create <ITKStateless>(new Uri("fabric:/TK_2016MainSFFunctions/TKStateless")
, new Microsoft.ServiceFabric.Services.Client.ServicePartitionKey(partition));
}
var v = await proxy.SetAsync(name, value);
var stop = DateTime.Now;
return($"Partition: {partition}, {(DateTime.Now - start).TotalMilliseconds}, {v}");
}
public async Task <string> Get()
{
//We need to provide two sets of info to the service proxy. The name of the service as registered
//wit SF and the partition key, which is set to 0 currently because we only have one partition.
//partitioning info found here https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-concepts-partitioning
ISnowProvider snow =
ServiceProxy.Create <ISnowProvider>(new Uri("fabric:/GoodVibesSurfing/GetSnowConditions"),
new ServicePartitionKey(0));
try
{
var taskResult = await RetryPattern.DoTaskWithRetry(snow.GetSnowConditionsAsync);
//due to some nested task garbaggio we're going to wait for this again. The reason is that our delegate is running a task
//which runs a task... so the await for some reason isn't sufficient
taskResult.Wait();
var conditions = taskResult.Result;
//Dictionary<string, long> conditions = await snow.GetSnowConditionsAsync();
return(JsonConvert.SerializeObject(conditions));
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Any(x => x is TimeoutException) || ex.GetBaseException() is TimeoutException)
{
//need to tell the user that we timed out after retry
}
}
catch (Exception ex)
{
if (ex is TimeoutException || ex.InnerException is TimeoutException)
{
//implement retry pattern
}
}
throw new ApplicationException();
}
public async Task <IActionResult> Get()
{
try
{
string serviceUri = $"{this.serviceContext.CodePackageActivationContext.ApplicationName}/{this.configSettings.RequestsServiceName}";
ServicePartitionList partitions = await this.fabricClient.QueryManager.GetPartitionListAsync(new Uri(serviceUri));
if (partitions == null || partitions.Count == 0)
{
return(new ContentResult {
StatusCode = 404, Content = "There's no available replica. Please check service status."
});
}
ServicePartitionKey key = new ServicePartitionKey(((Int64RangePartitionInformation)(partitions[0].PartitionInformation)).LowKey);
IRequestManager service = ServiceProxy.Create <IRequestManager>(new Uri(serviceUri), key);
await service.Matchmake(new CancellationToken());
ServiceEventSource.Current.Message($"Matchmaked performed!");
return(this.Ok());
}
catch (FabricNotPrimaryException)
{
return(new ContentResult {
StatusCode = 410, Content = "The primary replica has moved. Please re-resolve the service."
});
}
catch (/*FabricException*/ Exception e)
{
return(new ContentResult {
StatusCode = 503, Content = $"The service was unable to process the request. Please try again. Exception: {e}"
});
}
}
private async Task RegisterGatewayServiceAsync(string backAddress, GatewayOptions gw)
{
// IGatewayServiceManagerActor gateway = ActorProxy.Create<IGatewayServiceManagerActor>(new ActorId("*"), "S-Innovations.ServiceFabric.GatewayApplication", "GatewayServiceManagerActorService");
var partitionKey = gw.Key ?? Context.CodePackageActivationContext.GetServiceManifestName();
var gateway = ServiceProxy.Create <IGatewayManagementService>(
new Uri("fabric:/S-Innovations.ServiceFabric.GatewayApplication/GatewayManagementService"), partitionKey.ToPartitionHashFunction());
await gateway.RegisterGatewayServiceAsync(new GatewayServiceRegistrationData
{
Key = partitionKey, // $"{partitionKey}-{Context.NodeContext.IPAddressOrFQDN}",
IPAddressOrFQDN = Context.NodeContext.IPAddressOrFQDN,
ServerName = gw.ServerName,
ReverseProxyLocation = gw.ReverseProxyLocation ?? "/",
Ssl = gw.Ssl,
BackendPath = backAddress,
ServiceName = Context.ServiceName,
ServiceVersion = Context.CodePackageActivationContext.GetServiceManifestVersion(),
CacheOptions = gw.CacheOptions,
Properties = gw.Properties
});
}
public override async Task Dispatch(Event @event)
{
List <QueryModelBuilder> handlers;
if (_handlers.TryGetValue(@event.GetType(), out handlers))
{
await Task.WhenAll(
handlers.Select(b =>
{
var builderType = b.GetType();
var queryModelBuilderService = ServiceProxy.Create <IQueryModelBuilderService>(
$"{builderType.FullName}, {builderType.Assembly.GetName().Name}",
new Uri("fabric:/CQRSMicroservices.ServiceFabric.Application/QueryModelBuilderService"
));
return(queryModelBuilderService.Handle(@event.ToJson()));
})
);
}
else
{
throw new NotImplementedException($"No handler for eventtype {@event.GetType().FullName}");
}
}
public async Task <IHttpActionResult> Get()
{
ServiceUriBuilder builder = new ServiceUriBuilder("ClusterService");
IClusterService clusterService = ServiceProxy.Create <IClusterService>(builder.ToUri(), new ServicePartitionKey(1));
IEnumerable <ClusterView> clusters = await clusterService.GetClusterListAsync();
return(this.Ok(
clusters.Select(
x => new
{
ClusterId = x.ClusterId,
Name = this.GetClusterName(x.ClusterId),
ApplicationCount = x.ApplicationCount,
ServiceCount = x.ServiceCount,
Capacity = this.GetUserCapacity(x.UserCount, x.MaxUsers),
UserCount = x.UserCount,
MaxUsers = x.MaxUsers,
TimeRemaining = x.TimeRemaining > TimeSpan.Zero
? String.Format("{0:hh\\:mm\\:ss}", x.TimeRemaining)
: "expired"
})));
}
// POST api/analysis
public async Task <HttpResponseMessage> Post()
{
//string partitionKey = Guid.NewGuid().ToString();
Random ram = new Random();
int partitionKey = ram.Next();
byte[] image = await Request.Content.ReadAsByteArrayAsync();
IYasudaAnalysis analysis = ServiceProxy.Create <IYasudaAnalysis>(
new Uri("fabric:/Services/YasudaAnalysis"),
new ServicePartitionKey(partitionKey));
await analysis.StartAnalysis(partitionKey, image);
var bodystr = @"{""TaskId"":""" + partitionKey + @"""}";
var bodycont = new StringContent(bodystr);
bodycont.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var resp = new HttpResponseMessage();
resp.Content = bodycont;
//resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(resp);
}
//Тест. Nunit вылетает, возможно плохо взаимодействует с fabric service
private static void Main(string[] args)
{
var passport = new Passport()
{
Address = "Звездная",
Birthday = new DateTime(1980, 4, 3),
Firstname = "Дарт",
IssuedBy = "Космос",
IssuedDepartment = "Космический Альянс",
IssuedOn = new DateTime(1980, 4, 3),
Lastname = "Вейдер",
Number = "01",
Secondname = "",
Series = "01",
Sex = SexType.Male
};
var calculatorClient = ServiceProxy.Create <IDataService>(new Uri("fabric:/DataServiceApplication/DataService"));
calculatorClient.SavePassportAsync(passport).Wait();
Console.WriteLine("No exceptions");
}
public async Task UpdateMultipleTimes()
{
ServicePartitionKey partitionKey;
using (var client = new FabricClient())
{
var partitions = await client.QueryManager.GetPartitionListAsync(SetupApp.TestKeyValueStatefulUri);
var partition = (Int64RangePartitionInformation)partitions.First().PartitionInformation;
partitionKey = new ServicePartitionKey(partition.LowKey);
while (true)
{
var replicas = await client.QueryManager.GetReplicaListAsync(partition.Id).ConfigureAwait(false);
if (replicas.Count == 3 && replicas.All(r => r.HealthState == HealthState.Ok))
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
}
var service = ServiceProxy.Create <ITestKeyValueStateful>(SetupApp.TestKeyValueStatefulUri, partitionKey);
var spans = new List <TimeSpan>();
for (var i = 0; i < 1000; i++)
{
spans.Add(await service.UpdateValue());
}
spans.Sort();
Console.WriteLine($"Min time: {spans.First()}");
Console.WriteLine($"Max time: {spans.Last()}");
}
public void ConfigureService([FromBody] JObject content, string primaryClusterAddress, string primaryHttpEndpointEncoded, string primaryThumbprint, string primaryCommonName,
string secondaryClusterAddress, string secondaryHttpEndpointEncoded, string secondaryThumbprint, string secondaryCommonName)
{
string[] primaryClusterDetails = primaryClusterAddress.Split(':');
string[] secondaryClusterDetails = secondaryClusterAddress.Split(':');
string primaryHttpEndpoint = Utility.decodeHTTPString(primaryHttpEndpointEncoded);
string secondaryHttpEndpoint = Utility.decodeHTTPString(secondaryHttpEndpointEncoded);
ClusterDetails primaryCluster = new ClusterDetails(primaryClusterDetails[0], primaryHttpEndpoint, primaryClusterAddress, primaryThumbprint, primaryCommonName);
ClusterDetails secondaryCluster = new ClusterDetails(secondaryClusterDetails[0], secondaryHttpEndpoint, secondaryClusterAddress, secondaryThumbprint, secondaryCommonName);
JArray serviceData = (JArray)content["ServiceList"];
JArray policiesData = (JArray)content["PoliciesList"];
List <string> serviceDataObj = JsonConvert.DeserializeObject <List <string> >(serviceData.ToString());
List <PolicyStorageEntity> policicesList = JsonConvert.DeserializeObject <List <PolicyStorageEntity> >(policiesData.ToString());
FabricClient fabricClient = new FabricClient();
ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFAppDRTool/RestoreService")).Result;
foreach (Partition partition in partitionList)
{
var int64PartitionInfo = partition.PartitionInformation as Int64RangePartitionInformation;
long lowKey = (long)int64PartitionInfo?.LowKey;
IRestoreService restoreServiceClient = ServiceProxy.Create <IRestoreService>(new Uri("fabric:/SFAppDRTool/RestoreService"), new ServicePartitionKey(lowKey));
try
{
restoreServiceClient.ConfigureService(serviceDataObj[0], serviceDataObj[1], policicesList, primaryCluster, secondaryCluster);
}
catch (Exception ex)
{
ServiceEventSource.Current.Message("Web Service: Exception configuring the service {0}", ex);
throw;
}
}
}
public Task Invoke(IDictionary <string, object> environment)
{
try
{
var counterServiceProxy = ServiceProxy.Create <ICounterService>(new Uri("fabric:/CounterServiceApplication/CounterService"), new ServicePartitionKey(1));
long result = counterServiceProxy.GetValueAsync().Result;
string responseText = "The value of counter is : " + result;
byte[] responseBytes = Encoding.UTF8.GetBytes(responseText);
// See http://owin.org/spec/owin-1.0.0.html for standard environment keys.
var responseStream = (Stream)environment["owin.ResponseBody"];
var responseHeaders = (IDictionary <string, string[]>)environment["owin.ResponseHeaders"];
responseHeaders["Content-Length"] = new string[] { responseBytes.Length.ToString(CultureInfo.InvariantCulture) };
responseHeaders["Content-Type"] = new string[] { "text/plain" };
return(responseStream.WriteAsync(responseBytes, 0, responseBytes.Length));
}
catch (Exception Ex)
{
ServiceEventSource.Current.Message("Invoke failed with Exception: {0}", Ex);
throw;
}
}
internal static async Task <IGatewayMonitor> GetGatewaySupervisorServiceAsync(string nodeId, bool createIfnotExist)
{
var appName = "fabric:/DeviceMonitorApp";
var serviceName = $"{appName}/{nodeId}";
var fabricClient = new FabricClient();
var serviceAlreadyExists = false;
try
{
var services = await fabricClient.QueryManager.GetServiceListAsync(new Uri(appName));
serviceAlreadyExists = services.Select(s => s.ServiceName).Contains(new Uri(serviceName));
}
catch (FabricElementNotFoundException) { }
if (!serviceAlreadyExists && createIfnotExist)
{
StatefulServiceDescription serviceDescription = new StatefulServiceDescription();
serviceDescription.ApplicationName = new Uri(appName);
serviceDescription.PartitionSchemeDescription = new SingletonPartitionSchemeDescription();
serviceDescription.ServiceName = new Uri(serviceName);
serviceDescription.ServiceTypeName = "GatewayMonitorServiceType";
serviceDescription.HasPersistedState = true;
serviceDescription.MinReplicaSetSize = 3;
serviceDescription.TargetReplicaSetSize = 3;
await fabricClient.ServiceManager.CreateServiceAsync(serviceDescription);
//TODO:Call GetService and then get partition instead of delay
await Task.Delay(TimeSpan.FromSeconds(30));
}
else if (!serviceAlreadyExists)
{
throw new ArgumentException("Invalid Arguments");
}
return(ServiceProxy.Create <IGatewayMonitor>(new Uri(serviceName)));
}
/// <summary>
/// Drains the queue of completed restock requests sends them to InventoryService.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task RunAsync(CancellationToken cancellationToken)
{
IReliableQueue <RestockRequest> completedRequests = await this.StateManager.GetOrAddAsync <IReliableQueue <RestockRequest> >(CompletedRequestsQueueName);
while (!cancellationToken.IsCancellationRequested)
{
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ConditionalValue <RestockRequest> result = await completedRequests.TryDequeueAsync(tx, TxTimeout, cancellationToken);
if (result.HasValue)
{
ServiceUriBuilder builder = new ServiceUriBuilder(InventoryServiceName);
IInventoryService inventoryService = ServiceProxy.Create <IInventoryService>(builder.ToUri(), result.Value.ItemId.GetPartitionKey());
await inventoryService.AddStockAsync(result.Value.ItemId, result.Value.Quantity);
ServiceEventSource.Current.ServiceMessage(
this,
"Adding stock to inventory service. ID: {0}. Quantity: {1}",
result.Value.ItemId,
result.Value.Quantity);
}
// This commits the dequeue operations.
// If the request to add the stock to the inventory service throws, this commit will not execute
// and the items will remain on the queue, so we can be sure that we didn't dequeue items
// that didn't get saved successfully in the inventory service.
// However there is a very small chance that the stock was added to the inventory service successfully,
// but service execution stopped before reaching this commit (machine crash, for example).
await tx.CommitAsync();
}
await Task.Delay(CompletedRequestsBatchInterval, cancellationToken);
}
}
/// <summary>
/// This is the main entry point for your service instance.
/// </summary>
/// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service instance.</param>
protected override async Task RunAsync(CancellationToken cancellationToken)
{
//await Task.Delay(TimeSpan.FromSeconds(45));
var dataSource = ServiceProxy.Create <IQueue>(new Uri("fabric:/ElasticScaleDemo/DataSource"), new ServicePartitionKey(0));
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
var item = await dataSource.DequeueAsync();
ServiceEventSource.Current.Message("Dequeued: {item}");
}
catch (QueueEmptyException queueException)
{
// no op
}
await Task.Delay(TimeSpan.FromSeconds(_timeToWorkInSeconds));
}
}
public async Task <IEnumerable <InventoryItemView> > GetStore()
{
ServiceUriBuilder builder = new ServiceUriBuilder(InventoryServiceName);
Uri serviceName = builder.ToUri();
List <InventoryItemView> itemList = new List <InventoryItemView>();
ServicePartitionList partitions = await fc.QueryManager.GetPartitionListAsync(serviceName);
foreach (Partition p in partitions)
{
long minKey = (p.PartitionInformation as Int64RangePartitionInformation).LowKey;
IInventoryService inventoryServiceClient = ServiceProxy.Create <IInventoryService>(serviceName, new ServicePartitionKey(minKey));
IEnumerable <InventoryItemView> result = await inventoryServiceClient.GetCustomerInventoryAsync(CancellationToken.None);
if (result != null)
{
itemList.AddRange(result);
}
}
return(itemList);
}
/// <summary>
/// Updates Windows Update Operation Result
/// </summary>
/// <param name="fabricClient">fabric client to carry out operations on service fabric</param>
/// <param name="applicationUri">Application name of the Patch Orchestration Application</param>
/// <param name="operationResult">Result of Windows Update operation <see cref="WindowsUpdateOperationResult"/></param>
/// <param name="timeout">Timeout for the operation</param>
/// <param name="cancellationToken">Cancellation token to cancel this async operation</param>
/// <returns>A Task representing the asnyc operation, result of the task would be <see cref="NodeAgentSfUtilityExitCodes"/></returns>
internal static async Task <NodeAgentSfUtilityExitCodes> UpdateWuOperationResult(
FabricClient fabricClient,
Uri applicationUri,
WindowsUpdateOperationResult operationResult,
TimeSpan timeout,
CancellationToken cancellationToken)
{
try
{
IDataInterface coordinatorServiceDataClient = ServiceProxy.Create <IDataInterface>(new Uri(applicationUri + CoordinatorServiceSuffix));
await
coordinatorServiceDataClient.UpdateWuOperationResult(
operationResult,
timeout,
cancellationToken);
return(NodeAgentSfUtilityExitCodes.Success);
}
catch (Exception e)
{
ServiceEventSource.Current.ErrorMessage(
String.Format("CoordinatorServiceHelper.UpdateWuOperationResult failed. Exception details {0}", e));
if (e is FabricTransientException)
{
return(NodeAgentSfUtilityExitCodes.RetryableException);
}
else if (e is FabricServiceNotFoundException)
{
return(NodeAgentSfUtilityExitCodes.ServiceNotFound);
}
else
{
return(NodeAgentSfUtilityExitCodes.Failure);
}
}
}
public async Task <string> DisconfigureService([FromBody] JObject content, String primaryCluster, String secondaryCluster)
{
bool successfullyRemoved = true;
JArray serviceData = (JArray)content["ServiceList"];
List <string> serviceDataObj = JsonConvert.DeserializeObject <List <string> >(serviceData.ToString());
FabricClient fabricClient = new FabricClient();
ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFAppDRTool/RestoreService")).Result;
foreach (Partition partition in partitionList)
{
var int64PartitionInfo = partition.PartitionInformation as Int64RangePartitionInformation;
long lowKey = (long)int64PartitionInfo?.LowKey;
IRestoreService restoreServiceClient = ServiceProxy.Create <IRestoreService>(new Uri("fabric:/SFAppDRTool/RestoreService"), new ServicePartitionKey(lowKey));
try
{
string serviceRemoved = await restoreServiceClient.DisconfigureService(serviceDataObj[0], primaryCluster, secondaryCluster);
if (serviceRemoved == null)
{
successfullyRemoved = false;
}
}
catch (Exception ex)
{
ServiceEventSource.Current.Message("Web Service: Exception Disconfiguring Service {0}", ex);
throw;
}
}
if (successfullyRemoved)
{
return(serviceDataObj[0]);
}
return(null);
}
/// <summary>
/// This is the main entry point for your service instance.
/// </summary>
/// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service instance.</param>
protected override async Task RunAsync(CancellationToken cancellationToken)
{
long iterations = 0;
//connection string for the queue
var connectionString = "Endpoint=sb://themayor.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=<keyname>";
var queueName = "hackprocessdemo";
var client = QueueClient.CreateFromConnectionString(connectionString, queueName);
string nodeip = this.Context.NodeContext.IPAddressOrFQDN;
string nodename = this.Context.NodeContext.NodeName;
//using an event message listener
client.OnMessage(message =>
{
var bodyText = message.GetBody <string>();
var msgId = message.MessageId;
bodyText = "SF: " + nodeip + " - Nodename: " + nodename + " --- " + bodyText;
var queuestore = ServiceProxy.Create <queueItemStorageSrv.IQueueStore>(new Uri("fabric:/queueworkerStateless/queueItemStorageSrv"),
new Microsoft.ServiceFabric.Services.Client.ServicePartitionKey(1));
var successful = queuestore.SetQueueInformation(bodyText);
if (successful.Result)
{
ServiceEventSource.Current.ServiceMessage(this.Context, "{0} added message to storage", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
}
});
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
ServiceEventSource.Current.ServiceMessage(this.Context, "Working-{0} iteration-{1}", nodename, iterations);
await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken);
}
}
static void TestMisc()
{
var proxy = ActorProxy.Create <IKing>(new ActorId("1"), "fabric:/MessyChessApplication", "King");
proxy.SetInfoAsync(new ChessPieceInfo {
ActorId = "1", PieceType = ChessPieceType.King, Team = 1, X = 1, Y = 1
}).Wait();
var king = proxy.GetInfoAsync().Result;
Console.WriteLine(king.PieceType);
Console.ReadLine();
Random rand = new Random();
while (true)
{
int x = 0;
int y = 0;
while (x < 8 && y < 8 || x >= 16 && y < 8 ||
x < 8 && y >= 16 || x >= 16 && y >= 16)
{
x = rand.Next(0, 24);
y = rand.Next(0, 24);
}
string partition = ((y / 4) * 6 + (x / 4) + 1).ToString();
IChessboard boardShard = ServiceProxy.Create <IChessboard>(new Uri("fabric:/MessyChessApplication/Chessboard"), new ServicePartitionKey(partition));
boardShard.PutAPieceAsync(new ChessPieceInfo {
ActorId = "1", PieceType = ChessPieceType.King, Team = rand.Next(1, 5), X = x, Y = y
}).Wait();
IChessboardObserver board = ServiceProxy.Create <IChessboardObserver>(new Uri("fabric:/MessyChessApplication/ChessboardObserver"));
var boardInfo = board.GetBoard(new CancellationToken()).Result;
PaintBoard(boardInfo);
Thread.Sleep(10);
}
}
public async Task <Job> NewJob(int time)
{
var j = new Job()
{
NodeName = "",
Id = Guid.NewGuid().ToString(),
Status = JobStatus.Waiting,
InitData = time.ToString()
};
lock (jobs)
{
jobs.AddOrUpdate(j.Id, j, (o, n) => j);
}
var key = Fnv1aHashCode.Get64bitHashCode(j.Id);
IJobWorker proxy = ServiceProxy.Create <IJobWorker>(new Uri("fabric:/Compute2/PartitionedComputeService"),
new ServicePartitionKey(key));
proxy.Execute(j).ConfigureAwait(false);
return(j);
}
public TServiceInterface Create <TServiceInterface>(string partitionKey, Uri serviceName) where TServiceInterface : IService
{
return(ServiceProxy.Create <TServiceInterface>(serviceName, new Microsoft.ServiceFabric.Services.Client.ServicePartitionKey(partitionKey)));
}
public IGiftProcessingService Create()
{
return(ServiceProxy.Create <IGiftProcessingService>(FabricUri, new ServicePartitionKey(1)));
}
public TServiceInterface Create <TServiceInterface>(Uri serviceName) where TServiceInterface : IService
{
return(ServiceProxy.Create <TServiceInterface>(serviceName, new Microsoft.ServiceFabric.Services.Client.ServicePartitionKey(GetNextInt64Simple())));
}
/// <summary>
/// Gets the proxy.
/// </summary>
/// <param name="region">The region.</param>
/// <param name="key">The key.</param>
/// <returns></returns>
private IDistribuitedCache GetProxy(string region, string key = null)
{
var partitionKey = CalculatePartitionKey(region, key, this.numberOfPartitions);
return(ServiceProxy.Create <IDistribuitedCache>(this.serviceUri, partitionKey));
}
private IProductCatalogService GetProductCatalogService()
{
return(ServiceProxy.Create <IProductCatalogService>(
new Uri("fabric:/ECommerce/ECommerce.ProductCatalog"),
new ServicePartitionKey(0)));
}
public ProductController()
{
_catalogService = ServiceProxy.Create <IProductCatalogService>(
new Uri("fabric:/ECommerce/ECommerce.ProductCatalog"),
new ServicePartitionKey(0));
}
public UsersController()
{
this._userService = ServiceProxy.Create <IUserService>(
new Uri($"{ FabricRuntime.GetActivationContext().ApplicationName }/Blissmo.UserService"),
new ServicePartitionKey(0));
}
public ProductsController()
{
this.productCatalogService = ServiceProxy.Create <IProductCatalogService>(
new Uri("fabric:/ECommerce/ECommerce.ProductCatalog"),
new Microsoft.ServiceFabric.Services.Client.ServicePartitionKey(0));
}
public OnlineForm(StatefulServiceContext context)
: base(context)
{
_dbService = ServiceProxy.Create <IDBService>(new Uri("fabric:/ADC/ADC.Stateful.DBService"), new ServicePartitionKey(0));
}
public GameController()
{
ServicePartitionKey servicePartitionKey = new ServicePartitionKey(0);
matchMaking = ServiceProxy.Create <IMatchMaking>(new Uri("fabric:/TicTacToe/MatchMaking"), servicePartitionKey);
}
