public async Task <T> LoadAsync <T>(string key) where T : class { var configuration = GetConfiguration(key); if (configuration == null) { _logger.LogInformation($"Loading data file locally: {_componentId}:{key}"); return(await _baseDataStore.LoadAsync <T>(key)); } var url = GetUrl(key); var response = await _client.GetAsync(url); if (!response.IsSuccessStatusCode) { throw new Exception($"Server responded with {(int)response.StatusCode} - {response.StatusCode} for URL: GET {url}"); } var serializedYaml = await response.Content.ReadAsStringAsync(); return(m_Deserializer.Deserialize <T>(serializedYaml)); }
private IRestResponse<T> Deserialize<T>(IRestRequest request, IRestResponse raw) { request.OnBeforeDeserialization(raw); IDeserializer handler = GetHandler(raw.ContentType); handler.RootElement = request.RootElement; handler.DateFormat = request.DateFormat; handler.Namespace = request.XmlNamespace; IRestResponse<T> response = new RestResponse<T>(); try { response = raw.toAsyncResponse<T>(); response.Data = handler.Deserialize<T>(raw); response.Request = request; } catch (Exception ex) { response.ResponseStatus = ResponseStatus.Error; response.ErrorMessage = ex.Message; response.ErrorException = ex; } return response; }
public static News DownloadNews() { string rawData; try { rawData = RemoteObjectManager.Instance.DownloadObjectAsString("news.yaml"); } catch (Exception ex) { throw new NewsParsingException($"Failed to download update news data: {ex.Message}", ex); } try { return(deserializer.Deserialize <News>(rawData)); } catch (Exception ex) { throw new NewsParsingException($"Failed to parse update news data: {ex.Message}", ex); } }
public ReadYamlFileResult ReadYamlFile(string yamlFile) { // TODO: Firetrust.MailWasherPro -> copyright sign works with Encoding.Default, but other packages have wrong signs then using (StreamReader streamReader = new StreamReader(yamlFile, true)) { try { ManifestPackage_1_0_0 package = _deserializer.Deserialize <ManifestPackage_1_0_0>(streamReader); return(new ReadYamlFileResult() { Manifest = package, FilePath = yamlFile }); } catch (YamlException ex) { return(new ReadYamlFileResult() { ErrorMessage = GetMessage(ex), FilePath = yamlFile }); } } }
// Register and validate a conversation in real-time public void RegisterConversation(string name, TextAsset file) { var tempObject = _deserializer.Deserialize <Conversation>(file.text); if (tempObject == null) { DialogueLogger.LogError($"There was an error deserializing file {file.name}"); return; } tempObject.PreValidation(); if (valdateConversation(tempObject, name)) { if (_conversations.ContainsKey(name)) { DialogueLogger.LogWarning($"Conversation {name} already registered, overwritting"); } _conversations[name] = tempObject; tempObject.FinishedParsing(); } }
private void DeserializeMetrics(YamlMappingNode node, MetricDefinitionV1 metricDefinition, IErrorReporter errorReporter) { if (metricDefinition.ResourceType == null) { return; } var resourceTypeNode = node.Children["resourceType"]; if (metricDefinition.ResourceType == ResourceType.NotSpecified) { errorReporter.ReportError(resourceTypeNode, "'resourceType' must not be set to 'NotSpecified'."); return; } if (node.Children.TryGetValue(ResourceCollectionsTag, out var resourceCollectionNode)) { metricDefinition.ResourceCollections = _azureResourceCollectionDeserializer.Deserialize((YamlSequenceNode)resourceCollectionNode, errorReporter); } if (node.Children.TryGetValue(ResourcesTag, out var metricsNode)) { var resourceDeserializer = _azureResourceDeserializerFactory.GetDeserializerFor(metricDefinition.ResourceType.Value); if (resourceDeserializer != null) { metricDefinition.Resources = resourceDeserializer.Deserialize((YamlSequenceNode)metricsNode, errorReporter); } else { errorReporter.ReportError(resourceTypeNode, $"Could not find a deserializer for resource type '{metricDefinition.ResourceType}'."); } } if ((metricDefinition.Resources == null || !metricDefinition.Resources.Any()) && (metricDefinition.ResourceCollections == null || !metricDefinition.ResourceCollections.Any())) { errorReporter.ReportError(node, "Either 'resources' or 'resourceCollections' must be specified."); } }
private IRestResponse <T> Deserialize <T>(IRestRequest request, IRestResponse raw) { request.OnBeforeDeserialization(raw); IRestResponse <T> response = new RestResponse <T>(); try { response = raw.ToAsyncResponse <T>(); response.Request = request; // Only attempt to deserialize if the request has not errored due // to a transport or framework exception. HTTP errors should attempt to // be deserialized if (response.ErrorException == null) { IDeserializer handler = this.GetHandler(raw.ContentType); // Only continue if there is a handler defined else there is no way to deserialize the data. // This can happen when a request returns for example a 404 page instead of the requested JSON/XML resource if (handler != null) { handler.RootElement = request.RootElement; handler.DateFormat = request.DateFormat; handler.Namespace = request.XmlNamespace; response.Data = handler.Deserialize <T>(raw); } } } catch (Exception ex) { response.ResponseStatus = ResponseStatus.Error; response.ErrorMessage = ex.Message; response.ErrorException = ex; } return(response); }
/// <summary> /// Deserializes and adds message from stream. /// </summary> /// <param name="stream">Stream from which to Deserialize</param> /// <param name="deserializer">Deserializer which is to be used</param> /// <returns>Reference to added message, null if unsuccessful.</returns> public Message AddMessage(Stream stream, IDeserializer deserializer) { var mess = deserializer.Deserialize(stream) as Message; if (mess == null) { return(null); } if (!messages.ContainsKey(mess.ID) && (messages.ContainsKey(mess.TargetId) || mess.TargetId == Guid.Empty)) { //as in previous method, these conditions had to be checked messages.Add(mess.ID, mess); mess.Conversation = this; OnPropertyChanged(this, new(nameof(ObservableMessages))); } else { mess = null; } return(mess); }
protected override AggregatableMessage <ICommand> Process(KafkaMessageBatch batch) { var filtered = batch.Results .Where(x => _appropriateTopics.Contains(x.Topic)); using (var transaction = new TransactionScope(TransactionScopeOption.Required, _transactionOptions)) { var dtos = _deserializer.Deserialize(filtered).ToList(); if (dtos.Count != 0) { Process(dtos); } transaction.Complete(); } return(new AggregatableMessage <ICommand> { TargetFlow = MessageFlow, Commands = Array.Empty <ICommand>(), }); }
private OfferingSaleCancellationResponse ProcessUnsuccessfulRequest(HttpResponseMessage response) { var body = response.Content.ReadAsStringAsync().Result; ErrorResponse errorResponse = null; string message; if (string.IsNullOrWhiteSpace(body)) { message = $"HTTP Status: '{(int)response.StatusCode} - {response.StatusCode}' Reason: '{response.ReasonPhrase}'"; errorResponse = new ErrorResponse { Message = message, HttpStatusCode = response.StatusCode }; } else { errorResponse = _deserializer.Deserialize <ErrorResponse>(body); errorResponse.HttpStatusCode = response.StatusCode; message = errorResponse.ValidationMessages.Count > 0 ? $"Invalid Request : {string.Join(" - ", errorResponse.ValidationMessages)}" : $"Unable to cancel offering sale : {errorResponse.Message}"; } if (_configuration.ThrowExceptions) { // use WebException to maintain backwards compatibility with old versions which used HttpWebRequest throw new WebException(message, null, WebExceptionStatus.ProtocolError, new SimpleWebResponse(response.StatusCode, response.Content)); } return(new OfferingSaleCancellationResponse { Success = false, ErrorResponse = errorResponse }); }
public void GetTradesExpected() { IDeserializer deserializer = null; var restMock = new Mock <IRestClient>(MockBehavior.Strict); restMock.SetupAllProperties(); restMock.Setup(x => x.AddHandler("application/json", It.IsAny <IDeserializer>())).Callback <string, IDeserializer>((ct, d) => deserializer = d); restMock.Setup(x => x.Execute <ResponseCollection <TradeInfo> >(It.IsAny <IRestRequest>())).Returns <IRestRequest>(request => { var responseMock = new Mock <IRestResponse <ResponseCollection <TradeInfo> > >(MockBehavior.Strict); responseMock.SetupAllProperties(); responseMock.Object.Content = Properties.Resources.TradesInfoResponse; responseMock.Object.Request = request; responseMock.Object.Data = deserializer.Deserialize <ResponseCollection <TradeInfo> >(responseMock.Object); return(responseMock.Object); }); var client = new BitsoClient(restMock.Object, ServiceUrlMock, ApiKeyMock, ApiSecretMock); var res = client.GetTrades("btc_mxn"); Assert.AreNotEqual <int>(0, res.Count); Assert.AreNotEqual <decimal>(0, res[0].Amount); Assert.IsFalse(string.IsNullOrEmpty(res[0].BookName)); Assert.IsTrue(res[0].MakerSide != MarketSide.None); Assert.AreNotEqual <decimal>(0M, res[0].Price); Assert.AreNotEqual <decimal>(0M, res[0].Amount); Assert.AreNotEqual <long>(0, res[0].TradeId); var diff = res[0].CreatedAt - default(System.DateTime); Assert.IsTrue(diff > System.TimeSpan.Zero); }
public static async Task <ResultT> DecodeAsync <ResultT, M>(this AbstractStreamSource source, IDeserializer <ResultT, M> deserializer, IProgress prog = null) where M : MediaType { if (source is null) { throw new System.ArgumentNullException(nameof(source)); } if (deserializer is null) { throw new System.ArgumentNullException(nameof(deserializer)); } prog.Report(0); using var stream = await source .GetStreamAsync(prog) .ConfigureAwait(false); var value = deserializer.Deserialize(stream); prog.Report(1); return(value); }
public async Task <FrontMatter?> ReadFrontMatterAsync(string postPath) { var frontMatterYaml = await File.ReadAllTextAsync(postPath); if (frontMatterYaml == null) { return(null); } var temp = frontMatterYaml.Split("---"); if (temp.Length < 2) { return(null); } var frontMatter = _yamlDeserializer .Deserialize <FrontMatter>(temp[1]); // Cleanup front matter frontMatter.Title = frontMatter.Title.Replace("&", "&"); return(frontMatter); }
public static RemotePackageConfig DownloadPackageConfig(Config config) { string packageConfigName = config.Debug.AlternatePackageConfigFile ?? "packageconfig.yaml"; string rawData; try { rawData = RemoteObjectManager.Instance.DownloadObjectAsString(packageConfigName); } catch (Exception ex) { throw new PackageException($"Failed to download package config: {ex.Message}", ex); } try { return(deserializer.Deserialize <RemotePackageConfig>(rawData)); } catch (Exception ex) { throw new PackageException($"Failed to parse package config: {ex.Message}", ex); } }
public void Process() { try { Stream = client.GetStream(); string state = GetState(); SendState(state); while (true) { try { string activityString = GetMessage(); Activity activity = deserializer.Deserialize <Activity>(activityString); clientModel.Move(activity); server.SendAll(GetState()); } catch (Exception e) { Console.Error.WriteLine(e.Message); break; } } } catch (Exception e) { Console.Error.WriteLine(e.Message); } finally { server.RemoveConnection(Id); Close(); } }
internal static T CustomField <T>(IDeserializer context, IDeserializer <T> custom, string name, ICfgNode node, bool required) { try { var field = node.NestedByName(name).FirstOrDefault(); if (field == null) { if (required) { throw new FormatException("field not found"); } else { return(default(T)); } } return(custom.Deserialize(context, field)); } catch (Exception ex) { throw new DeserializeChildException(name, ex); } }
public IEnumerable <T> LoadFromStream(TextReader stream, string configSection) { var parser = new Parser(stream); parser.Consume <StreamStart>(); parser.Consume <DocumentStart>(); parser.Consume <MappingStart>(); var validConfigs = new List <T>(); while (parser.TryConsume <Scalar>(out var key)) { if (key.Value != configSection) { parser.SkipThisAndNestedEvents(); continue; } var configs = _deserializer.Deserialize <List <T>?>(parser); if (configs == null) { parser.SkipThisAndNestedEvents(); continue; } ValidateConfigs(configSection, configs, validConfigs); parser.SkipThisAndNestedEvents(); } if (validConfigs.Count == 0) { throw new ConfigurationException(configSection, typeof(T), "There are no configured instances defined"); } return(validConfigs); }
public async Task Load(ILogger logger, CancellationToken token) { var init = this.Root.File(InitFilename); if (!init.Exists) { logger.LogWarning($"Settings file {InitFilename} not found. Will use default settings"); return; } try { logger.LogInformation("Loading settings from {0}", init.FullName); using (var stream = init.OpenRead()) using (var reader = new StreamReader(stream)) { _values = GetValues(await Task.Run(() => YamlDeserializer.Deserialize <Dictionary <string, object> >(reader))); } } catch (Exception ex) { throw new Exception($"Failed to load settings from {init.FullName}: {ex.Message}", ex); } }
static public async Task Handle(HttpResponseMessage response) { if (!response.IsSuccessStatusCode) { ErrorResult errorResult = null; try { IDeserializer <HttpResponseMessage, Task <ErrorResult> > d = DeserializerFactory.GetFactory().CreateErrorResultDeserializer(); errorResult = await d.Deserialize(response); } catch (XmlException ex) { throw ex; //response.EnsureSuccessful(); } catch (InvalidOperationException invalidEx) { throw invalidEx; //response.EnsureSuccessful(); } throw ExceptionFactory.CreateException(errorResult.Code, errorResult.Message, errorResult.RequestId, errorResult.HostId); } }
public void GetAccountFeesExpected() { IDeserializer deserializer = null; var restMock = new Mock <IRestClient>(MockBehavior.Strict); restMock.SetupAllProperties(); restMock.Setup(x => x.AddHandler("application/json", It.IsAny <IDeserializer>())).Callback <string, IDeserializer>((ct, d) => deserializer = d); restMock.Setup(x => x.Execute <ResponseSingle <AccountFees> >(It.IsAny <IRestRequest>())).Returns <IRestRequest>(request => { var responseMock = new Mock <IRestResponse <ResponseSingle <AccountFees> > >(MockBehavior.Strict); responseMock.SetupAllProperties(); responseMock.Object.Content = Properties.Resources.AccountFeesResponse; responseMock.Object.Request = request; responseMock.Object.Data = deserializer.Deserialize <ResponseSingle <AccountFees> >(responseMock.Object); return(responseMock.Object); }); var client = new BitsoClient(restMock.Object, ServiceUrlMock, ApiKeyMock, ApiSecretMock); var res = client.GetAccountFees(); Assert.IsNotNull(res); Assert.AreNotEqual <int>(0, res.TradeFees.Count); Assert.IsFalse(string.IsNullOrEmpty(res.TradeFees[0].BookName)); Assert.AreNotEqual <decimal>(0M, res.TradeFees[0].TakerPercent); Assert.AreNotEqual <decimal>(0M, res.TradeFees[0].TakerValue); Assert.AreNotEqual <decimal>(0M, res.TradeFees[0].MakerPercent); Assert.AreNotEqual <decimal>(0M, res.TradeFees[0].MakerValue); Assert.AreNotEqual <int>(0, res.WithdrawalFees.Count); Assert.AreNotEqual <decimal>(0M, res.WithdrawalFees.First().Value); }
public async Task GetSportEventSummaryAsync(URN id, CultureInfo culture, ISportEventCI requester) { RecordCall("GetSportEventSummaryAsync"); var strId = id?.ToString().Replace(":", "_") ?? string.Empty; var filePath = GetFile($"summary_{strId}.{culture.TwoLetterISOLanguageName}.xml", culture); if (string.IsNullOrEmpty(filePath) && id?.TypeGroup != ResourceTypeGroup.BASIC_TOURNAMENT && id?.TypeGroup != ResourceTypeGroup.TOURNAMENT && id?.TypeGroup != ResourceTypeGroup.SEASON) { filePath = GetFile(MatchDetailsXml, culture); } if (string.IsNullOrEmpty(filePath)) { return; } var mapper = new SportEventSummaryMapperFactory(); var stream = FileHelper.OpenFile(filePath); var result = mapper.CreateMapper(_restDeserializer.Deserialize(stream)).Map(); if (result != null) { await _cacheManager.SaveDtoAsync(id, result, culture, DtoType.SportEventSummary, requester).ConfigureAwait(false); } }
public void Deserialize(IDeserializer deserializer) { deserializer.Deserialize("PlantShadows", shadowFB); deserializer.Deserialize("Buttons", buttonFB); }
private static void PatchList(Context context, List <AssetFile> sources, Stream stream) { foreach (var source in sources) { string sourceText = File.ReadAllText(context.GetSourceModAssetPath(source.Name)); switch (source.Type) { case "trsr": var trsrList = Kh2.SystemData.Trsr.Read(stream).ToDictionary(x => x.Id, x => x); var moddedTrsr = deserializer.Deserialize <Dictionary <ushort, Kh2.SystemData.Trsr> >(sourceText); foreach (var treasure in moddedTrsr) { if (trsrList.ContainsKey(treasure.Key)) { if (treasure.Value.World == 0) { trsrList[treasure.Key].ItemId = treasure.Value.ItemId; } else { trsrList[treasure.Key] = treasure.Value; } } else { trsrList.Add(treasure.Key, treasure.Value); } } Kh2.SystemData.Trsr.Write(stream.SetPosition(0), trsrList.Values); break; case "item": var itemList = Kh2.SystemData.Item.Read(stream); var moddedItem = deserializer.Deserialize <Kh2.SystemData.Item>(sourceText); if (moddedItem.Items != null) { foreach (var item in moddedItem.Items) { var itemToUpdate = itemList.Items.FirstOrDefault(x => x.Id == item.Id); if (itemToUpdate != null) { itemList.Items[itemList.Items.IndexOf(itemToUpdate)] = item; } else { itemList.Items.Add(item); } } } if (moddedItem.Stats != null) { foreach (var item in moddedItem.Stats) { var itemToUpdate = itemList.Stats.FirstOrDefault(x => x.Id == item.Id); if (itemToUpdate != null) { itemList.Stats[itemList.Stats.IndexOf(itemToUpdate)] = item; } else { itemList.Stats.Add(item); } } } itemList.Write(stream.SetPosition(0)); break; case "fmlv": var formRaw = Kh2.Battle.Fmlv.Read(stream).ToList(); var formList = new Dictionary <Kh2.Battle.Fmlv.FormFm, List <Kh2.Battle.Fmlv> >(); foreach (var form in formRaw) { if (!formList.ContainsKey(form.FinalMixForm)) { formList.Add(form.FinalMixForm, new List <Kh2.Battle.Fmlv>()); } formList[form.FinalMixForm].Add(form); } var moddedForms = deserializer.Deserialize <Dictionary <Kh2.Battle.Fmlv.FormFm, List <FmlvDTO> > >(sourceText); foreach (var form in moddedForms) { foreach (var level in form.Value) { formList[form.Key][level.FormLevel - 1].Ability = (ushort)level.Ability; formList[form.Key][level.FormLevel - 1].Exp = level.Experience; formList[form.Key][level.FormLevel - 1].Unk1 = level.GrowthAbilityLevel; } } Kh2.Battle.Fmlv.Write(stream.SetPosition(0), formList.Values.SelectMany(x => x).ToList()); break; case "lvup": var levelList = Kh2.Battle.Lvup.Read(stream); var moddedLevels = deserializer.Deserialize <Dictionary <string, Dictionary <int, Kh2.Battle.Lvup.PlayableCharacter.Level> > > (sourceText); foreach (var character in moddedLevels) { foreach (var level in moddedLevels[character.Key]) { levelList.Characters[characterMap[character.Key] - 1].Levels[level.Key - 1] = moddedLevels[character.Key][level.Key]; } } levelList.Write(stream.SetPosition(0)); break; case "bons": var bonusRaw = Kh2.Battle.Bons.Read(stream); var bonusList = new Dictionary <byte, Dictionary <string, Kh2.Battle.Bons> >(); foreach (var bonus in bonusRaw) { if (!bonusList.ContainsKey(bonus.RewardId)) { bonusList.Add(bonus.RewardId, new Dictionary <string, Kh2.Battle.Bons>()); } var character = characterMap.First(x => x.Value == bonus.CharacterId).Key; if (!bonusList[bonus.RewardId].ContainsKey(character)) { bonusList[bonus.RewardId].Add(character, bonus); } } var moddedBonus = deserializer.Deserialize <Dictionary <byte, Dictionary <string, Kh2.Battle.Bons> > >(sourceText); foreach (var bonus in moddedBonus) { if (!bonusList.ContainsKey(bonus.Key)) { bonusList.Add(bonus.Key, new Dictionary <string, Kh2.Battle.Bons>()); } foreach (var character in moddedBonus[bonus.Key]) { if (!bonusList[bonus.Key].ContainsKey(character.Key)) { bonusList[bonus.Key].Add(character.Key, new Kh2.Battle.Bons()); } bonusList[bonus.Key][character.Key] = character.Value; } } Kh2.Battle.Bons.Write(stream.SetPosition(0), bonusList.Values.SelectMany(x => x.Values)); break; case "objentry": var objEntryList = Kh2.Objentry.Read(stream).ToDictionary(x => x.ObjectId, x => x); var moddedObjEntry = deserializer.Deserialize <Dictionary <uint, Kh2.Objentry> >(sourceText); foreach (var objEntry in moddedObjEntry) { if (objEntryList.ContainsKey(objEntry.Key)) { objEntryList[objEntry.Key] = objEntry.Value; } else { objEntryList.Add(objEntry.Key, objEntry.Value); } } Kh2.Objentry.Write(stream.SetPosition(0), objEntryList.Values); break; case "plrp": var plrpList = Kh2.Battle.Plrp.Read(stream); var moddedPlrp = deserializer.Deserialize <List <Kh2.Battle.Plrp> >(sourceText); foreach (var plrp in moddedPlrp) { var oldPlrp = plrpList.First(x => x.Character == plrp.Character && x.Id == plrp.Id); plrpList[plrpList.IndexOf(oldPlrp)] = plrp; } Kh2.Battle.Plrp.Write(stream.SetPosition(0), plrpList); break; default: break; } } }
public ConfigurationDefinition ReadDefinition(Stream input) { var yaml = deserializer.Deserialize <YamlTemplate>(new StreamReader(input)); var guid = Guid.Parse(yaml.Metadata.Guid); var descriptionGuid = Guid.Parse(yaml.Template.Guid); var description = componentDescriptionLookup.GetDescription(new TypeDescriptionComponentType(descriptionGuid, ComponentType.Unknown(yaml.Template.Name))); if (description == null) { throw new InvalidOperationException("Base description for template not found."); } var metadata = new DefinitionMetadata { Guid = guid, Description = yaml.Metadata.Description, Name = yaml.Metadata.Name, Version = yaml.Metadata.Version, }; var properties = new Dictionary <PropertyName, PropertyValue>(); foreach (var setter in yaml.Properties) { var componentProperty = description.Properties.FirstOrDefault(x => x.Name == setter.Name); if (componentProperty == null) { throw new InvalidOperationException($"Property '{setter.Name}' does not exist on component type '{description.ComponentName}'"); } PropertyValue value; switch (componentProperty.Type) { case PropertyType.Boolean: { value = new PropertyValue((bool)setter.Value); break; } case PropertyType.Decimal: { value = new PropertyValue((double)setter.Value); break; } case PropertyType.Integer: { value = new PropertyValue((int)setter.Value); break; } case PropertyType.Enum: case PropertyType.String: { value = new PropertyValue((string)setter.Value); break; } default: { throw new NotSupportedException("Unknown property type."); } } properties.Add(componentProperty.SerializedName, value); } var configuration = new ComponentConfiguration(null, yaml.Metadata.Name, properties); return(new ConfigurationDefinition(metadata, description, configuration)); }
/// <summary> /// Parse the string into dotnet object. /// </summary> /// <param name="input">String representation of YAML file.</param> /// <returns>The application configuration object.</returns> public static ImageScannerConfiguration Parse(string input) { return(Deserializer.Deserialize <ImageScannerConfiguration>(input)); }
private async Task Fetch(ChannelWriter <Message <TKey, TValue> > messageWriter, string topic, PartitionMetadata partition, BrokerConnection broker, CancellationToken cancellationToken) { long offset = 0; while (!cancellationToken.IsCancellationRequested) { var fetch = await broker.Fetch(new FetchRequest { ReplicaId = -1, MaxWaitTime = 100, MinBytes = 1, MaxBytes = 64 * 1024, IsolationLevel = 0, SessionId = 0, SessionEpoc = -1, Topics = new [] { new FetchRequest.Topic { TopicName = topic, Partitions = new [] { new FetchRequest.Topic.Partition { PartitionId = partition.PartitionId, CurrentLeaderEpoc = -1, FetchOffset = offset, LogStartOffset = -1, PartitionMaxBytes = 32 * 1024 } } } } }); long maxoffset = 0; long high = 0; foreach (var r in fetch.Responses) { foreach (var pr in r.PartitionResponses) { high = pr.HighWaterMark; foreach (var batch in pr.RecordBatches) { foreach (var rec in batch.Records) { if (rec.Offset > maxoffset) { maxoffset = rec.Offset; } var msg = new Message <TKey, TValue> { Timestamp = Timestamp.UnixTimestampMsToDateTime(batch.FirstTimeStamp + rec.TimeStampDelta), Topic = r.TopicName, PartitionId = pr.PartitionId, Offset = rec.Offset, Key = await keyDeserializer.Deserialize(rec.Key), Value = await valueDeserializer.Deserialize(rec.Value) }; if (rec.Headers.Count > 0) { foreach (var h in rec.Headers) { msg.AddHeader(h.Key, h.Value); } } await messageWriter.WriteAsync(msg, cancellationToken); } } } } if (maxoffset > 0) { offset = maxoffset + 1; } if (offset >= high) { await Task.Delay(200); // linger } } }
protected override void Decode(IChannelHandlerContext context, IByteBuffer message, List <object> output) { if (context == null || message == null) { throw new ArgumentNullException(nameof(context)); } var continueToDecode = true; var temp = new List <IPacket>(); var encryptedString = ""; var mapper = SessionFactory.Instance.Sessions[context.Channel.Id.AsLongText()]; _region = mapper.RegionType; _sessionId = mapper.SessionId; var str = ((Span <byte>)message.Array).Slice(message.ArrayOffset, message.ReadableBytes).ToArray(); if (_sessionId == 0) { if (!(_deserializer.Deserialize(DecryptCustomParameter(str, out var endofPacket)) is UnresolvedPacket pack)) { throw new ArgumentNullException(nameof(context)); } if (!int.TryParse(pack.Header, out _sessionId)) { _logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.ERROR_SESSIONID)); return; } SessionFactory.Instance.Sessions[context.Channel.Id.AsLongText()].SessionId = _sessionId; _logger.Information(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CLIENT_CONNECTED), mapper.SessionId); temp.Add(pack); if (endofPacket.Length == 0) { continueToDecode = false; } str = endofPacket; } if (continueToDecode) { var sessionKey = _sessionId & 0xFF; var sessionNumber = unchecked ((byte)(_sessionId >> 6)); sessionNumber &= 0xFF; sessionNumber &= unchecked ((byte)0x80000003); switch (sessionNumber) { case 0: encryptedString = (from character in str let firstbyte = unchecked ((byte)(sessionKey + 0x40)) select unchecked ((byte)(character - firstbyte))).Aggregate(encryptedString, (current, highbyte) => current + (char)highbyte); break; case 1: encryptedString = (from character in str let firstbyte = unchecked ((byte)(sessionKey + 0x40)) select unchecked ((byte)(character + firstbyte))).Aggregate(encryptedString, (current, highbyte) => current + (char)highbyte); break; case 2: encryptedString = (from character in str let firstbyte = unchecked ((byte)(sessionKey + 0x40)) select unchecked ((byte)((character - firstbyte) ^ 0xC3))).Aggregate(encryptedString, (current, highbyte) => current + (char)highbyte); break; case 3: encryptedString = (from character in str let firstbyte = unchecked ((byte)(sessionKey + 0x40)) select unchecked ((byte)((character + firstbyte) ^ 0xC3))).Aggregate(encryptedString, (current, highbyte) => current + (char)highbyte); break; default: encryptedString += (char)0xF; break; } temp.AddRange(encryptedString.Split((char)0xFF, StringSplitOptions.RemoveEmptyEntries).Select(p => { try { var packet = _deserializer.Deserialize(DecryptPrivate(p)); if (!packet.IsValid) { _logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CORRUPT_PACKET), packet); } return(packet); } #pragma warning disable CA1031 // Do not catch general exception types catch (Exception ex) #pragma warning restore CA1031 // Do not catch general exception types { _logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.ERROR_DECODING), ex.Data["Packet"]); ushort?keepalive = null; if (ushort.TryParse(ex.Data["Packet"]?.ToString()?.Split(" ")[0], out var kpalive)) { keepalive = kpalive; } return(new UnresolvedPacket { KeepAliveId = keepalive, Header = "0" }); } })); } if (temp.Count > 0) { output?.Add(temp); } }
public object Deserialize(string input, IDeserializer deserializer) { var obj = deserializer.Deserialize(input); return obj; }
public Task <object> Execute(object data, object state = null) { return(Task.FromResult(_deserializer.Deserialize((DataObject)data, _type, _args))); }
/// <summary>Deserializes the given file into the specified object using the specified factory.</summary> /// <typeparam name="T">The object to return to.</typeparam> /// <param name="FactoryName">The name of the factory, <see cref="Serialization.GetFactoryNames"/>.</param> /// <param name="stream">The stream to read from.</param> /// <returns>Deserializes the given file into the specified object using the specified factory.</returns> public static T Deserialize <T>(String FactoryName, Stream stream) { IDeserializer <T, Stream> deserializer = GetDeserializer <T>(FactoryName); return(deserializer.Deserialize(stream)); }
public T Deserialize <T>(string data) => _deserializer.Deserialize <T>(data);
public static void ParseInput(string input, IDeserializer deserializer) { var result = TomlGrammar.Document.TryParse(input); if (!result.WasSuccessful) throw new GrammarException(result.Message); var tables = result.Value; var tableValueMap = tables.ToDictionary(x => x, x => new TableValue(x.Title, x.KeyValuePairs)); // The dictionary holds all non-array tables, and most recently processed array table element var tableLookup = new Dictionary<string[], TableAndValue>(new TableKeyComparer()); foreach (var item in tableValueMap.Where(x => !x.Key.IsArrayTable)) { if (tableLookup.ContainsKey(item.Key.Title)) throw new DuplicateTableKeyException(item.Key.ParentTitle, item.Key.ActualTitle); tableLookup.Add(item.Key.Title, new TableAndValue(item.Key, item.Value)); } // A list of all array tables var arrayTableTitles = new HashSet<string[]>(tables.Where(x => x.IsArrayTable).Select(x => x.Title), new TableKeyComparer()); // This could probably be refactored out into its own method... But I want to keep the parser stateless for now, // and I could create an inner class... but the compiler will do that for me this way Action<Table> ensureTableDeclaredAndWiredInLookup = null; ensureTableDeclaredAndWiredInLookup = table => { TableAndValue parent; // The case for tables that imply the existence of their parent, eifi [foo.bar] where [foo] isn't defined if (!tableLookup.TryGetValue(table.ParentTitle, out parent)) { if (arrayTableTitles.Contains(table.ParentTitle)) throw new ParseException("Whoops"); // TODO better message var parentTable = new Table(table.ParentTitle, Enumerable.Empty<KeyValuePair>(), false); parent = new TableAndValue(parentTable, new TableValue(parentTable.Title)); tableValueMap.Add(parentTable, parent.TableValue); ensureTableDeclaredAndWiredInLookup(parentTable); } var tableValue = tableValueMap[table]; if (table.IsArrayTable) parent.TableValue.AddChildArrayTable(table.ActualTitle, tableValue); else parent.TableValue.AddKeyValuePair(table.ActualTitle, tableValue); }; Table mostRecentlyDefinedTableElement = null; // Assign child tables to their parents foreach (var table in tables) { if (table.IsArrayTable) tableLookup[table.Title] = new TableAndValue(table, tableValueMap[table]); if (table.ParentTitle != null) ensureTableDeclaredAndWiredInLookup(table); mostRecentlyDefinedTableElement = table; } // Tables doesn't contain the newly-created intermediate tables foreach (var table in tableValueMap.Values) { table.FlattenChildArrayTables(); } deserializer.Deserialize(tableLookup[new string[0]].TableValue); }
public Collection(string text, string base_dir) : this(_Deserializer.Deserialize <YAML.Collection>(text), base_dir) { }
public static Database Load(string text, IDeserializer serializer) { return new Database(serializer.Deserialize(text)); }