public async Task AddAsync(ITransaction tx, TKey key, TValue value) { if (reliableDictionary == null) { await InitializeReliableDictionary(); } await reliableDictionary.AddAsync(tx, key, value); }
public async Task <IActionResult> Post(string id) { IReliableDictionary <string, Game> gamesDictionary = await _stateManager.GetOrAddAsync <IReliableDictionary <string, Game> >("games"); using (ITransaction tx = _stateManager.CreateTransaction()) { bool gameExists = await gamesDictionary.ContainsKeyAsync(tx, id); if (gameExists) { return(BadRequest("Game already exists")); } var game = new Game { State = new TicTacToeState() { Board = new string[9], IsXTurn = true, }, UserRoles = new Dictionary <string, string>() }; await gamesDictionary.AddAsync(tx, id, game); await tx.CommitAsync(); return(Ok()); } }
/// <summary> /// Inner GetOrAdd for a collection. /// This method adds new metric collection type information for new collections as part of the same transaction. /// </summary> /// <param name="tx"></param> /// <param name="type"></param> /// <param name="name"></param> /// <param name="timeout"></param> /// <returns></returns> private async Task <ConditionalValue <IReliableState> > TryCreateOrGetMetricReliableCollectionAsync(ITransaction tx, Type type, Uri name, TimeSpan timeout) { if (type.GetGenericTypeDefinition() == typeof(IReliableDictionary <,>)) { // Store the given type information for the collection with the given name. // The type information is used to recreate the collection during enumeration. IReliableDictionary <string, string> metricDictionaryTypes = await this.GetTypeNameDictionaryAsync(); if (!(await metricDictionaryTypes.ContainsKeyAsync(tx, name.ToString(), LockMode.Update))) { await metricDictionaryTypes.AddAsync(tx, name.ToString(), type.AssemblyQualifiedName); } IReliableDictionary <BinaryValue, BinaryValue> innerStore = await this.stateManagerReplica.GetOrAddAsync <IReliableDictionary <BinaryValue, BinaryValue> >(tx, name, timeout); return(new ConditionalValue <IReliableState>( true, MetricReliableDictionaryActivator.CreateFromReliableDictionaryType( type, innerStore, new BinaryValueConverter(name, this.serializerResolver), this.config))); } return(new ConditionalValue <IReliableState>(false, null)); }
/// <summary> /// This method executes on the bidder's partition. /// Called by web: priority 0 /// </summary> public async Task <ItemInfo> CreateItemAsync(String sellerEmail, String itemName, String imageUrl, DateTime expiration, Decimal startAmount, CancellationToken cancellationToken) { // NOTE: If items gets large, old item value (but not key) can move to warm storage // If user exists, create item & transactionally and it to user's items dictionary & unexpired items dictionary Email _sellerEmail = Email.Parse(sellerEmail); using (var tx = CreateTransaction()) { var cr = await m_users.TryGetValueAsync(tx, _sellerEmail); if (!cr.HasValue) { throw new InvalidOperationException($"Seller '{_sellerEmail}' doesn't exist."); } // Look up user's (seller's) auction item dictionary & add the new item to it: IReliableDictionary <ItemId, ItemInfo> userItems = await GetSellerItemsAsync(_sellerEmail); ItemId itemId = ItemId.Parse(_sellerEmail, itemName); ItemInfo item = new ItemInfo(itemId, imageUrl, expiration, new[] { new Bid(_sellerEmail, startAmount) }); // Seller places first bid try { await userItems.AddAsync(tx, itemId, item); // TODO: If already exists } catch (Exception ex) { throw new InvalidOperationException($"Seller '{itemId.Seller}' is already selling '{itemId.ItemName}'.", ex); } await m_unexpiredItems.AddAsync(tx, itemId); await tx.CommitAsync(); return(item); } }
public async Task <IActionResult> Put(string name, [FromBody] ValueViewModel value) { try { IReliableDictionary <string, string> dictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, string> >(ValuesDictionaryName); using (ITransaction tx = this.stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, name, value.Value); await tx.CommitAsync(); } } catch (ArgumentException) { return(new ContentResult { StatusCode = 400, Content = $"A value with name {name} already exists." }); } catch (FabricNotPrimaryException) { return(new ContentResult { StatusCode = 503, Content = "The primary replica has moved. Please re-resolve the service." }); } catch (FabricException) { return(new ContentResult { StatusCode = 503, Content = "The service was unable to process the request. Please try again." }); } return(this.Ok()); }
/// <summary> /// Adds elements to the queuestorage /// </summary> /// <param name="newMessage"></param> /// <returns></returns> public async Task <bool> SetQueueInformation(string newMessage) { try { CancellationToken token = this.serviceCancellationToken; IReliableDictionary <long, string> queueinfo = await this.StateManager.GetOrAddAsync <IReliableDictionary <long, string> >("QueueData"); using (ITransaction tx = this.StateManager.CreateTransaction()) { long newid = Environment.TickCount; if (!await queueinfo.ContainsKeyAsync(tx, newid)) { await queueinfo.AddAsync(tx, newid, newMessage); } await tx.CommitAsync(); } return(true); } catch { return(false); } }
private async Task AddClusters(ITransaction tx, IReliableDictionary <int, Cluster> dictionary, int count, Func <Cluster> newCluster) { for (int i = 0; i < count; ++i) { await dictionary.AddAsync(tx, GetRandom(), newCluster()); } }
private async Task ExecuteAddOrderAsync(Order order, IReliableDictionary <string, Order> orders) { using (ITransaction tx = this.stateManager.CreateTransaction()) { await orders.AddAsync(tx, order.Id, order); await tx.CommitAsync(); } }
public async Task <IActionResult> NewGame(string roomid, string playerid, string playerdata, string roomtype) { try { if (!RoomManager.IsActive) { return new ContentResult { StatusCode = 503, Content = "Service is still starting up. Please retry." } } ; Player player = JsonConvert.DeserializeObject <Player>(playerdata); //get the general room dictionary IReliableDictionary <string, Room> roomdict = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, Room> >(RoomDictionaryName); //get or add the active room we will put this player in IReliableDictionary <string, ActivePlayer> activeroom = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, ActivePlayer> >(roomid); using (ITransaction tx = this.stateManager.CreateTransaction()) { //Find the room in the room dictionary ConditionalValue <Room> roomOption = await roomdict.TryGetValueAsync(tx, roomid, LockMode.Update); if (!roomOption.HasValue) { //Scenario: Room does not exist yet await roomdict.AddAsync(tx, roomid, new Room(1, roomtype)); } else { //Scenario: Room does exist Room newRoom = roomOption.Value; newRoom.NumPlayers++; await roomdict.SetAsync(tx, roomid, newRoom); } //Add the data to that room await activeroom.SetAsync(tx, playerid, new ActivePlayer(player, DateTime.UtcNow)); await tx.CommitAsync(); } return(new ContentResult { StatusCode = 200, Content = "Successfully Logged In" }); } catch (Exception e) { return(exceptionHandler(e)); } }
/// <summary> /// This method saves the description (eventString) and timestamp of the recentmost induced fault as /// a ChaosEntry in a Reliable Dictionary /// </summary> /// <param name="eventString"></param> /// <returns>A task to await on</returns> private async Task StoreEventAsync(string eventString) { ServiceEventSource.Current.ServiceMessage(this, "ChaosTest: {0}", eventString); IReliableDictionary <string, long> eventCount = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, long> >(StringResource.EventCountKey); IReliableDictionary <string, DateTime> startTime = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, DateTime> >(StringResource.StartTimeKey); IReliableDictionary <long, ChaosEntry> savedEvents = await this.StateManager.GetOrAddAsync <IReliableDictionary <long, ChaosEntry> >(StringResource.SavedEventsKey); using (ITransaction tx = this.StateManager.CreateTransaction()) { if (!await startTime.ContainsKeyAsync(tx, StringResource.StartTimeKey)) { await startTime.AddAsync(tx, StringResource.StartTimeKey, DateTime.UtcNow); } if (!await eventCount.ContainsKeyAsync(tx, StringResource.EventCountKey)) { await eventCount.AddAsync(tx, StringResource.EventCountKey, 0); } ConditionalValue <long> result = await eventCount.TryGetValueAsync(tx, StringResource.EventCountKey, LockMode.Update); if (result.HasValue) { long currentCount = result.Value; // If we have HistoryLength number of events, we make room for new events by removing oldest ones, // always keeping HistoryLength number of recentmost events on the show on the webpage. if (currentCount > Constants.HistoryLength - 1) { await savedEvents.TryRemoveAsync(tx, currentCount - Constants.HistoryLength + 1); } ChaosEntry chaosEntry = new ChaosEntry { Record = eventString, TimeStamp = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture) }; await savedEvents.AddAsync(tx, ++currentCount, chaosEntry); await eventCount.SetAsync(tx, StringResource.EventCountKey, currentCount); await tx.CommitAsync(); } } }
private async Task Populate(CancellationToken cancellationToken) { IReliableDictionary <string, string> list = await this.GetListAsync(); using (ITransaction tx = this.stateManager.CreateTransaction()) { await list.AddAsync(tx, Guid.NewGuid().ToString(), DateTime.Now.ToString()); await tx.CommitAsync(); } }
private async Task AddToHistoryAsync(CheckoutSummary checkout) { IReliableDictionary <DateTime, CheckoutSummary> history = await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >("history"); using (ITransaction transaction = StateManager.CreateTransaction()) { await history.AddAsync(transaction, checkout.Date, checkout); await transaction.CommitAsync(); } }
private async Task AddToHistoryAsync(CheckoutSummary summary) { IReliableDictionary <DateTime, CheckoutSummary> history = await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >(HISTORY_COLLECTION); using (ITransaction tx = StateManager.CreateTransaction()) { await history.AddAsync(tx, summary.Date, summary); await tx.CommitAsync(); } }
private static async Task SaveToCache( string query, IReliableDictionary <string, CachedItem <SearchOutput> > cache, SearchOutput output, ITransaction tx) { await cache.AddAsync(tx, query, new CachedItem <SearchOutput> { CachedAt = DateTime.UtcNow, Data = output }); }
/// <summary> /// Adds clusters by the given amount without going over the max threshold and without resulting in below the min threshold. /// </summary> /// <param name="targetCount"></param> /// <returns></returns> internal async Task BalanceClustersAsync(int target) { Random random = new Random(); IReliableDictionary <int, Cluster> clusterDictionary = await this.reliableStateManager.GetOrAddAsync <IReliableDictionary <int, Cluster> >(ClusterDictionaryName); using (ITransaction tx = this.reliableStateManager.CreateTransaction()) { var activeClusters = this.GetActiveClusters(clusterDictionary); int activeClusterCount = activeClusters.Count(); if (target < this.Config.MinimumClusterCount) { target = this.Config.MinimumClusterCount; } if (target > this.Config.MaximumClusterCount) { target = this.Config.MaximumClusterCount; } if (activeClusterCount < target) { int limit = Math.Min(target, this.Config.MaximumClusterCount); for (int i = 0; i < limit - activeClusterCount; ++i) { await clusterDictionary.AddAsync(tx, random.Next(), new Cluster()); } await tx.CommitAsync(); } if (activeClusterCount > target) { var removeList = activeClusters .Where(x => x.Value.Users.Count == 0) .Take(Math.Min(activeClusterCount - this.Config.MinimumClusterCount, activeClusterCount - target)); foreach (var item in removeList) { Cluster value = item.Value; value.Status = ClusterStatus.Remove; await clusterDictionary.SetAsync(tx, item.Key, value); } await tx.CommitAsync(); } } }
public async Task <IActionResult> Post([FromRoute] string name) { ServiceEventSource.Current.ServiceMessage(this._serviceContext, $"Spinning up ingestion worker {name}"); // establish the information for the event hub, to which we're connecting // load the connection string from event hub var ehConfiguration = this._serviceContext.CodePackageActivationContext .GetConfigurationPackageObject("Config") .Settings .Sections["EventHubConfiguration"]; var eventHubConnectionString = ehConfiguration.Get("ConnectionString"); var eventHubConsumerGroup = ehConfiguration.Get("ConsumerGroup"); var eventHubMaxBatchSize = ehConfiguration.TryGetAsInt("MaxBatchSize", 100); // start connecting to the event hub var client = EventHubClient.CreateFromConnectionString(eventHubConnectionString); // verify the partition exists var eventHubInfo = await client.GetRuntimeInformationAsync(); ServiceEventSource.Current.ServiceMessage(this._serviceContext, $"Ingestion worker {name} will connect to EH {client.EventHubName}"); var lowKey = 0; var highKey = eventHubInfo.PartitionCount - 1; var appName = _serviceContext.CodePackageActivationContext.ApplicationName; var svcName = $"{appName}/{Names.IngestorSuffix}/{name}"; await _fabricClient.ServiceManager.CreateServiceAsync(new StatefulServiceDescription() { HasPersistedState = true, PartitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(eventHubInfo.PartitionCount, lowKey, highKey), ServiceTypeName = Names.IngestorTypeName, ApplicationName = new System.Uri(appName), ServiceName = new System.Uri(svcName) }); ServiceEventSource.Current.ServiceMessage(this._serviceContext, $"Ingestion worker {name} spun up on {svcName}"); // store the name of the ingestor for the service in the dictionary, so that we can monitor this // outside the SF portal using (var tx = this._stateManager.CreateTransaction()) { await _ingestorDictionary.AddAsync(tx, svcName, eventHubInfo.PartitionCount.ToString()); await tx.CommitAsync(); } return(Ok($"Ingestor created: {svcName}")); }
public async Task AddKeyAsync(string key, string value) { if (_dict == null) { throw new NullReferenceException(nameof(_dict)); } using (var tx = this.StateManager.CreateTransaction()) { await _dict.AddAsync(tx, key, value); await tx.CommitAsync(); } }
public async Task <IActionResult> Post(string value) { IReliableDictionary <string, string> valuesList = await _stateManager.GetOrAddAsync <IReliableDictionary <string, string> >("values"); using (ITransaction tx = _stateManager.CreateTransaction()) { await valuesList.AddAsync(tx, value, value); await tx.CommitAsync(); } return(new OkResult()); }
public async Task AddToHistoryAsync(CheckoutSummary checkout) { // Get or Create history list IReliableDictionary <DateTime, CheckoutSummary> history = await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >("history"); using (ITransaction tx = StateManager.CreateTransaction()) { // Add the new checkout to history. await history.AddAsync(tx, checkout.Date, checkout); await tx.CommitAsync(); } }
/// <summary> /// Used internally to generate inventory items and adds them to the ReliableDict we have. /// </summary> /// <param name="item"></param> /// <returns></returns> public async Task <bool> CreateInventoryItemAsync(Domain.CustomerInformation item) { IReliableDictionary <string, Domain.CustomerInformation> inventoryItems = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, Domain.CustomerInformation> >(CustomerInformationDictionary); using (ITransaction tx = this.StateManager.CreateTransaction()) { await inventoryItems.AddAsync(tx, item.Id, item); await tx.CommitAsync(); } return(true); }
public async Task AddMessageAsync(Message message) { DateTime time = DateTime.Now.ToLocalTime(); IReliableDictionary <DateTime, Message> messagesDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <DateTime, Message> >("messages"); using (ITransaction tx = this.StateManager.CreateTransaction()) { await messagesDictionary.AddAsync(tx, time, message); await tx.CommitAsync(); } }
public async Task <bool> AddOrUpdateAsync(Person person) { using (var ctx = this.StateManager.CreateTransaction()) { var personId = person.Id; var currentPerson = (Person)null; if (await _personDictionary.ContainsKeyAsync(ctx, personId)) { var personValue = await _personDictionary.TryGetValueAsync(ctx, personId); if (personValue.HasValue) { currentPerson = personValue.Value; } } if (currentPerson == null) { await _personDictionary.AddAsync(ctx, person.Id, person); if (!String.IsNullOrWhiteSpace(person.EmailAddress)) { await _emailLookupDictionary.AddAsync(ctx, person.EmailAddress, person.Id); } if (!String.IsNullOrWhiteSpace(person.TwitterHandle)) { await _twitterLookupDictionary.AddAsync(ctx, person.TwitterHandle, person.Id); } await ctx.CommitAsync(); return(true); } else { if (await _personDictionary.TryUpdateAsync(ctx, person.Id, person, currentPerson)) { await ctx.CommitAsync(); return(true); } } } return(false); }
public async Task StartAnalysis(int partitionKey, byte[] imagebyte) { //this.analysisCollection = // await this.StateManager.GetOrAddAsync<IReliableDictionary<string, AnalysisState>>("statuscollection"); using (ITransaction tx = this.StateManager.CreateTransaction()) { var state = new AnalysisState(); //var state = new AnalysisState(imagebyte); await analysisCollection.AddAsync(tx, partitionKey, state); await byteCollection.AddAsync(tx, partitionKey, imagebyte); await tx.CommitAsync(); } }
/// <summary> /// Used internally to generate inventory items and adds them to the ReliableDict we have. /// </summary> /// <param name="item"></param> /// <returns></returns> public async Task <bool> CreateInventoryItemAsync(InventoryItem item) { IReliableDictionary <InventoryItemId, InventoryItem> inventoryItems = await this.stateManager.GetOrAddAsync <IReliableDictionary <InventoryItemId, InventoryItem> >(InventoryItemDictionaryName); using (ITransaction tx = this.stateManager.CreateTransaction()) { await inventoryItems.AddAsync(tx, item.Id, item); await tx.CommitAsync(); ServiceEventSource.Current.ServiceMessage(this, "Created inventory item: {0}", item); } return(true); }
/// <summary> /// This method activates an actor to fulfill the RestockRequest. /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task AddRestockRequestAsync(RestockRequest request) { try { //Get dictionary of Restock Requests IReliableDictionary <InventoryItemId, ActorId> requestDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <InventoryItemId, ActorId> >(ItemIdToActorIdMapName); ActorId actorId = ActorId.CreateRandom(); try { using (ITransaction tx = this.StateManager.CreateTransaction()) { await requestDictionary.AddAsync(tx, request.ItemId, actorId); await tx.CommitAsync(); } } catch (ArgumentException) { // restock request already exists return; } // Create actor proxy and send the request IRestockRequestActor restockRequestActor = ActorProxy.Create <IRestockRequestActor>(actorId, this.ApplicationName); await restockRequestActor.AddRestockRequestAsync(request); // Successfully added, register for event notifications for completion await restockRequestActor.SubscribeAsync <IRestockRequestEvents>(this); ServiceEventSource.Current.ServiceMessage(this, "Created restock request. Item ID: {0}. Actor ID: {1}", request.ItemId, actorId); } catch (InvalidOperationException ex) { ServiceEventSource.Current.Message(string.Format("RestockRequestManagerService: Actor rejected {0}: {1}", request, ex)); throw; } catch (Exception ex) { ServiceEventSource.Current.Message(string.Format("RestockRequestManagerService: Exception {0}: {1}", request, ex)); throw; } }
public async Task <IActionResult> Create([FromBody] PostsRequest request) { Post post = new Post(); post.message = request.message; post.userName = request.userName; IReliableDictionary <string, Post> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, Post> >("posts"); using (ITransaction tx = this.stateManager.CreateTransaction()) { await votesDictionary.AddAsync(tx, post.id.ToString(), post); await tx.CommitAsync(); } return(new OkResult()); }
private async Task FillWithData(CancellationToken cancellationToken) { bool Done = false; IReliableDictionary <int, List <TechSkill> > dictionary = await StateManager.GetOrAddAsync <IReliableDictionary <int, List <TechSkill> > >(SkillDictionaryName); //fill with sample data while (!Done) { try { // Create a new Transaction object for this partition using (ITransaction tx = base.StateManager.CreateTransaction()) { IAsyncEnumerable <KeyValuePair <int, List <TechSkill> > > SkillEnum = (await dictionary.CreateEnumerableAsync(tx)); TechSkill tsk = new TechSkill { ResourceId = 1, Name = "C#", Level = Models.Domain.Level.Expert, Notes = string.Empty }; List <TechSkill> skills = new List <TechSkill>(); skills.Add(tsk); await dictionary.AddAsync(tx, tsk.ResourceId, skills); // CommitAsync sends Commit record to log & secondary replicas // After quorum responds, all locks released await tx.CommitAsync(); } // If CommitAsync not called, Dispose sends Abort // record to log & all locks released Done = true; } catch (TimeoutException) { Done = false; await Task.Delay(100, cancellationToken); } } }
private async Task <string> ExecuteAddUserAsync(User user, IReliableDictionary <string, User> users, CancellationToken cancellationToken) { using (var tx = this.StateManager.CreateTransaction()) { var current = await users.TryGetValueAsync(tx, user.Id); if (current.HasValue) { return(user.Id); // Return existing user } await users.AddAsync(tx, user.Id, user, TimeSpan.FromSeconds(15), cancellationToken); await tx.CommitAsync(); MetricsLog?.UserCreated(user); } return(user.Id); }
public async Task Post([FromBody] List <DoctorStatsViewModel> stats) { try { IReliableDictionary <int, string> countyNameDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <int, string> >(CountyService.CountyNameDictionaryName); foreach (var stat in stats) { ServiceEventSource.Current.Message("Saving for county {0}", stat.countyId); IReliableDictionary <Guid, CountyDoctorStats> countyHealth = await this.stateManager.GetOrAddAsync <IReliableDictionary <Guid, CountyDoctorStats> >( string.Format(CountyService.CountyHealthDictionaryName, stat.countyId)); using (ITransaction tx = this.stateManager.CreateTransaction()) { await countyHealth.SetAsync( tx, stat.DoctorId, new CountyDoctorStats(stat.PatientCount, stat.HealthReportCount, stat.DoctorName, stat.AverageHealthIndex)); // Add the county only if it does not already exist. ConditionalValue <string> getResult = await countyNameDictionary.TryGetValueAsync(tx, stat.countyId); if (!getResult.HasValue) { await countyNameDictionary.AddAsync(tx, stat.countyId, String.Empty); } // finally, commit the transaction and return a result await tx.CommitAsync(); } } return; } catch (Exception e) { ServiceEventSource.Current.Message("Exception in CountyHealthController {0}", e); throw; } }
/// <summary> /// This method executes on the bidder's partition. /// Called by web: priority 0 /// </summary> public async Task <UserInfo> CreateUserAsync(String userEmail, CancellationToken cancellationToken) { // Create user and add to dictionary; fail if user already exists Email _userEmail = Email.Parse(userEmail); using (var tx = CreateTransaction()) { var userInfo = new UserInfo(_userEmail); try { await m_users.AddAsync(tx, _userEmail, userInfo); await tx.CommitAsync(); return(userInfo); } catch (Exception ex) { // Change to what if already exists throw new InvalidOperationException($"User '{_userEmail}' already exists.", ex); } } }
private async Task AddClusters(ITransaction tx, IReliableDictionary<int, Cluster> dictionary, int count, Func<Cluster> newCluster) { for (int i = 0; i < count; ++i) { await dictionary.AddAsync(tx, this.GetRandom(), newCluster()); } }