public async Task CleanUpFilesAsync_DelectedCount_ReturnsProperCount()
{
//Arrange
var stubOptions = new FileStorageOptions()
{
ServerFileUploadSubFolder = "RestApi"
};
var mockBlobs = new List <BlobInfo>()
{
GetFakeBlobInfo("/foo", DateTimeOffset.UtcNow),
GetFakeBlobInfo("/bar", DateTimeOffset.UtcNow.AddDays(-1)),
GetFakeBlobInfo("/baz", DateTimeOffset.UtcNow.AddDays(-1))
};
var blobRepoMock = CreateDefaultBlobRepository(mockBlobs);
var optionsMock = new Mock <IOptionsSnapshot <FileStorageOptions> >();
optionsMock.Setup(m => m.Value).Returns(stubOptions);
//Act
var service = new FileService(blobRepoMock.Object, optionsMock.Object, m_LoggerMock.Object);
int deleted = await service.CleanUpFilesAsync(1);
//Assert
Assert.Equal(2, deleted);
}
public async Task CleanUpFilesAsync_ExpirationDelay_DeleteOnlyExpired()
{
//Arrange
var stubOptions = new FileStorageOptions()
{
ServerFileUploadSubFolder = "RestApi"
};
var mockBlob = GetFakeBlobInfo("/foo", DateTimeOffset.UtcNow);
var mockBlobs = new List <BlobInfo>()
{
GetFakeBlobInfo("/bar", DateTimeOffset.UtcNow.AddDays(-1)),
mockBlob,
GetFakeBlobInfo("/baz", DateTimeOffset.UtcNow.AddDays(-1))
};
var blobRepoMock = CreateDefaultBlobRepository(mockBlobs);
var optionsMock = new Mock <IOptionsSnapshot <FileStorageOptions> >();
optionsMock.Setup(m => m.Value).Returns(stubOptions);
//Act
var service = new FileService(blobRepoMock.Object, optionsMock.Object, m_LoggerMock.Object);
await service.CleanUpFilesAsync(1);
//Assert
Assert.Single(mockBlobs, mockBlob);
}
public async Task CleanUpFilesAsync_RelayContainer_DeleteAnyBlobs()
{
//Arrange
var stubOptions = new FileStorageOptions()
{
DeviceFileUploadFolder = nameof(FileStorageOptions.DeviceFileUploadFolder),
ServerFileUploadFolder = nameof(FileStorageOptions.ServerFileUploadFolder),
ServerFileUploadSubFolder = "RestApi"
};
var mockBlobs = new List <BlobInfo>()
{
GetFakeBlobInfo(stubOptions.DeviceFileUploadFolder, "foo", DateTimeOffset.UtcNow.AddDays(-1)),
GetFakeBlobInfo(stubOptions.ServerFileUploadFolder, "bar", DateTimeOffset.UtcNow.AddDays(-1)),
GetFakeBlobInfo($"/{stubOptions.ServerFileUploadFolder}/baz/patate/patate.txt", DateTimeOffset.UtcNow.AddDays(-1))
};
var blobRepoMock = CreateDefaultBlobRepository(mockBlobs);
var optionsMock = new Mock <IOptionsSnapshot <FileStorageOptions> >();
optionsMock.Setup(m => m.Value).Returns(stubOptions);
//Act
var service = new FileService(blobRepoMock.Object, optionsMock.Object, m_LoggerMock.Object);
await service.CleanUpFilesAsync(1);
//Assert
Assert.Empty(mockBlobs);
}
/// <summary>
/// Cleans-up the files used for device request/response.
/// </summary>
/// <param name="minutesCleanupExpirationDelay"></param>
/// <returns></returns>
public async Task <int> CleanUpFilesAsync(uint minutesCleanupExpirationDelay)
{
if (minutesCleanupExpirationDelay == uint.MinValue)
{
throw new ArgumentOutOfRangeException(nameof(minutesCleanupExpirationDelay));
}
List <BlobInfo> blobs;
FileStorageOptions options = m_FileStorageOptions.Value;
//collect blobs for relay api -> device requests - any blobs in that path have been uploaded for the relay API purpose
blobs = await m_BlobRepository.ListBlobAsync(options.ServerFileUploadFolder);
m_Logger.LogDebug($"Found '{blobs.Count}' blob(s) for relay -> device requests");
//collect blobs for device -> relay api responses - filter blobs related to relay API context only
List <BlobInfo> responseBlobs = await m_BlobRepository.ListBlobAsync(options.DeviceFileUploadFolder);
List <BlobInfo> relayApiBlobs = responseBlobs.Where(b => b.Path.Contains(m_FileStorageOptions.Value.ServerFileUploadSubFolder)).ToList();
m_Logger.LogDebug($"Found '{relayApiBlobs.Count}' blob(s) for device -> relay responses");
blobs.AddRange(relayApiBlobs);
//perform clean-up on expired blobs
DateTime expirationDate = DateTime.UtcNow.AddMinutes(-minutesCleanupExpirationDelay);
Task <bool>[] deleteTasks = blobs.Where(b => b.LastModified < expirationDate)
.Select(b => m_BlobRepository.DeleteBlobAsync(b.Path))
.ToArray();
await Task.WhenAll(deleteTasks);
return(deleteTasks.Count(t => t.Result));
}
public FileController(IFilesRepository filesRepository,
IFileManagement fileManagement,
IOptions <FileStorageOptions> fileStorageOptions)
{
_filesRepository = filesRepository;
_fileManagement = fileManagement;
_fileStorageOptions = fileStorageOptions.Value;
}
public PhotoService(IOptions <FileStorageOptions> fileStorageOptions)
{
_fileStorageOptions = fileStorageOptions.Value ?? throw new ArgumentNullException(nameof(fileStorageOptions));
if (Directory.Exists(_fileStorageOptions.PersonPhotoPath) == false)
{
Directory.CreateDirectory(_fileStorageOptions.PersonPhotoPath);
}
}
public FileStorageService(FileStorageOptions fileStorageOptions)
{
_bucket = fileStorageOptions.Bucket;
_s3Client = new AmazonS3Client(new BasicAWSCredentials(fileStorageOptions.AccessKey, fileStorageOptions.SecretKey), new AmazonS3Config
{
ServiceURL = fileStorageOptions.Endpoint,
SignatureMethod = SigningAlgorithm.HmacSHA256,
ForcePathStyle = true,
MaxConnectionsPerServer = 100
});
}
public FileInfoCreateCommandHandler(
IRepository <FileItem, Guid> repository,
IDomainEventBus domainEventBus,
IMapper mapper,
ISettingManager settingManage,
IFileManager fileManager)
{
_repository = repository;
_domainEventBus = domainEventBus;
_mapper = mapper;
_options = settingManage.GetApplicationOptions <FileStorageOptions>(nameof(FileStorageOptions));
_fileManager = fileManager;
}
public static IServiceCollection ConfigureForWebServer(this IServiceCollection services, IConfiguration configuration)
{
FileStorageOptions fileStorageOptions = new FileStorageOptions();
configuration.GetSection(FileStorageOptions.FileStorageOptionsKey).Bind(fileStorageOptions);
InstallConfiguration installConfiguration = new InstallConfiguration
{
DatabaseConnectionString = configuration.GetConnectionString("Database"),
AzureStorageConnectionString = configuration.GetConnectionString("AzureStorageConnectionString"),
FileStoragePathOrContainerName = fileStorageOptions.PathOrContainerName,
ServiceProfiles = new[] { ServiceAttribute.DefaultProfile, ServiceProfiles.WebServer },
};
return(services.ConfigureForAll(installConfiguration));
}
public static string GeneratePath(FileItem file, FileStorageOptions options)
{
var fullPath = PathHelper.Combine(options.RootPath, file.TenantId.ToString(), file.ModuleCode);
var ext = Path.GetExtension(file.Name);
var classifyPath = "";
foreach (var item in options.ClassifyOptions)
{
if (item.Extensions.Split(',').Any(c => c == ext))
{
classifyPath = item.DirectoryName;
}
}
fullPath = PathHelper.Combine(fullPath, classifyPath);
var datePath = "";
switch (options.DirectoryRule)
{
case DirectoryNameRule.Year:
datePath = file.CreationTime.Value.ToString("yyyy");
break;
case DirectoryNameRule.Month:
datePath = file.CreationTime.Value.ToString("yyyy/yyyy-MM");
break;
case DirectoryNameRule.Day:
datePath = file.CreationTime.Value.ToString("yyyy/yyyy-MM/yyyy-MM-dd");
break;
default:
break;
}
fullPath = PathHelper.Combine(fullPath, datePath, Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ext);
return(fullPath);
}
public FileStorageService(
IOptions <FileStorageOptions> options,
ICacheProvider cacheProvider
)
{
_options = options.Value;
_cacheProvider = cacheProvider;
if (string.IsNullOrWhiteSpace(_options.Path))
{
throw new OptionsValidationException("Path", typeof(string), new[] { "value is null or empty" });
}
if (string.IsNullOrWhiteSpace(_options.RecyclerPath))
{
throw new OptionsValidationException("RecyclerPath", typeof(string), new[] { "value is null or empty" });
}
if (string.IsNullOrWhiteSpace(_options.RecyclerName))
{
throw new OptionsValidationException("RecyclerName", typeof(string), new[] { "value is null or empty" });
}
}
public FileStorageService(IOptions <FileStorageOptions> fileStorageOptions,
ILoggerFactory loggerFactory)
{
_fileStorageOptions = fileStorageOptions.Value;
_logger = loggerFactory.CreateLogger <FileStorageService>();
}
public SingleFileUploadModel(IFileItemService service, ISettingManager settingManage)
{
_service = service;
_filesOptions = settingManage.GetApplicationOptions <FileStorageOptions>(nameof(FileStorageOptions));
}
