Ejemplo n.º 1
0
        internal PortSet <string, Exception> DeserializeEnvelopeBody(loganalyzer.Envelope envelope)
        {
            var xmlResultPort = new PortSet <XmlWriter, Exception>();

            var o = loganalyzer.DssLogAnalyzerHelper.DeserializeEnvelope(envelope).Body;

            var stringbuilderOutput = new StringBuilder();
            var xmlWriter           = XmlWriter.Create(stringbuilderOutput, new XmlWriterSettings {
                Indent = true
            });

            var ser = new SerializeToXmlWriter(o, xmlWriter, xmlResultPort);

            SerializerPort.Post(ser);

            var resultPort = new PortSet <string, Exception>();

            Activate(
                Arbiter.Choice(
                    xmlResultPort,
                    success => resultPort.Post(stringbuilderOutput.ToString()),
                    failure => resultPort.Post(failure)));

            return(resultPort);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Convert xml files to binary
        /// </summary>
        /// <param name="logFile">File to be converted</param>
        /// <param name="newLogFile">New file name</param>
        /// <param name="resultPort">DSS result port</param>
        /// <returns>ITask enumerator</returns>
        private IEnumerator <ITask> ConvertXmlLogToBinary(string logFile, string newLogFile, Port <LogFileResult> resultPort)
        {
            var envelopes = new List <Envelope>(DefaultInitialEnvelopeCapacity);

            using (var fs = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.None, 1))
            {
                if (fs.Length != 0)
                {
                    using (var newFs = new FileStream(newLogFile, FileMode.Create, FileAccess.Write, FileShare.None, 1))
                    {
                        using (var bw = new BinaryWriter(newFs))
                        {
                            var reader = XmlReader.Create(fs);
                            while (ReadToNextEnvelopeNode(reader))
                            {
                                var deserHeader = new Deserialize(reader);
                                SerializerPort.Post(deserHeader);

                                DeserializeResult headerDeserResult = null;
                                yield return(Arbiter.Choice(
                                                 deserHeader.ResultPort,
                                                 w3cHeader => headerDeserResult = w3cHeader,
                                                 failure => LogError(failure)));

                                if (headerDeserResult != null && ReadToNextBodyNode(reader))
                                {
                                    var deserBody = new Deserialize(reader);
                                    SerializerPort.Post(deserBody);

                                    DeserializeResult bodyDeserResult = null;

                                    yield return(Arbiter.Choice(
                                                     deserBody.ResultPort,
                                                     bodyContents => bodyDeserResult = bodyContents,
                                                     failure => LogError(failure)));

                                    if (bodyDeserResult != null)
                                    {
                                        this.SerializeToBinary(headerDeserResult, bodyDeserResult, bw);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }