public SftpActor(IClientFactory clientFactory)
{
_clientFactory = clientFactory;
_fileStreamProvider = _clientFactory.CreateFileStreamProvider();
Disconnected();
}
public FileSystemStore(
IStoreBackend <Guid, Metadata> metadataRepository
, IStoreBackend <Guid, Upload> storeBackend
, IFileStreamProvider <Guid, StreamAdapter> fileStreamProvider) :
base(metadataRepository, storeBackend, fileStreamProvider)
{
}
public JobState(IFileStreamProvider fileStreamProvider, IFileLineCounter fileLineCounter, IFileProcessor fileProcessor, IPercentageCalculator percentageCalculator)
{
_fileStreamProvider = fileStreamProvider;
_fileLineCounter = fileLineCounter;
_fileProcessor = fileProcessor;
_percentageCalculator = percentageCalculator;
}
protected Store(IStoreBackend <TKey, TMeta> metadataRepository
, IStoreBackend <TKey, TIn> storeBackend
, IFileStreamProvider <TKey, StreamAdapter> fileStreamProvider)
{
metaRepository = metadataRepository;
this.storeBackend = storeBackend;
this.fileStreamProvider = fileStreamProvider;
}
/************************ Construction ***********************************/
/*----------------------- WritableXmlConfigurationSource ----------------*/
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="fileStreamProvider"></param>
public WritableXmlConfigurationSource(
IXmlConfigurationWriter writer,
IFileStreamProvider fileStreamProvider)
{
Writer = writer ?? throw new ArgumentNullException(nameof(writer));
StreamProvider = fileStreamProvider ??
throw new ArgumentNullException(nameof(fileStreamProvider));
return;
} /* End of Function - WritableXmlConfigurationSource */
// Get a stream binder from a resolved path
private async Task <IFileStreamProvider> GetStreamHelper(string path)
{
TAttribute clone = CloneAttributeWithResolvedPath(path);
TFile nativeFile = await this._strategyBuilder(clone);
var func = this._converterManager.GetConverter <TFile, IFileStreamProvider, TAttribute>();
IFileStreamProvider strategy = func(nativeFile, null, null);
return(strategy);
}
public ConfigurationProvider(IFileStreamProvider fileStreamProvider)
{
_configurationItems =
Assembly.GetExecutingAssembly().Location
.Map(Path.GetDirectoryName)
.Map(x => Path.Combine(x, "raindrop.config.json"))
.Map(fileStreamProvider.OpenFileForRead)
.Map(x => new StreamReader(x))
.Use(x => x.ReadToEnd())
.Map(JObject.Parse)
.Properties()
.ToDictionary(k => k.Name, v => v);
}
// Get a stream binder from a resolved path
private async Task <IFileStreamProvider> GetStreamHelper(string path)
{
TAttribute clone = JsonConvert.DeserializeObject <TAttribute>(JsonConvert.SerializeObject(_source));
clone.Path = path;
TFile nativeFile = await this._strategyBuilder(clone);
var func = this._converterManager.GetConverter <TFile, IFileStreamProvider, TAttribute>();
IFileStreamProvider strategy = func(nativeFile, null, null);
return(strategy);
}
public async Task <IValueProvider> BindAsync(object value, ValueBindingContext context)
{
string path = (string)value;
IFileStreamProvider strategy = await GetStreamHelper(path);
var outTuple = await strategy.OpenWriteStreamAsync();
Stream outStream = outTuple.Item1;
Func <object, Task> completedFunc = outTuple.Item2;
// Bind to 'out string'
var valueProvider = new GenericOutFileValueProvider(outStream, completedFunc);
return(valueProvider);
}
public MemoryFile(string name, IDirectory directory, IFileStreamProvider streamProvider = null)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
Name = name;
Directory = directory;
Extension = ParseExtension(name);
if (streamProvider == null)
{
streamProvider = new MemoryStreamProvider();
}
StreamProvider = streamProvider;
}
public MemoryFile(string name, IDirectory directory, IFileStreamProvider streamProvider = null)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
Name = name;
Directory = directory;
Extension = ParseExtension(name);
if (streamProvider == null)
{
streamProvider = new MemoryStreamProvider();
}
StreamProvider = streamProvider;
}
private IList <T> ParseCSVFile <T>(IFileStreamProvider fileStreamProvider, string filePath)
where T : class, new()
{
using (var fileStream = fileStreamProvider.OpenRead(filePath))
using (var textReader = new StreamReader(
fileStream,
new UTF8Encoding(false),
detectEncodingFromByteOrderMarks: false,
bufferSize: 10 * 1024,
leaveOpen: true))
using (var csvReader = new CsvReader(textReader, leaveOpen: true))
{
csvReader.Configuration.RegisterClassMap(csvReader.Configuration.AutoMap <T>());
return(csvReader.GetRecords <T>().ToList());
}
}
public FileGrowthCsvReaderProvider(IConfiguration configuration, IFileStreamProvider fileStreamProvider)
{
var pwd = configuration["WorkingDirectory"];
var fileIDPath = Path.Combine(pwd, configuration["FileIDName"]);
var fileStatsPath = Path.Combine(pwd, configuration["FileStatsName"]);
FileMap = (
from dto in ParseCSVFile <FileMetaDataDto>(fileStreamProvider, fileIDPath)
select new FileMetaData(dto.ID, dto.Name)
).ToDictionary(p => p.FileID, p => p);
FileSizeStatsMap = (
from dto in ParseCSVFile <FileSizeStatsDto>(fileStreamProvider, fileStatsPath)
group dto by dto.FileID into g
select new FileSizeStats(g.Key, g.ToDictionary(p => p.Timestamp, p => p.SizeInBytes))
).ToDictionary(p => p.FileID, p => p);
}
} /* End of Function - AddWritableXml */
/*----------------------- AddWritableXml --------------------------------*/
/// <summary>
/// Adds a writable XML configuration source, using defaults.
/// </summary>
/// <param name="builder">Builder to add source to.</param>
/// <param name="fileProvider">File provider to use.</param>
/// <param name="path">Path of the XML file.</param>
/// <param name="optional">Determines if loading the file is optional.</param>
/// <param name="reloadOnChange">
/// Determines if data should reload on file change.
/// </param>
/// <param name="writer">
/// Service used to write the data to a stream.
/// </param>
/// <returns>
/// The configuration builder.
/// </returns>
public static IConfigurationBuilder AddWritableXml(
this IConfigurationBuilder builder,
IFileProvider fileProvider,
string path,
bool optional,
bool reloadOnChange,
IFileStreamProvider fileStreamProvider,
IXmlConfigurationWriter writer)
{
// Build our source
var source = new WritableXmlConfigurationSource(writer, fileStreamProvider)
{
FileProvider = fileProvider,
Path = path,
Optional = optional,
ReloadOnChange = reloadOnChange
};
// Resolve the file provider
source.ResolveFileProvider();
// And finally add it back to the configuration builder.
return(builder.Add(source));
} /* End of Function - AddWritableXml */
public JsonConverter(IFileStreamProvider fileStreamProvider)
{
_fileStreamProvider = fileStreamProvider;
}
public async Task <IValueProvider> BindAsync(object value, ValueBindingContext context)
{
string path = (string)value;
IFileStreamProvider strategy = await GetStreamHelper(path);
var targetType = _parameter.ParameterType;
object userObj = null;
Func <object, Task> onComplete;
ConstantObj valueProvider = null;
if (_source.Access == FileAccess.Write)
{
var tuple = await strategy.OpenWriteStreamAsync();
var writeStream = tuple.Item1;
var saveStreamFunc = tuple.Item2;
if (targetType == typeof(Stream) || (_parameter.IsOut && targetType == typeof(Stream).MakeByRefType()))
{
userObj = writeStream;
onComplete = saveStreamFunc;
}
else if (targetType == typeof(TextWriter) || (_parameter.IsOut && targetType == typeof(TextWriter).MakeByRefType()))
{
var tw = new StreamWriter(writeStream);
userObj = tw;
onComplete = async obj =>
{
tw.Flush();
await saveStreamFunc(obj);
};
}
else if (targetType == typeof(StreamWriter) || (_parameter.IsOut && targetType == typeof(StreamWriter).MakeByRefType()))
{
var tw = new StreamWriter(writeStream);
userObj = tw;
onComplete = async obj =>
{
tw.Flush();
await saveStreamFunc(obj);
};
}
else if (targetType == typeof(byte[]) || (_parameter.IsOut && targetType == typeof(byte[]).MakeByRefType()))
{
userObj = writeStream;
onComplete = saveStreamFunc;
}
else
{
throw new InvalidOperationException("Unsupported type:" + targetType.FullName);
}
}
else
{
var readStream = await strategy.OpenReadStreamAsync();
onComplete = obj => Task.FromResult(0); // Nop
if (targetType == typeof(Stream))
{
userObj = readStream;
}
else if (targetType == typeof(TextReader))
{
userObj = new StreamReader(readStream);
}
else if (targetType == typeof(StreamReader))
{
userObj = new StreamReader(readStream);
}
else if (targetType == typeof(string))
{
userObj = new StreamReader(readStream).ReadToEnd();
}
else if (targetType == typeof(byte[]) && readStream is MemoryStream)
{
userObj = ((MemoryStream)readStream).ToArray();
}
else
{
throw new InvalidOperationException("Unsupported type:" + targetType.FullName);
}
}
valueProvider = new ConstantObj
{
Type = targetType,
Value = userObj,
OnCompleted = onComplete
};
return(valueProvider);
}
protected Store(
IStoreBackend <Guid, Metadata> metadataRepository
, IStoreBackend <Guid, TIn> storeBackend
, IFileStreamProvider <Guid, StreamAdapter> fileStreamProvider) : base(metadataRepository, storeBackend, fileStreamProvider)
{
}
public FileGrowthCsvWriterProvider(IConfiguration configuration, IFileStreamProvider fileStreamProvider)
{
Configuration = configuration;
FileStreamProvider = fileStreamProvider;
}
public FileLineCounter(IFileStreamProvider fileStreamProvider)
{
_fileStreamProvider = fileStreamProvider;
}
public FileProcessor(IConfigurationState configurationState, IFileStreamProvider fileStreamProvider, IPercentageCalculator percentageCalculator)
{
_configurationState = configurationState;
_fileStreamProvider = fileStreamProvider;
_percentageCalculator = percentageCalculator;
}
public InputDatasetFactory(IFileStreamProvider fileStreamProvider)
{
_fileStreamProvider = fileStreamProvider;
}
public StringFileReaderWriter(IFileStreamProvider streamProvider)
{
_streamProvider = streamProvider;
}
