private void WithLock(DeletionArgs args, string subKey, Func <long> func)
{
while (!args.CancellationToken.IsCancellationRequested)
{
try
{
using (FluentNHibernateDistributedLock.Acquire(Storage,
string.Format("{0}:{1}", DistributedLockKey, subKey),
DefaultLockTimeout,
args.CancellationToken))
{
var removedCount = func();
if (removedCount < args.NumberOfRecordsInSinglePass)
{
break;
}
}
}
catch (DistributedLockTimeoutException)
{
Logger.Debug("Distributed lock acquisition timeout was exceeded");
}
args.CancellationToken.Wait(DelayBetweenPasses);
}
}
public void Execute(CancellationToken cancellationToken)
{
var numberOfRecordsInSinglePass = Storage.Options.DeleteExpiredBatchSize;
if (numberOfRecordsInSinglePass <= 0 || numberOfRecordsInSinglePass > 100_000)
{
numberOfRecordsInSinglePass = DefaultNumberOfRecordsInSinglePass;
}
var deletionArgs = new DeletionArgs
{
NumberOfRecordsInSinglePass = numberOfRecordsInSinglePass, CancellationToken = cancellationToken
};
var actions = new List <Action <DeletionArgs> >
{
DeleteJobItems, DeleteListItems, DeleteAggregatedCounterItems, DeleteSetItems, DeleteHashItems,
DeleteDistributedLockItems
};
foreach (var action in actions)
{
try
{
action(deletionArgs);
}
catch (Exception ex)
{
Logger.ErrorException("Error while deleting expired items", ex);
}
}
cancellationToken.Wait(Storage.Options.JobExpirationCheckInterval);
}
private long DeleteExpirableEntity <T>(DeletionArgs info) where T : class, IExpirableWithId
{
return(DeleteEntities <T>((session, cutoff) =>
{
var ids = session.Query <T>()
.Where(i => i.ExpireAt < cutoff).Take(info.NumberOfRecordsInSinglePass)
.Select(i => i.Id)
.ToList();
return session.DeleteByInt32Id <T>(ids);
}));
}
private void DeleteJobItems(DeletionArgs deletionArgs)
{
WithLock(deletionArgs, "JobItems", () =>
{
DeleteJobDetailEntity <_JobQueue>(deletionArgs);
DeleteJobDetailEntity <_JobParameter>(deletionArgs);
DeleteJobDetailEntity <_JobState>(deletionArgs);
DeleteExpirableEntity <_Job>(deletionArgs);
return(0);
});
}
#pragma warning restore 618
private void DeleteJobDetailEntity <T>(DeletionArgs info) where T : class, IJobChild, IInt32Id
{
DeleteEntities <T>((session, cutoff) =>
{
var idList = session.Query <T>().Where(i => i.Job.ExpireAt < cutoff)
.Take(info.NumberOfRecordsInSinglePass)
.Select(i => i.Id)
.ToList();
return(session.DeleteByInt32Id <T>(idList));
});
}
private void DeleteDistributedLockItems(DeletionArgs deletionArgs)
{
WithLock(deletionArgs, nameof(_DistributedLock), () =>
{
return(DeleteEntities <_DistributedLock>((session, cutoff) =>
{
var unixDate = cutoff.ToEpochDate();
var idList = session.Query <_DistributedLock>()
.Where(i => i.ExpireAtAsLong < unixDate).Take(deletionArgs.NumberOfRecordsInSinglePass)
.Select(i => i.Id)
.ToList();
return session.DeleteByInt32Id <_DistributedLock>(idList);
}));
});
}
private void DeletionCheck(object sender, DeletionArgs args)
{
if (current == args.DeletedVertex)
{
if (current.Value.CompareTo(args.NewVertex.Value) > 0)
{
current = null;
}
else
{
current = args.NewVertex;
}
}
if (current == null)
{
Reset();
}
}
public override void DeleteMultipleFiles(List <Tuple <string, object> > keyNamesAndIdentifiers, CancellationToken cancellationToken)
{
DeletionArgs reusedArgs = new DeletionArgs
{
};
DeleteObjectsRequest request = new DeleteObjectsRequest
{
BucketName = this._awsBuckeName,
Objects = (from k in keyNamesAndIdentifiers select new KeyVersion()
{
Key = k.Item1
}).ToList()
//Quiet = true
};
try
{
// Report start - before any possible failures.
if (DeletionStarted != null)
{
DeletionStarted(reusedArgs, () =>
{
reusedArgs.State = TransferState.STARTED;
});
}
this._s3Client.DeleteObjects(request);
// Report completion.
if (DeletionCompleted != null)
{
DeletionCompleted(reusedArgs, () =>
{
reusedArgs.State = TransferState.COMPLETED;
});
}
}
catch (OperationCanceledException exception)
{
logger.Info("Deletion canceled.");
// Report cancelation.
if (DeletionCanceled != null)
{
DeletionCanceled(reusedArgs, () =>
{
reusedArgs.State = TransferState.CANCELED;
reusedArgs.Exception = exception;
});
}
}
catch (DeleteObjectsException exception)
{
// Get error details from response.
DeleteObjectsResponse errorResponse = exception.Response;
//foreach (DeletedObject deletedObject in errorResponse.DeletedObjects)
//{
// logger.Debug("Deleted object {0}" + deletedObject.Key);
//}
foreach (DeleteError deleteError in errorResponse.DeleteErrors)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Error deleting item " + deleteError.Key);
sb.AppendLine(" Code : " + deleteError.Code);
sb.AppendLine(" Message: " + deleteError.Message);
logger.Log(LogLevel.Warn, sb.ToString());
}
// Report failure.
if (DeletionFailed != null)
{
DeletionFailed(reusedArgs, () =>
{
reusedArgs.State = TransferState.FAILED;
reusedArgs.Exception = exception;
});
}
}
catch (Exception exception)
{
if (exception is AmazonS3Exception)
{
AmazonS3Exception amznException = exception as AmazonS3Exception;
if (amznException.ErrorCode != null && (amznException.ErrorCode.Equals("InvalidAccessKeyId") || amznException.ErrorCode.Equals("InvalidSecurity")))
{
logger.Log(LogLevel.Warn, "Check the provided AWS Credentials.");
}
else
{
logger.Log(LogLevel.Warn, "Error occurred. Message:'{0}' when deleting object", amznException.Message);
}
}
else
{
logger.Log(LogLevel.Warn, "Exception occurred: {0}", exception.Message);
}
// Report failure.
if (DeletionFailed != null)
{
DeletionFailed(reusedArgs, () =>
{
reusedArgs.State = TransferState.FAILED;
reusedArgs.Exception = exception;
});
}
}
}
public override void DeleteFile(string keyName, object userData, CancellationToken cancellationToken)
{
if (cancellationToken != null)
{
cancellationToken.ThrowIfCancellationRequested();
}
DeletionArgs reusedArgs = new DeletionArgs
{
UserData = userData,
FilePath = keyName,
};
DeleteObjectRequest request = new DeleteObjectRequest
{
BucketName = this._awsBuckeName,
Key = keyName
};
try
{
// Report start - before any possible failures.
if (DeletionStarted != null)
{
DeletionStarted(reusedArgs, () =>
{
reusedArgs.State = TransferState.STARTED;
});
}
this._s3Client.DeleteObject(request);
// Report completion.
if (DeletionCompleted != null)
{
DeletionCompleted(reusedArgs, () =>
{
reusedArgs.State = TransferState.COMPLETED;
});
}
}
catch (OperationCanceledException exception)
{
logger.Info("Deletion canceled.");
// Report cancelation.
if (DeletionCanceled != null)
{
DeletionCanceled(reusedArgs, () =>
{
reusedArgs.State = TransferState.CANCELED;
reusedArgs.Exception = exception;
});
}
}
catch (Exception exception)
{
if (exception is AmazonS3Exception)
{
AmazonS3Exception amznException = exception as AmazonS3Exception;
if (amznException.ErrorCode != null && (amznException.ErrorCode.Equals("InvalidAccessKeyId") || amznException.ErrorCode.Equals("InvalidSecurity")))
{
logger.Log(LogLevel.Warn, "Check the provided AWS Credentials.");
}
else
{
logger.Log(LogLevel.Warn, "Error occurred. Message:'{0}' when deleting object", amznException.Message);
}
}
else
{
logger.Log(LogLevel.Warn, "Exception occurred: {0}", exception.Message);
}
// Report failure.
if (DeletionFailed != null)
{
DeletionFailed(reusedArgs, () =>
{
reusedArgs.State = TransferState.FAILED;
reusedArgs.Exception = exception;
});
}
}
}
private void DeleteExpirableEntityWithLock <T>(DeletionArgs deletionArgs)
where T : class, IExpirableWithId
{
WithLock(deletionArgs, typeof(T).Name,
() => DeleteExpirableEntity <T>(deletionArgs));
}
private void DeleteListItems(DeletionArgs deletionArgs)
{
DeleteExpirableEntityWithLock <_List>(deletionArgs);
}
private void DeleteAggregatedCounterItems(DeletionArgs deletionArgs)
{
DeleteExpirableEntityWithLock <_AggregatedCounter>(deletionArgs);
}
private void DeleteHashItems(DeletionArgs deletionArgs)
{
DeleteExpirableEntityWithLock <_Hash>(deletionArgs);
}
