protected override void GenerateAggregateClient() { if (DomainId != null) { AggregateClient = Clients.CreateEventActor(ContainerName, DomainName, null); } }
public async Task <IHttpActionResult> ReloadEvent(string eventid) { var error = ""; var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService); handler.Start(LOG_TAG, "ReloadEvent", GetServiceProperties()); try { IActorLocationService locator = ServiceFactory.GetInstance().GetActorLocationService(); IEventActor eventActor = locator.Create <IEventActor>(new ActorId(eventid), Constants.ContosoEventsApplicationName); await eventActor.Reload(); return(Ok("Done")); } catch (Exception ex) { error = ex.Message; return(BadRequest(ex.Message)); } finally { handler.Stop(error); } }
public async Task CancelOrder() { var error = ""; var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService); handler.Start(LOG_TAG, "CancelOrder", GetActorProperties()); try { var state = await this.StateManager.GetStateAsync <TicketOrder>(ActorStatePropertyName); if (state == null) { handler.Info("Cancel order is null"); return; } //TODO: Task 1.1 - Acquire an instance of the Actor IEventActor eventActor = this.ActorLocationService .Create <IEventActor>(new ActorId(state.EventId), Constants.ContosoEventsApplicationName); //TODO: Task 1.2 - Invoke the CancelTicket operation with the supplied state await eventActor.CancelTickets(state); // Refund credit card await this.PaymentProcessorService.Refund(state); //TODO: Task 1.3 - Update the state object to reflect that the order is cancelled state.CancellationDate = DateTime.Now; state.IsFulfilled = false; state.IsCancelled = true; //TODO: Exercise 6 - Task 1 //state.Status = OrderStatuses.Cancelled; //TODO: Task 1.4 - Save the updated state //await SetEntityStateAsync(/* complete this */); await SetEntityStateAsync(state); // Notify the user await this.NotificationService.Notify(state); } catch (Exception ex) { error = ex.Message; } finally { handler.Stop(error); if (!string.IsNullOrEmpty(error)) { this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("CancelOrder", error)); } } }
public async Task ProcessOrder(TicketOrder order) { var error = ""; var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService); handler.Start(LOG_TAG, "ProcessOrder", GetActorProperties()); try { if (order == null) { handler.Info("Process order is null"); return; } var state = await this.StateManager.GetStateAsync <TicketOrder>(ActorStatePropertyName); state = order; // Validate the order bool isValid = true; try { TicketOrder.Validate(state); } catch (Exception e) { state.Note = e.Message; isValid = false; } if (isValid) { // Validate the event TicketEvent tEvent = await this.DataStoreService.GetEventById(order.EventId); if (tEvent == null) { state.FulfillDate = null; state.IsFulfilled = false; state.Note = "The Event ID is not valid!"; //TODO: Exercise 6 - Task 1 //state.Status = OrderStatuses.Invalid; } else { state.PricePerTicket = tEvent.PricePerTicket; state.Currency = tEvent.Currency; state.Price = state.Tickets * state.PricePerTicket; // Locate the event actor IEventActor eventActor = this.ActorLocationService.Create <IEventActor>(new ActorId(order.EventId), Constants.ContosoEventsApplicationName); bool isAvailable = await eventActor.ReserveTickets(order); if (isAvailable || !SettingService.IsTicketAvailabilityCheck()) { // Charge credit card string confirmationNumber = await this.PaymentProcessorService.Authorize(order); if (!string.IsNullOrEmpty(confirmationNumber)) { state.PaymentProcessorConfirmation = confirmationNumber; state.FulfillDate = DateTime.Now; state.IsFulfilled = true; //TODO: Exercise 6 - Task 1 //state.Status = OrderStatuses.Fufilled; } else { state.FulfillDate = null; state.IsFulfilled = false; state.Note = "Credit card failed to authorize!"; await eventActor.FailTickets(order); //TODO: Exercise 6 - Task 1 //state.Status = OrderStatuses.CreditCardDenied; } } else { state.FulfillDate = null; state.IsFulfilled = false; state.Note = "Event Tickets are exhausted!"; //TODO: Exercise 6 - Task 1 //state.Status = OrderStatuses.TicketsExhausted; } } } else { state.FulfillDate = null; state.IsFulfilled = false; //TODO: Exercise 6 - Task 1 //state.Status = OrderStatuses.Invalid; } // Make sure the state is saved await SetEntityStateAsync(state); // Externalize the state await this.ExternalizationService.Externalize(state); // Notify the user await this.NotificationService.Notify(state); } catch (Exception ex) { error = ex.Message; } finally { handler.Stop(error); if (!string.IsNullOrEmpty(error)) { this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("ProcessOrder", error)); } } }
public async Task <IHttpActionResult> UpdateServiceHealthState(UpdateHealthRequest request) { var error = ""; var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService); handler.Start(LOG_TAG, "UpdateServiceHealthState", GetServiceProperties()); try { UpdateHealthRequest.Validate(request); int ticketOrderServices = 0; int ticketOrderActors = 0; int eventActors = 0; ServiceLocationService locator = new ServiceLocationService(); UriBuilderService builder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsTicketOrderServiceName); ServicePartitionList partitions = await _fabricClient.QueryManager.GetPartitionListAsync(builder.ToUri()); foreach (Partition p in partitions) { long minKey = (p.PartitionInformation as Int64RangePartitionInformation).LowKey; ITicketOrderService dispenderService = locator.Create <ITicketOrderService>(builder.ToUri()); await dispenderService.UpdateHealthState(GetHealthStateFromString(request.State), request.Message); ticketOrderServices++; } ActorLocationService actorLocator = new ActorLocationService(); UriBuilderService orderActorBuilder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsTicketOrderActorName); ServicePartitionList orderActorPartitions = await _fabricClient.QueryManager.GetPartitionListAsync(orderActorBuilder.ToUri()); foreach (Partition p in orderActorPartitions) { string minKey = (p.PartitionInformation as Int64RangePartitionInformation).Id.ToString(); ITicketOrderActor actor = actorLocator.Create <ITicketOrderActor>(new ActorId(minKey), Constants.ContosoEventsApplicationName); await actor.UpdateHealthState(GetHealthStateFromString(request.State), request.Message); ticketOrderActors++; // May require contiunuation } IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService); List <TicketEvent> events = await dataService.GetEvents(); UriBuilderService eventActorBuilder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsEventActorName); foreach (var tEvent in events) { IEventActor actor = actorLocator.Create <IEventActor>(new ActorId(tEvent.Id), Constants.ContosoEventsApplicationName); await actor.UpdateHealthState(GetHealthStateFromString(request.State), request.Message); eventActors++; // May require contiunuation } return(Ok("Done: " + ticketOrderServices + "|" + ticketOrderActors + "|" + eventActors)); } catch (Exception ex) { error = ex.Message; return(BadRequest(ex.Message)); } finally { handler.Stop(error); } }
// ITicketDispenserService Interface Implementation public async Task <string> EnqueueOrder(TicketOrder order) { var error = ""; var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService); handler.Start(LOG_TAG, "EnqueueOrder", GetServiceProperties()); string orderId = Guid.NewGuid().ToString(); bool blProceed = true; try { // Do some sanity checking TicketOrder.Validate(order); // Quick check to see if tickets are available if (SettingService.IsTicketAvailabilityCheck()) { IEventActor eventActor = this.ActorLocationService.Create <IEventActor>(new ActorId(order.EventId), Constants.ContosoEventsApplicationName); if (!await eventActor.CheckTickets(order)) { handler.Info("Processing order - Event Id: " + order.EventId + " - Order Id: " + orderId + " - tickets: " + order.Tickets + " - Tickets are exhausted!"); // Do not throw an exception because we will get a health issue // throw new Exception("Tickets are exhausted!"); // Need to alert the admin only as tickets are exhausted // Prevent proceeding with the order blProceed = false; // Reset the order id to indicate to the Web API client that the order did not go through orderId = ""; } } if (blProceed) { order.Id = orderId; handler.Info("Processing order - Event Id: " + order.EventId + " - Order Id: " + orderId + " - tickets: " + order.Tickets); //TODO: Task 2.1 - Get (or create) a reliable queue called "OrderQueue" in this partition. //var requests = await this.StateManager./*...complete this...*/<IReliableQueue<TicketOrder>>(OrderQueueName); var requests = await this.StateManager.GetOrAddAsync <IReliableQueue <TicketOrder> >(OrderQueueName); //TODO: Task 2.2 - Create a new transaction scope //using (var tx = this.StateManager./*...complete this...*/) //{ // TODO: Task 2.3 - Enqueue the order to the reliable queue within the transaction //await requests.EnqueueAsync(/*...complete this...*/, /*...complete this...*/); // TODO: Task 2.4 - Commit the transaction if enqueue was successful //await tx./*...complete this...*/(); //} using (var tx = this.StateManager.CreateTransaction()) { await requests.EnqueueAsync(tx, order); await tx.CommitAsync(); } } } catch (Exception ex) { error = ex.Message; throw ex; } finally { handler.Stop(error); if (!string.IsNullOrEmpty(error)) { this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("EnqueueOrder", error)); } } return(orderId); }