public async Task <bool> RemoveRow(
            GrainReference grainRef,
            string reminderName,
            string eTag
            )
        {
            var row = await _db
                      .Reminders
                      .FirstOrDefaultAsync(a =>
                                           a.ServiceId == _clusterOptions.Value.ServiceId &&
                                           a.GrainId == grainRef.ToKeyString() &&
                                           a.ReminderName == reminderName
                                           );

            if (row == null)
            {
                return(false);
            }

            if (row.ETag != eTag)
            {
                throw new OrleansEFReminderException.EtagMismatch(
                          $"etag mismatch. " +
                          $"grainId: {grainRef.ToKeyString()} " +
                          $"reminderName: {reminderName}"
                          );
            }

            _db.Reminders.Remove(row);

            await _db.SaveChangesAsync();

            return(true);
        }
        public async Task <IGrainState> ClearStateAsync(
            string grainType,
            GrainReference grainReference,
            IGrainState grainState
            )
        {
            try
            {
                if (string.IsNullOrWhiteSpace(grainType))
                {
                    throw new ArgumentNullException(nameof(grainType));
                }

                grainReference = grainReference ??
                                 throw new ArgumentNullException(nameof(grainReference));

                grainState = grainState ??
                             throw new ArgumentNullException(nameof(grainState));

                grainState.ETag =
                    null;

                grainState.State =
                    null;

                var dbGrain = await _db
                              .Storage
                              .FirstOrDefaultAsync(a =>
                                                   a.Type == grainType &&
                                                   a.PrimaryKey == grainReference.ToKeyString()
                                                   );

                if (dbGrain == null)
                {
                    return(grainState);
                }

                _db.Storage.Remove(dbGrain);

                await _db.SaveChangesAsync();

                return(grainState);
            }
            catch (Exception e)
            {
                _logger.LogError(0, e, nameof(ClearStateAsync));
                throw;
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// delete old silo entries
        /// </summary>
        /// <param name="beforeDate"></param>
        /// <returns></returns>
        public async Task CleanupDefunctSiloEntries(DateTimeOffset beforeDate)
        {
            using (await _semaphore.DisposableWaitAsync())
            {
                var deadSilos = await _orleansEfContext
                                .Memberships
                                .Where(a =>
                                       a.DeploymentId == _clusterOptions.ClusterId &&
                                       a.IAmAliveTime < beforeDate.UtcDateTime
                                       )
                                .ToListAsync();

                deadSilos.ForEach(a =>
                                  _logger.Info(0, $"cleaning up suspected dead silo. address={a.Address}:{a.Port} hostname={a.HostName} last_i_am_alive={a.IAmAliveTime}")
                                  );

                _orleansEfContext.Memberships.RemoveRange(deadSilos);

                await _orleansEfContext.SaveChangesAsync();
            }
        }