public static async Task <CompressedContent> Create(HttpContent content, Compressor compressor) { var result = new CompressedContent(); await result.CompressContent(content, compressor); return(result); }
private Task WriteAsync(string content, CancellationToken cancellationToken) { var httpContent = new StringContent(content, Encoding.UTF8, "text/plain"); var compressedContent = new CompressedContent(httpContent, CompressedContent.Compression.gzip); return(_httpClient.PostAsync($"write?precision={_metricFormatter.Precision}", compressedContent, cancellationToken)); }
private void SetBody(HttpRequestMessage request) { // set body if appropriate if (_body != null) { byte[] bodyBytes = null; try { bodyBytes = Manager.GetObjectMapper().WriteValueAsBytes(_body).ToArray(); } catch (Exception e) { Log.To.Sync.E(Tag, "Error serializing body of request", e); } HttpContent entity = new ByteArrayContent(bodyBytes); entity.Headers.ContentType = new MediaTypeHeaderValue("application/json"); if (bodyBytes.Length > 100) { entity = new CompressedContent(entity, "gzip"); } request.Content = entity; } else { Log.To.Sync.W(Tag, "No body found for this request to {0}", request.RequestUri); } }
public static int Main(string[] args) { if (!Directory.Exists(CACHE_DIR)) { Directory.CreateDirectory(CACHE_DIR); } var compression = CompressedContent.Default() .Level(CompressionLevel.Optimal); var cache = ServerCache.Persistent(CACHE_DIR) .Invalidate(false); var project = Project.Create() .Add(compression) .Add(cache); var cachePolicy = ClientCache.Policy() .Duration(7) .Predicate((_, r) => r.ContentType?.KnownType != ContentType.TextHtml); return(Host.Create() .Handler(project) #if DEBUG .Development() #endif .Add(cachePolicy) .Defaults() .Console() .Run()); }
private async void Button_Click(object sender, RoutedEventArgs e) { String sourceFile = "Assets/xyy.wav"; String targetFile = "xyy.mp3"; try { IBuffer waveDates = await ReadWave(sourceFile); CompressedContent data = await WaveToMp3(waveDates); byte[] mp3Data = data.Data; DeleteFile(targetFile); SaveFile(data.Data, targetFile); IsolatedStorageFileStream stream = new IsolatedStorageFileStream(targetFile, FileMode.Open, IsolatedStorageFile.GetUserStoreForApplication()); mediaElement.SetSource(stream); mediaElement.Position = new TimeSpan(0); mediaElement.Play(); } catch (Exception ex) { String s = ex.Message; } }
public async Task CompressedContent_LoadIntoBufferAsync_ExecutesWithoutException() { var innerContent = new System.Net.Http.StringContent("Jim Jimmy Jim Jim Jimney"); var compressedContent = new CompressedContent(innerContent, "deflate"); await compressedContent.LoadIntoBufferAsync().ConfigureAwait(false); //TODO: Apart from no exception thrown, not really sure how to test this. }
public async Task CompressedContent_ReadAsByteArrayAsync_ReturnsCompressedBytes() { var contentString = "Jim Jimmy Jim Jim Jimney"; var innerContent = new System.Net.Http.StringContent(contentString); var compressedContent = new CompressedContent(innerContent, "deflate"); var result = await compressedContent.ReadAsByteArrayAsync(); Assert.IsNotNull(result); Assert.IsTrue(result.Length < contentString.Length); }
public void CompressingObjectContentShouldRetainContentType2() { //Arrange var jsonContent = new ObjectContent<Foo>(new Foo() {Bar = "Hello"}, "application/json"); //Act var compressedContent = new CompressedContent(jsonContent); //Assert Assert.AreEqual("application/json", compressedContent.Headers.ContentType.MediaType); }
public void CompressingObjectContentShouldRetainContentType() { //Arrange var stringContent = new ObjectContent<string>("Hello World", "text/plain"); //Act var compressedContent = new CompressedContent(stringContent); //Assert Assert.AreEqual("text/plain", compressedContent.Headers.ContentType.MediaType); }
public void CompressedContent_Constructor_CopiesOriginalHeaders() { var innerContent = new System.Net.Http.StringContent("Test"); innerContent.Headers.TryAddWithoutValidation("X-CustomHeader", "123"); var compressedContent = new CompressedContent(innerContent, "deflate"); IEnumerable <string> values; compressedContent.Headers.TryGetValues("X-CustomHeader", out values); Assert.AreEqual("123", values.First()); }
public void TestCustomCompression() { using var runner = new TestRunner(); runner.Host.Compression(CompressedContent.Default().Add(new CustomAlgorithm())).Start(); var request = runner.GetRequest(); request.Headers.Add("Accept-Encoding", "custom"); using var response = request.GetSafeResponse(); Assert.Equal("custom", response.ContentEncoding); }
internal async Task <HttpResponseMessage> PostSqlQueryAsync(string sqlQuery, CancellationToken token, ClickHouseParameterCollection parameters = null) { var uri = string.Empty; if (parameters == null) { uri = MakeUri(); } else { var httpParametersSupported = await this.SupportsHttpParameters(); var formattedParameters = new Dictionary <string, string>(parameters.Count); foreach (ClickHouseDbParameter parameter in parameters) { var formattedParameter = httpParametersSupported ? HttpParameterFormatter.Format(parameter) : InlineParameterFormatter.Format(parameter); formattedParameters.TryAdd(parameter.ParameterName, formattedParameter); } if (httpParametersSupported) { uri = MakeUri(null, formattedParameters); } else { sqlQuery = SubstituteParameters(sqlQuery, formattedParameters); uri = MakeUri(); } } using var postMessage = new HttpRequestMessage(HttpMethod.Post, uri); AddDefaultHttpHeaders(postMessage.Headers); HttpContent content = new StringContent(sqlQuery); content.Headers.ContentType = new MediaTypeHeaderValue("text/sql"); if (useCompression) { content = new CompressedContent(content, DecompressionMethods.GZip); } postMessage.Content = content; var response = await httpClient.SendAsync(postMessage, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false); return(await HandleError(response, sqlQuery).ConfigureAwait(false)); }
public Task WriteAsync(RavenJToken tokenToWrite) { writeCalled = true; return(SendRequestInternal(() => { HttpContent content = new JsonContent(tokenToWrite); if (!factory.DisableRequestCompression) { content = new CompressedContent(content, "gzip"); } return new HttpRequestMessage(Method, Url) { Content = content, }; })); }
public Task WriteAsync(RavenJToken tokenToWrite) { writeCalled = true; return(SendRequestInternal(() => { HttpContent content = new JsonContent(tokenToWrite); content = new CompressedContent(content, "gzip"); return new HttpRequestMessage(Method, Url) { Content = content, Headers = { TransferEncodingChunked = !EnvironmentUtils.RunningOnPosix } }; })); }
internal async Task <HttpResponseMessage> PostSqlQueryAsync(string sqlQuery, CancellationToken token) { using var postMessage = new HttpRequestMessage(HttpMethod.Post, MakeUri()); AddDefaultHttpHeaders(postMessage.Headers); HttpContent content = new StringContent(sqlQuery); content.Headers.ContentType = new MediaTypeHeaderValue("text/sql"); if (useCompression) { content = new CompressedContent(content, DecompressionMethods.GZip); } postMessage.Content = content; var response = await httpClient.SendAsync(postMessage, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false); return(await HandleError(response, sqlQuery).ConfigureAwait(false)); }
private async void Button_WavePlay_Click(object sender, RoutedEventArgs e) { try { String sourceFile = "xyy.mp3"; String targetFile = "xyy.wave"; IBuffer waveDates = await ReadWave("Assets/" + sourceFile); CompressedContent data = await Mp3ToWave(waveDates); byte[] mp3Data = data.Data; DeleteFile(targetFile); SaveFile(data.Data, targetFile); SoundEffect soudplay = new SoundEffect(mp3Data, 44100, AudioChannels.Stereo); soudplay.Play(); } catch (Exception ex) { String s = ex.Message; } }
/// <summary> /// Configures the server host with default policies for compression and security. /// </summary> /// <param name="host">The host to be configured</param> /// <param name="compression">Whether responses sent by the server should automatically be compressed</param> /// <param name="secureUpgrade">Whether the server should automatically upgrade insecure requests</param> /// <param name="strictTransport">Whether the server should send a strict transport policy</param> public static IServerHost Defaults(this IServerHost host, bool compression = true, bool secureUpgrade = true, bool strictTransport = true) { if (compression) { host.Compression(CompressedContent.Default()); } if (secureUpgrade) { host.SecureUpgrade(SecureUpgrade.Force); } if (strictTransport) { host.StrictTransport(new StrictTransportPolicy(TimeSpan.FromDays(365), true, true)); } return(host); }
public async Task <bool> UploadDivesToAPI(List <LogEntryDTO> dives) { var json = JsonConvert.SerializeObject(dives); var stringContent = new StringContent(json, Encoding.UTF8, "application/json"); var compressedContent = new CompressedContent(stringContent, "gzip"); try { var response = await _client.PostAsync("api/LogEntries", compressedContent); if (response.IsSuccessStatusCode) { return(true); } return(false); } catch (Exception ex) { throw ex; } }
protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var response = await base.SendAsync(request, cancellationToken); if (request.Headers.AcceptEncoding != null && response.Content != null) { // As per RFC2616.14.3: // Ignores encodings with quality == 0 // If multiple content-codings are acceptable, then the acceptable content-coding with the highest non-zero qvalue is preferred. var compressor = (from encoding in request.Headers.AcceptEncoding let quality = encoding.Quality ?? 1.0 where quality > 0 join c in Compressors on encoding.Value.ToLowerInvariant() equals c.EncodingType.ToLowerInvariant() orderby quality descending select c).FirstOrDefault(); if (compressor != null) { response.Content = await CompressedContent.Create(response.Content, compressor); } } return(response); }
public CustomLevelSelectSection() { levelList = new List <CustomLevel>(); isLoading = true; isLoadingAnimation = 1f; ThreadPool.UnsafeQueueUserWorkItem(_ => { JsonParser json = new JsonParser(); try { string path = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "unknown"); if (DirectoryOp.Exists(path)) { foreach (string levelPath in DirectoryOp.GetFiles(path)) { if (api == null) { break; } if (!levelPath.EndsWith(".level")) { continue; } IFileSystem levelPackage = new CompressedContent(levelPath); using ( Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) { string levelToken = PathOp.GetFileNameWithoutExtension(levelPath); LevelConfigJson config = json.Parse <LevelConfigJson>(s); string icon = ""; #if DEBUG if ((config.Description.Flags & LevelFlags.FastCamera) != 0) { icon += " Fast"; } if ((config.Description.Flags & LevelFlags.HasPit) != 0) { icon += " Pit"; } #endif if ((config.Description.Flags & LevelFlags.Multiplayer) != 0 && (config.Description.Flags & (LevelFlags.MultiplayerRace | LevelFlags.MultiplayerFlags)) == 0) { icon += " Battle"; } if ((config.Description.Flags & LevelFlags.MultiplayerRace) != 0) { icon += " Race"; } if ((config.Description.Flags & LevelFlags.MultiplayerFlags) != 0) { icon += " CTF"; } levelList.Add(new CustomLevel(config.Description.Name, "unknown", levelToken, icon)); } } levelList.Sort((x, y) => { string xs = BitmapFont.StripFormatting(x.DisplayName); string ys = BitmapFont.StripFormatting(y.DisplayName); int i = string.Compare(xs, ys, StringComparison.InvariantCulture); if (i != 0) { return(i); } return(string.Compare(x.LevelName, y.LevelName, StringComparison.InvariantCulture)); }); } } catch { // ToDo: Handle exceptions } finally { isLoading = false; } }, null); }
public bool ChangeLevel(string levelName, MultiplayerLevelType levelType) { string path = Path.Combine(DualityApp.DataDirectory, "Episodes", levelName + ".level"); if (!File.Exists(path)) { return(false); } IFileSystem levelPackage = new CompressedContent(path); lock (sync) { currentLevel = levelName; currentLevelType = levelType; // Load new level using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) { // ToDo: Cache parser JsonParser json = new JsonParser(); LevelHandler.LevelConfigJson config = json.Parse <LevelHandler.LevelConfigJson>(s); if (config.Version.LayerFormat > LevelHandler.LayerFormatVersion || config.Version.EventSet > LevelHandler.EventSetVersion) { throw new NotSupportedException("Version not supported"); } currentLevelFriendlyName = BitmapFont.StripFormatting(config.Description.Name); Log.Write(LogType.Info, "Loading level \"" + currentLevelFriendlyName + "\" (" + currentLevelType + ")..."); Point2 tileMapSize; using (Stream s2 = levelPackage.OpenFile("Sprite.layer", FileAccessMode.Read)) using (BinaryReader r = new BinaryReader(s2)) { tileMapSize.X = r.ReadInt32(); tileMapSize.Y = r.ReadInt32(); } levelBounds = new Rect(tileMapSize * /*tileMap.Tileset.TileSize*/ 32); collisions = new DynamicTreeBroadPhase <ICollisionable>(); // Read events eventMap = new ServerEventMap(tileMapSize); if (levelPackage.FileExists("Events.layer")) { using (Stream s2 = levelPackage.OpenFile("Events.layer", FileAccessMode.Read)) { eventMap.ReadEvents(s2, config.Version.LayerFormat); } } } // Send request to change level to all players foreach (KeyValuePair <NetConnection, Player> pair in players) { pair.Value.State = PlayerState.NotReady; } playerConnections.Clear(); foreach (KeyValuePair <NetConnection, Player> pair in players) { Send(new LoadLevel { LevelName = currentLevel, LevelType = currentLevelType, AssignedPlayerIndex = pair.Value.Index }, 64, pair.Key, NetDeliveryMethod.ReliableUnordered, PacketChannels.Main); } } return(true); }
public void CompressedContent_Constructor_ThrowsOnNullEncoding() { var innerContent = new System.Net.Http.StringContent("Test"); var compressedContent = new CompressedContent(innerContent, null); }
public void CompressedContent_Constructor_ThrowsOnNullContent() { var compressedContent = new CompressedContent(null, "gzip"); }
public void CompressedContent_Constructor_ThrowsOnUnsupportedContentType() { var innerContent = new System.Net.Http.StringContent("Test"); var compressedContent = new CompressedContent(innerContent, "123"); }
private void PrerenderTexturedBackground() { try { // Try to use "The Secret Files" background string levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "secretf", "01_easter1.level"); if (!FileOp.Exists(levelPath)) { // Try to use "Base Game" background levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "prince", "03_carrot1.level"); if (!FileOp.Exists(levelPath)) { // Try to use "Holiday Hare '98" background levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "xmas98", "03_xmas3.level"); if (!FileOp.Exists(levelPath)) { // Try to use "Christmas Chronicles" background levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "xmas99", "03_xmas3.level"); if (!FileOp.Exists(levelPath)) { // Try to use "Shareware Demo" background; levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "share", "02_share2.level"); if (!FileOp.Exists(levelPath)) { // No usable background found throw new FileNotFoundException(); } } } } } // Load metadata IFileSystem levelPackage = new CompressedContent(levelPath); LevelHandler.LevelConfigJson config; using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) { config = ContentResolver.Current.Json.Parse <LevelHandler.LevelConfigJson>(s); } LevelHandler.LevelConfigJson.LayerSection layer; if (config.Layers.TryGetValue("Sky", out layer)) { if (layer.BackgroundColor != null && layer.BackgroundColor.Count >= 3) { horizonColor = new Vector4(layer.BackgroundColor[0] / 255f, layer.BackgroundColor[1] / 255f, layer.BackgroundColor[2] / 255f, 1f); } switch ((BackgroundStyle)layer.BackgroundStyle) { default: case BackgroundStyle.Sky: texturedBackgroundShader = ContentResolver.Current.RequestShader("TexturedBackground"); break; case BackgroundStyle.Circle: texturedBackgroundShader = ContentResolver.Current.RequestShader("TexturedBackgroundCircle"); break; } } // Render background layer to texture TileSet levelTileset = new TileSet(config.Description.DefaultTileset, true, null); if (!levelTileset.IsValid) { throw new InvalidDataException(); } using (Stream s = levelPackage.OpenFile("Sky.layer", FileAccessMode.Read)) { using (BinaryReader r = new BinaryReader(s)) { int width = r.ReadInt32(); int height = r.ReadInt32(); TileMapLayer newLayer = new TileMapLayer(); newLayer.Layout = new LayerTile[width * height]; for (int i = 0; i < newLayer.Layout.Length; i++) { ushort tileType = r.ReadUInt16(); byte flags = r.ReadByte(); if (flags == 0) { newLayer.Layout[i] = levelTileset.GetDefaultTile(tileType); continue; } bool isFlippedX = (flags & 0x01) > 0; bool isFlippedY = (flags & 0x02) > 0; bool isAnimated = (flags & 0x04) > 0; bool legacyTranslucent = (flags & 0x80) > 0; // Invalid tile numbers (higher than tileset tile amount) are silently changed to empty tiles if (tileType >= levelTileset.TileCount && !isAnimated) { tileType = 0; } LayerTile tile; // Copy the default tile and do stuff with it tile = levelTileset.GetDefaultTile(tileType); tile.IsFlippedX = isFlippedX; tile.IsFlippedY = isFlippedY; tile.IsAnimated = isAnimated; if (legacyTranslucent) { tile.MaterialAlpha = /*127*/ 140; } newLayer.Layout[i] = tile; } newLayer.LayoutWidth = width; RecreateTexturedBackground(levelTileset, ref newLayer); } } } catch (Exception ex) { Log.Write(LogType.Warning, "Cannot prerender textured background: " + ex); cachedTexturedBackground = new Texture(new Pixmap(new PixelData(2, 2, ColorRgba.Black))); } }
private void LoadLevel(string level, string episode) { string levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", episode, level + ".level"); IFileSystem levelPackage = new CompressedContent(levelPath); // ToDo: Cache parser, move JSON parsing to ContentResolver JsonParser jsonParser = new JsonParser(); LevelConfigJson json; using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) { json = jsonParser.Parse <LevelConfigJson>(s); } if (json.Version.LayerFormat > LayerFormatVersion || json.Version.EventSet > EventSetVersion) { throw new NotSupportedException("Level version not supported"); } App.Log("Loading level \"" + json.Description.Name + "\"..."); root.Title = BitmapFont.StripFormatting(json.Description.Name); root.Immersive = false; defaultNextLevel = json.Description.NextLevel; defaultSecretLevel = json.Description.SecretLevel; ambientLightDefault = json.Description.DefaultLight; ambientLightCurrent = ambientLightTarget = ambientLightDefault * 0.01f; if (json.Description.DefaultDarkness != null && json.Description.DefaultDarkness.Count >= 4) { darknessColor = new Vector4(json.Description.DefaultDarkness[0] / 255f, json.Description.DefaultDarkness[1] / 255f, json.Description.DefaultDarkness[2] / 255f, json.Description.DefaultDarkness[3] / 255f); } else { darknessColor = new Vector4(0, 0, 0, 1); } // Palette ColorRgba[] tileMapPalette; if (levelPackage.FileExists("Main.palette")) { using (Stream s = levelPackage.OpenFile("Main.palette", FileAccessMode.Read)) { tileMapPalette = TileSet.LoadPalette(s); } } else { tileMapPalette = null; } // Tileset tileMap = new TileMap(this, json.Description.DefaultTileset, tileMapPalette, (json.Description.Flags & LevelFlags.HasPit) != 0); // Additional tilesets if (json.Tilesets != null) { for (int i = 0; i < json.Tilesets.Count; i++) { LevelConfigJson.TilesetSection part = json.Tilesets[i]; tileMap.ReadTilesetPart(part.Name, part.Offset, part.Count); } } // Read all layers json.Layers.Add("Sprite", new LevelConfigJson.LayerSection { XSpeed = 1, YSpeed = 1 }); foreach (var layer in json.Layers.OrderBy(layer => layer.Value.Depth)) { LayerType type; if (layer.Key == "Sprite") { type = LayerType.Sprite; } else if (layer.Key == "Sky") { type = LayerType.Sky; //if (layer.Value.BackgroundStyle != 0 /*Plain*/ && layer.Value.BackgroundColor != null && layer.Value.BackgroundColor.Count >= 3) { // camera.GetComponent<Camera>().ClearColor = new ColorRgba((byte)layer.Value.BackgroundColor[0], (byte)layer.Value.BackgroundColor[1], (byte)layer.Value.BackgroundColor[2]); //} } else { type = LayerType.Other; } using (Stream s = levelPackage.OpenFile(layer.Key + ".layer", FileAccessMode.Read)) { tileMap.ReadLayerConfiguration(type, s, layer.Value); } } // Read animated tiles if (levelPackage.FileExists("Animated.tiles")) { using (Stream s = levelPackage.OpenFile("Animated.tiles", FileAccessMode.Read)) { tileMap.ReadAnimatedTiles(s); } } levelBounds = new Rect(tileMap.Size * tileMap.Tileset.TileSize); // Read events eventMap = new EventMap(this, tileMap.Size); if (levelPackage.FileExists("Events.layer")) { using (Stream s2 = levelPackage.OpenFile("Events.layer", FileAccessMode.Read)) { eventMap.ReadEvents(s2, json.Version.LayerFormat, difficulty); } } GameObject tilemapHandler = new GameObject(); tilemapHandler.Parent = rootObject; tilemapHandler.AddComponent(tileMap); // Load default music musicPath = PathOp.Combine(DualityApp.DataDirectory, "Music", json.Description.DefaultMusic); music = new OpenMptStream(musicPath, true); music.BeginFadeIn(0.5f); DualityApp.Sound.PlaySound(music); // Apply weather if (json.Description.DefaultWeather != WeatherType.None) { ApplyWeather( json.Description.DefaultWeather, json.Description.DefaultWeatherIntensity, json.Description.DefaultWeatherOutdoors); } // Load level text events levelTexts = json.TextEvents ?? new List <string>(); if (FileOp.Exists(levelPath + "." + i18n.Language)) { try { using (Stream s = FileOp.Open(levelPath + "." + i18n.Language, FileAccessMode.Read)) { json = jsonParser.Parse <LevelConfigJson>(s); if (json.TextEvents != null) { for (int i = 0; i < json.TextEvents.Count && i < levelTexts.Count; i++) { if (json.TextEvents[i] != null) { levelTexts[i] = json.TextEvents[i]; } } } } } catch (Exception ex) { App.Log("Cannot load i18n for this level: " + ex); } } }
public void RequestTileset(string path, bool applyPalette, ColorRgba[] customPalette, out ContentRef<Material> materialRef, out PixelData mask) { IFileSystem tilesetPackage = new CompressedContent(PathOp.Combine(DualityApp.DataDirectory, "Tilesets", path + ".set")); // Palette if (applyPalette) { if (customPalette != null) { ApplyBasePalette(customPalette); } else if (tilesetPackage.FileExists("Main.palette")) { ApplyBasePalette(TileSet.LoadPalette(tilesetPackage.OpenFile("Main.palette", FileAccessMode.Read))); } } // Load textures PixelData texturePixels; using (Stream s = tilesetPackage.OpenFile("Diffuse.png", FileAccessMode.Read)) { texturePixels = new Png(s).GetPixelData(); } #if !DISABLE_NORMAL_MAPPING PixelData normalPixels; if (tilesetPackage.FileExists("Normals.png")) { using (Stream s = tilesetPackage.OpenFile("Normals.png", FileAccessMode.Read)) { normalPixels = new Png(s).GetPixelData(); } } else { normalPixels = null; } #endif using (Stream s = tilesetPackage.OpenFile("Mask.png", FileAccessMode.Read)) { mask = new Png(s).GetPixelData(); } // Apply palette to tileset ColorRgba[] palette = paletteTexture.Res.BasePixmap.Res.MainLayer.Data; ColorRgba[] data = texturePixels.Data; #if !DISABLE_ASYNC Parallel.ForEach(Partitioner.Create(0, data.Length), range => { for (int i = range.Item1; i < range.Item2; i++) { #else for (int i = 0; i < data.Length; i++) { #endif int colorIdx = data[i].R; data[i] = palette[colorIdx].WithAlpha(palette[colorIdx].A * data[i].A / (255f * 255f)); } #if !DISABLE_ASYNC }); #endif ContentRef<Texture> mainTex = new Texture(new Pixmap(texturePixels)); ContentRef<Texture> normalTex; #if !DISABLE_NORMAL_MAPPING if (normalPixels == null) { normalTex = DefaultNormalMap; } else { normalTex = new Texture(new Pixmap(normalPixels)); normalTex.Res.DetachSource(); } #else normalTex = DefaultNormalMap; #endif // Create material Material material = new Material(RequestShader("BasicNormal")); material.SetTexture("mainTex", mainTex); material.SetTexture("normalTex", normalTex); material.SetValue("normalMultiplier", Vector2.One); materialRef = material; }
public void CompressedContent_Constructor_ConstructsOkWithContentAndDeflateEncoding() { var innerContent = new System.Net.Http.StringContent("Test"); var compressedContent = new CompressedContent(innerContent, "deflate"); }
/// <summary> /// Store takes a batch of RoutedItem, all going to the same share destination, and uploads them as a single operation. This is done to solve the many small files problem.Larger files can go individually. /// </summary> /// <param name="batch"></param> /// <param name="taskID"></param> /// <param name="connection"></param> /// <returns></returns> public async Task store(List <RoutedItem> batch, int taskID, LITEConnection connection) { Connection = connection; var taskInfo = $"task: {taskID} connection: {Connection.name}"; StreamContent streamContent = null; MultipartContent content = null; HttpResponseMessage response = null; string testFile = null; var firstRecord = batch.First(); try { var stopWatch = new Stopwatch(); stopWatch.Start(); //set the URL //string resourceURL = Connection.URL + "/api/File"; string resourceURL = Connection.URL + FileAgentConstants.BaseUrl; _logger.Log(LogLevel.Debug, $"{taskInfo} URL: {resourceURL}"); // generate guid for boundary...boundaries cannot be accidentally found in the content var boundary = Guid.NewGuid(); _logger.Log(LogLevel.Debug, $"{taskInfo} boundary: {boundary}"); // create the content content = new MultipartContent("related", boundary.ToString()); //add the sharing headers List <string> shareHeader = new List <string>(); if (Connection.shareDestinations != null) { foreach (var connectionSet in firstRecord.toConnections.FindAll(e => e.connectionName.Equals(Connection.name))) { if (connectionSet.shareDestinations != null) { foreach (var shareDestination in connectionSet.shareDestinations) { shareHeader.Add(shareDestination.boxUuid); _logger.Log(LogLevel.Debug, $"{taskInfo} sharing to: {shareDestination.boxId} {shareDestination.boxName} {shareDestination.groupId} {shareDestination.groupName} {shareDestination.organizationName} {shareDestination.publishableBoxType}"); } } } } content.Headers.Add("X-Li-Destination", shareHeader); long fileSize = 0; var profile = _profileStorage.Current; var dir = profile.tempPath + Path.DirectorySeparatorChar + Connection.name + Path.DirectorySeparatorChar + "toEGS"; Directory.CreateDirectory(dir); testFile = dir + Path.DirectorySeparatorChar + Guid.NewGuid() + ".gz"; using (FileStream compressedFileStream = File.Create(testFile)) { using GZipStream compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress); foreach (var routedItem in batch) { if (File.Exists(routedItem.sourceFileName)) { routedItem.stream = File.OpenRead(routedItem.sourceFileName); if (Connection.calcCompressionStats) { routedItem.stream.CopyTo(compressionStream); } fileSize += routedItem.length; streamContent = new StreamContent(routedItem.stream); streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = routedItem.sourceFileName }; content.Add(streamContent); streamContent.Headers.Add("content-type", "application/octet-stream"); } else { _logger.Log(LogLevel.Error, $"{taskInfo} {routedItem.sourceFileName} no longer exists. Increase tempFileRetentionHours for heavy transfer backlogs that may take hours!!"); routedItem.Error = "File no longer exists"; _routedItemManager.Init(routedItem); _routedItemManager.Dequeue(Connection, Connection.toEGS, nameof(Connection.toEGS), error: true); } } } if (Connection.calcCompressionStats) { FileInfo info = new FileInfo(testFile); _logger.Log(LogLevel.Information, $"{taskInfo} orgSize: {fileSize} compressedSize: {info.Length} reduction: {(fileSize == 0 ? 0 : (fileSize * 1.0 - info.Length) / (fileSize) * 100)}%"); } // issue the POST Task <HttpResponseMessage> task; var httpClient = _liteHttpClient.GetClient(connection); if (firstRecord.Compress == true) { var compressedContent = new CompressedContent(content, "gzip"); _logger.Log(LogLevel.Debug, $"{taskInfo} compressedContent.Headers {compressedContent.Headers} "); compressedContent.Headers.Remove("Content-Encoding"); var cookies = _liteHttpClient.GetCookies(resourceURL); _logger.LogCookies(cookies, taskInfo); task = httpClient.PostAsync(resourceURL, compressedContent); } else { _logger.Log(LogLevel.Debug, $"{taskInfo} will send content.Headers {content.Headers}"); var cookies = _liteHttpClient.GetCookies(resourceURL); _logger.LogCookies(cookies, taskInfo); task = httpClient.PostAsync(resourceURL, content); } response = await task; // output the result _logger.LogHttpResponseAndHeaders(response, taskInfo); _logger.Log(LogLevel.Debug, $"{taskInfo} response.Content.ReadAsStringAsync(): {await response.Content.ReadAsStringAsync()}"); stopWatch.Stop(); _logger.Log(LogLevel.Information, $"{taskInfo} elapsed: {stopWatch.Elapsed} size: {fileSize} rate: {(float)fileSize / stopWatch.Elapsed.TotalMilliseconds * 1000 / 1000000} MB/s"); switch (response.StatusCode) { case HttpStatusCode.Created: //dequeue the work, we're done! if (streamContent != null) { streamContent.Dispose(); } if (response != null) { response.Dispose(); } if (content != null) { content.Dispose(); } foreach (var ri in batch) { _routedItemManager.Init(ri); _routedItemManager.Dequeue(Connection, Connection.toEGS, nameof(Connection.toEGS)); } //let EGGS know it's available, or when we convert udt to .net core then perhaps push so no open socket required on client. //await SendToAllHubs(LITEServicePoint, batch); break; case HttpStatusCode.UnprocessableEntity: //dequeue the work, we're done! _logger.Log(LogLevel.Warning, $"creation of {firstRecord.sourceFileName} and others in batch failed with {response.StatusCode}"); if (streamContent != null) { streamContent.Dispose(); } if (response != null) { response.Dispose(); } if (content != null) { content.Dispose(); } foreach (var ri in batch) { ri.Error = HttpStatusCode.UnprocessableEntity.ToString(); _routedItemManager.Init(ri); _routedItemManager.Dequeue(Connection, Connection.toEGS, nameof(Connection.toEGS), error: true); } break; default: if (response.StatusCode == HttpStatusCode.Unauthorized) { Connection.loginNeeded = true; } _logger.Log(LogLevel.Warning, $"creation of {firstRecord.sourceFileName} and others in batch failed with {response.StatusCode}"); _liteHttpClient.DumpHttpClientDetails(); break; } //delete the compression test file File.Delete(testFile); } catch (TaskCanceledException) { _logger.Log(LogLevel.Information, $"Task was canceled."); } catch (HttpRequestException e) { _logger.Log(LogLevel.Warning, $"{taskInfo} Exception: {e.Message} {e.StackTrace}"); if (e.InnerException != null) { _logger.Log(LogLevel.Warning, $"Inner Exception: {e.InnerException}"); } _liteHttpClient.DumpHttpClientDetails(); } catch (FileNotFoundException e) { _logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}"); } catch (IOException e) { _logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}"); } catch (Exception e) { _logger.LogFullException(e, taskInfo); _liteHttpClient.DumpHttpClientDetails(); } finally { try { if (streamContent != null) { streamContent.Dispose(); } if (response != null) { response.Dispose(); } if (content != null) { content.Dispose(); } File.Delete(testFile); _taskManager.Stop($"{Connection.name}.Store"); } catch (Exception e) { _logger.LogFullException(e, taskInfo); } } }
internal async Task <ClientResponseWithObject <T> > SendAsync <T>(HttpMethod method, object body, string urlPart, Dictionary <string, string> queryParameters, Dictionary <string, string> headers, bool useGzip = false) { ClientResponseWithObject <T> clientResponse = null; var messageHandler = new ApiHttpMessageHandler(useGzip); var jsonSerializerSettings = new JsonSerializerSettings(); jsonSerializerSettings.Converters.Add(new StringEnumConverter()); using (var client = new HttpClient(messageHandler)) { client.BaseAddress = _configuration.ApiBaseEndpoint; client.Timeout = _configuration.Timeout; client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.AuthorizationHeader, string.Format("{0} {1}", Constants.AuthorizationMethodSlamby, _configuration.ApiSecret)); client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.SdkVersionHeader, GetType().GetTypeInfo().Assembly.GetName().Version.ToString()); if (_configuration.ParallelLimit > 0) { client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.ApiParallelLimitHeader, _configuration.ParallelLimit.ToString()); } if (useGzip) { client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip")); } if (headers != null) { foreach (var header in headers) { client.DefaultRequestHeaders.Add(header.Key, header.Value); } } HttpContent content = null; if (body != null) { var json = JsonConvert.SerializeObject(body, jsonSerializerSettings); content = new StringContent(json, Encoding.UTF8, "application/json"); if (useGzip) { content = new CompressedContent(content, "gzip"); } } else { content = new StringContent(string.Empty, Encoding.UTF8, "application/json"); } HttpResponseMessage responseMsg = null; var appendedUri = _appendQueryString(_endpoint, urlPart, queryParameters); if (method == HttpMethod.Get) { responseMsg = await client.GetAsync(appendedUri); } else if (method == HttpMethod.Post) { responseMsg = await client.PostAsync(appendedUri, content); } else if (method == HttpMethod.Delete) { responseMsg = await client.DeleteAsync(appendedUri); } else if (method == HttpMethod.Put) { responseMsg = await client.PutAsync(appendedUri, content); } else { throw new NotImplementedException(); } clientResponse = new ClientResponseWithObject <T> { HttpStatusCode = responseMsg.StatusCode, IsSuccessful = responseMsg.IsSuccessStatusCode, ServerMessage = responseMsg.ReasonPhrase }; var respString = await responseMsg.Content.ReadAsStringAsync(); try { if (!string.IsNullOrEmpty(respString)) { if (responseMsg.IsSuccessStatusCode) { clientResponse.ResponseObject = JsonConvert.DeserializeObject <T>(respString, jsonSerializerSettings); } else { clientResponse.Errors = JsonConvert.DeserializeObject <ErrorsModel>(respString, jsonSerializerSettings); } } } catch (JsonSerializationException ex) { Debug.WriteLine(ex.Message); clientResponse.IsSuccessful = false; clientResponse.Errors = ErrorsModel.Create("Response is not a Valid or Expected Type of JSON:\n" + respString); } clientResponse.ApiVersion = responseMsg.Headers.Where(header => string.Equals(header.Key, Constants.ApiVersionHeader, StringComparison.OrdinalIgnoreCase)) .SelectMany(header => header.Value) .FirstOrDefault() ?? string.Empty; return(clientResponse); } }
public async Task stowAsMultiPart(List <RoutedItem> batch, int taskID, LifeImageCloudConnection Connection, IHttpManager httpManager) { Throw.IfNull(Connection); Throw.IfNull(httpManager); var taskInfo = $"task: {taskID} connection: {Connection.name}"; StreamContent streamContent = null; MultipartContent content = null; HttpResponseMessage response = null; string testFile = null; var firstRecord = batch.First(); var httpClient = _liteHttpClient.GetClient(Connection); try { var stopWatch = new Stopwatch(); stopWatch.Start(); //set the URL //string stowURL = Connection.URL + "/api/agent/v1/stow/studies"; string stowURL = Connection.URL + CloudAgentConstants.StowStudies; _logger.Log(LogLevel.Debug, $"{taskInfo} stowURL: {stowURL}"); // generate guid for boundary...boundaries cannot be accidentally found in the content var boundary = Guid.NewGuid(); _logger.Log(LogLevel.Debug, $"{taskInfo} boundary: {boundary}"); // create the content content = new MultipartContent("related", boundary.ToString()); //add the sharing headers List <string> shareHeader = new List <string>(); if (Connection.shareDestinations != null) { foreach (var connectionSet in firstRecord.toConnections.FindAll(e => e.connectionName.Equals(Connection.name))) { if (connectionSet.shareDestinations != null) { foreach (var shareDestination in connectionSet.shareDestinations) { shareHeader.Add(shareDestination.boxUuid); _logger.Log(LogLevel.Debug, $"{taskInfo} sharing to: {shareDestination.boxId} {shareDestination.boxName} {shareDestination.groupId} {shareDestination.groupName} {shareDestination.organizationName} {shareDestination.publishableBoxType}"); } } } } content.Headers.Add("X-Li-Destination", shareHeader); long fileSize = 0; var dir = _profileStorage.Current.tempPath + Path.DirectorySeparatorChar + Connection.name + Path.DirectorySeparatorChar + Constants.Dirs.ToCloud; Directory.CreateDirectory(dir); testFile = dir + Path.DirectorySeparatorChar + Guid.NewGuid() + ".gz"; using (FileStream compressedFileStream = File.Create(testFile)) { using GZipStream compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress); foreach (var routedItem in batch) { if (File.Exists(routedItem.sourceFileName)) { routedItem.stream = File.OpenRead(routedItem.sourceFileName); if (Connection.CalcCompressionStats) { routedItem.stream.CopyTo(compressionStream); } fileSize += routedItem.length; streamContent = new StreamContent(routedItem.stream); streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = routedItem.sourceFileName }; content.Add(streamContent); //shb 2017-11-01 streamcontent (uncompressed) is inside content (can be compressed below) server is complaining so will comment out //streamContent.Headers.Add("Content-Transfer-Encoding", "gzip"); //shb 2017-11-10 shb added content-type header to solve //controller.DicomRSControllerBase: Content-Encoding header has value null !!! //controller.StowRSController: Unable to process part 1 no content-type parameter received streamContent.Headers.Add("content-type", "application/dicom"); } else { _logger.Log(LogLevel.Error, $"{taskInfo} {routedItem.sourceFileName} no longer exists. Increase tempFileRetentionHours for heavy transfer backlogs that may take hours!!"); } } } if (Connection.CalcCompressionStats) { FileInfo info = new FileInfo(testFile); _logger.Log(LogLevel.Information, $"{taskInfo} orgSize: {fileSize} compressedSize: {info.Length} reduction: {(fileSize == 0 ? 0 : (fileSize * 1.0 - info.Length) / (fileSize) * 100)}%"); } // issue the POST Task <HttpResponseMessage> task; if (firstRecord.Compress == true) { var compressedContent = new CompressedContent(content, "gzip"); _logger.Log(LogLevel.Debug, $"{taskInfo} compressedContent.Headers {compressedContent.Headers} "); var cookies = _liteHttpClient.GetCookies(stowURL); _logger.LogCookies(cookies, taskInfo); task = httpClient.PostAsync(stowURL, compressedContent, _taskManager.cts.Token); } else { _logger.Log(LogLevel.Debug, $"{taskInfo} will send content.Headers {content.Headers}"); var cookies = _liteHttpClient.GetCookies(stowURL); _logger.LogCookies(cookies, taskInfo); task = httpClient.PostAsync(stowURL, content, _taskManager.cts.Token); } response = await task; // output the result _logger.LogHttpResponseAndHeaders(response, taskInfo); _logger.Log(LogLevel.Debug, $"{taskInfo} response.Content.ReadAsStringAsync(): {await response.Content.ReadAsStringAsync()}"); stopWatch.Stop(); _logger.Log(LogLevel.Information, $"{taskInfo} elapsed: {stopWatch.Elapsed} size: {fileSize} rate: {(float)fileSize / stopWatch.Elapsed.TotalMilliseconds * 1000 / 1000000} MB/s"); if (!(response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Accepted)) { if (response.StatusCode == HttpStatusCode.Unauthorized) { httpManager.loginNeeded = true; } _logger.Log(LogLevel.Warning, $"stow of {firstRecord.sourceFileName} and others in batch failed with {response.StatusCode}"); _liteHttpClient.DumpHttpClientDetails(); } else { //dequeue the work, we're done! if (streamContent != null) { streamContent.Dispose(); } if (response != null) { response.Dispose(); } if (content != null) { content.Dispose(); } foreach (var ri in batch) { _routedItemManager.Init(ri); _routedItemManager.Dequeue(Connection, Connection.toCloud, nameof(Connection.toCloud)); } } //delete the compression test file File.Delete(testFile); } catch (TaskCanceledException) { _logger.Log(LogLevel.Information, $"{taskInfo} Task was canceled."); } catch (HttpRequestException e) { _logger.Log(LogLevel.Warning, $"{taskInfo} Exception: {e.Message} {e.StackTrace}"); if (e.InnerException != null) { _logger.Log(LogLevel.Warning, $"{taskInfo} Inner Exception: {e.InnerException}"); } _liteHttpClient.DumpHttpClientDetails(); } catch (FileNotFoundException e) { _logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}"); } catch (IOException e) { _logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}"); } catch (Exception e) { _logger.LogFullException(e, taskInfo); _liteHttpClient.DumpHttpClientDetails(); } finally { try { if (streamContent != null) { streamContent.Dispose(); } if (response != null) { response.Dispose(); } if (content != null) { content.Dispose(); } File.Delete(testFile); _taskManager.Stop($"{Connection.name}.Stow"); } catch (Exception e) { _logger.LogFullException(e, taskInfo); } } }
private void LoadLevel(string level, string episode) { string levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", episode, level + ".level"); IFileSystem levelPackage = new CompressedContent(levelPath); LevelConfigJson json; using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) { json = ContentResolver.Current.Json.Parse <LevelConfigJson>(s); } if (json.Version.LayerFormat > LayerFormatVersion || json.Version.EventSet > EventSetVersion) { throw new NotSupportedException("Level version not supported"); } Log.Write(LogType.Info, "Loading level \"" + json.Description.Name + "\"..."); levelFriendlyName = json.Description.Name; //defaultNextLevel = json.Description.NextLevel; //defaultSecretLevel = json.Description.SecretLevel; // Palette ColorRgba[] tileMapPalette; if (levelPackage.FileExists("Main.palette")) { using (Stream s = levelPackage.OpenFile("Main.palette", FileAccessMode.Read)) { tileMapPalette = TileSet.LoadPalette(s); } } else { tileMapPalette = null; } // Tileset tileMap = new TileMap(this, json.Description.DefaultTileset, tileMapPalette, (json.Description.Flags & LevelFlags.HasPit) != 0); // Additional tilesets if (json.Tilesets != null) { for (int i = 0; i < json.Tilesets.Count; i++) { LevelConfigJson.TilesetSection part = json.Tilesets[i]; tileMap.ReadTilesetPart(part.Name, part.Offset, part.Count); } } // Read all layers json.Layers.Add("Sprite", new LevelConfigJson.LayerSection { XSpeed = 1, YSpeed = 1 }); foreach (var layer in json.Layers.OrderBy(layer => layer.Value.Depth)) { LayerType type; if (layer.Key == "Sprite") { type = LayerType.Sprite; } else if (layer.Key == "Sky") { type = LayerType.Sky; //if (layer.Value.BackgroundStyle != 0 /*Plain*/ && layer.Value.BackgroundColor != null && layer.Value.BackgroundColor.Count >= 3) { // camera.GetComponent<Camera>().ClearColor = new ColorRgba((byte)layer.Value.BackgroundColor[0], (byte)layer.Value.BackgroundColor[1], (byte)layer.Value.BackgroundColor[2]); //} } else { type = LayerType.Other; } using (Stream s = levelPackage.OpenFile(layer.Key + ".layer", FileAccessMode.Read)) { tileMap.ReadLayerConfiguration(type, s, layer.Value); } } // Read animated tiles if (levelPackage.FileExists("Animated.tiles")) { using (Stream s = levelPackage.OpenFile("Animated.tiles", FileAccessMode.Read)) { tileMap.ReadAnimatedTiles(s); } } levelBounds = new Rect(tileMap.Size * tileMap.Tileset.TileSize); // Read events eventMap = new EventMap(this, tileMap.Size); if (levelPackage.FileExists("Events.layer")) { using (Stream s2 = levelPackage.OpenFile("Events.layer", FileAccessMode.Read)) { eventMap.ReadEvents(s2, json.Version.LayerFormat, difficulty); } } GameObject tilemapHandler = new GameObject(); tilemapHandler.Parent = rootObject; tilemapHandler.AddComponent(tileMap); // Apply weather if (json.Description.DefaultWeather != WeatherType.None) { ApplyWeather( json.Description.DefaultWeather, json.Description.DefaultWeatherIntensity, json.Description.DefaultWeatherOutdoors); } // Load level text events levelTexts = json.TextEvents ?? new List <string>(); /*if (FileOp.Exists(levelPath + "." + i18n.Language)) { * try { * using (Stream s = FileOp.Open(levelPath + "." + i18n.Language, FileAccessMode.Read)) { * json = ContentResolver.Current.Json.Parse<LevelConfigJson>(s); * if (json.TextEvents != null) { * for (int i = 0; i < json.TextEvents.Count && i < levelTexts.Count; i++) { * if (json.TextEvents[i] != null) { * levelTexts[i] = json.TextEvents[i]; * } * } * } * } * } catch (Exception ex) { * Log.Write(LogType.Warning, "Cannot load i18n for this level: " + ex); * } * }*/ eventMap.ActivateEvents(int.MinValue, int.MinValue, int.MaxValue, int.MaxValue, false); }