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);
		}
示例#2
0
		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;
		}
示例#3
0
		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());
			}
		}
		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);
			}
		}