protected ClientHandler(byte id, ITransferHandler transferHandler)
{
if (transferHandler == null) throw new ArgumentNullException("transferHandler");
this.Id = id;
_transferHandler = transferHandler;
}
private async Task GetVersionAsync(ITransferHandler handler)
{
var networkBuffer = Constants.NoDataBytes;
var data = await handler.ReadAsync();
var package = _packages[BitConverter.ToInt32(data, 0)];
if (package != null)
{
networkBuffer = package.Header.NetworkBuffer;
}
await handler.WriteAsync(networkBuffer);
}
/// <summary>
/// Gets the maximum block size that can be transferred, if such
/// a limit exists. Returns null in case of arbitrary block sizes.
/// </summary>
protected Wrapped <int?> GetMaxBlockSize(ITransferHandler <T> transferHandler)
{
//get the minimum of the configured block size and the file system block size
//(which are both optional)
int?settingsValue = Settings == null ? null : GetSettingsMaxBlockSize(Settings);
if (settingsValue.HasValue)
{
int blockSize = Math.Min(settingsValue.Value, transferHandler.MaxBlockSize ?? int.MaxValue);
return(new Wrapped <int?>(blockSize));
}
return(new Wrapped <int?>(transferHandler.MaxBlockSize));
}
public TransferController(ITransferHandler handler)
{
_handler = handler;
}
public Host(ITransferHandler transferHandler, IErrorHandler errorHandler)
{
this.transferHandler = transferHandler;
this.errorHandler = errorHandler;
}
public LogsClientHandler(byte id, ITransferHandler transferHandler)
: base(id, transferHandler)
{
}
public UpdateClientHandler(byte id, ITransferHandler transferHandler)
: base(id, transferHandler)
{
}
private async Task GetConfigsAsync(ITransferHandler handler)
{
using (var ms = new MemoryStream())
{
for (var i = 0; i < _folders.Length; i++)
{
var folder = _folders[i];
var platform = (ClientPlatform)(i / Categories);
var category = (LogCategory)(i % Platforms);
var config = new LogConfig(new RequestHeader(platform, RequestHeader.EmptyVersion, string.Empty, string.Empty), category, folder);
var buffer = config.NetworkBuffer;
ms.Write(buffer, 0, buffer.Length);
}
await handler.WriteAsync(ms.ToArray());
}
}
private async Task<byte[]> UploadAsync(ITransferHandler handler, LogCategory category, bool append = false)
{
using (var ms = new MemoryStream(await handler.ReadAsync()))
{
var header = new RequestHeader().Setup(ms);
var folder = _folders[FolderIndex(header.ClientPlatform, category)];
if (folder != string.Empty)
{
var userFolder = new DirectoryInfo(Path.Combine(folder, header.Username));
if (!userFolder.Exists)
{
userFolder.Create();
}
var buffer = MemoryPool.Get80KBuffer();
try
{
await new ServerPackageHelper(buffer).UnpackAsync(ms, userFolder, append);
return OneBytes;
}
finally
{
MemoryPool.Return80KBuffer(buffer);
}
}
}
return ZeroBytes;
}
private async Task ConfigureAsync(ITransferHandler handler, LogCategory category)
{
using (var ms = new MemoryStream(await handler.ReadAsync()))
{
var logConfig = new LogConfig().Setup(ms);
_folders[FolderIndex(logConfig.RequestHeader.ClientPlatform, category)] = logConfig.Folder;
}
var buffer = new StringBuilder();
foreach (var folder in _folders)
{
buffer.AppendLine(folder);
}
using (var sw = new StreamWriter(ConfigName))
{
await sw.WriteAsync(buffer.ToString());
}
}
public TransferController(ITransferHandler handler, IMockDb _db)
{
_handler = handler;
this.db = _db;
}
private async Task GetVersionsAsync(ITransferHandler handler)
{
var networkBuffer = Constants.NoDataBytes;
var totalBufferSize = 0;
foreach (var p in _packages)
{
if (p != null)
{
totalBufferSize += p.Header.NetworkBuffer.Length;
}
}
if (totalBufferSize > 0)
{
using (var ms = new MemoryStream(totalBufferSize))
{
foreach (var p in _packages)
{
if (p != null)
{
var buffer = p.Header.NetworkBuffer;
ms.Write(buffer, 0, buffer.Length);
}
}
networkBuffer = ms.GetBuffer();
}
}
await handler.WriteAsync(networkBuffer);
}
private async Task DownloadPackageAsync(ITransferHandler handler)
{
var networkBuffer = Constants.NoDataBytes;
var header = new RequestHeader().Setup(new MemoryStream(await handler.ReadAsync()));
var package = _packages[(int)header.ClientPlatform];
if (package != null && package.Header.Version > header.Version)
{
networkBuffer = package.Data;
}
await handler.WriteAsync(networkBuffer);
}
private async Task UploadPackageAsync(ITransferHandler handler)
{
using (var ms = new MemoryStream(await handler.ReadAsync()))
{
var header = new RequestHeader().Setup(ms);
var packageBytes = new byte[ms.Length - ms.Position];
await ms.ReadAsync(packageBytes, 0, packageBytes.Length);
var package = new RequestPackage(header, packageBytes);
_packages[(int)package.Header.ClientPlatform] = package;
await this.SavePackageAsync(package.Header.ClientPlatform, package);
}
}
