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); } }