private ServiceContext CreateEntryJob(ServiceContext feedJob, PayloadFormat feedFormat,ref List<KeyValuePair<string, Exception>> failedTargets)
        {
            ServiceContext context = null;
            string entry = string.Empty;

            if (!string.IsNullOrEmpty(feedJob.ResponsePayload))
            {
                var entries = ContextHelper.GetEntries(feedJob.ResponsePayload, feedFormat).ToArray();

                if (entries.Any())
                {
                    entry = entries.First();
                }
                else
                {
                    string acceptHeader = Constants.V3AcceptHeaderJsonFullMetadata;

                    if (feedJob.Version == ODataVersion.V4)
                    {
                        acceptHeader = Constants.V4AcceptHeaderJsonFullMetadata;
                    }

                    var response = WebHelper.Get(feedJob.Destination, acceptHeader, RuleEngineSetting.Instance().DefaultMaximumPayloadSize, feedJob.RequestHeaders);

                    if (response != null && !string.IsNullOrEmpty(response.ResponsePayload))
                    {
                        entries = ContextHelper.GetEntries(response.ResponsePayload, feedFormat).ToArray();

                        if (entries.Any())
                        {
                            entry = entries.First();
                        }
                    }
                }

                Uri target = new Uri(entry);
                context = this.SetupCrawlSubJob(target, ref failedTargets);
            }

            return context;
        }
        /// <summary>
        /// Verifies the extension rule.
        /// </summary>
        /// <param name="context">The Interop service context</param>
        /// <param name="info">out parameter to return violation information when rule does not pass</param>
        /// <returns>true if rule passes; false otherwise</returns>
        public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            bool?                     passed   = null;
            var                       response = WebHelper.Get(context.Destination, string.Empty, RuleEngineSetting.Instance().DefaultMaximumPayloadSize, context.RequestHeaders);
            PayloadFormat             format   = ContextHelper.GetFormatFromPayload(response.ResponsePayload);
            ExtensionRuleResultDetail detail   = new ExtensionRuleResultDetail(this.Name, context.Destination.AbsoluteUri, "GET", StringHelper.MergeHeaders(string.Empty, context.RequestHeaders), response);

            if (response != null && response.StatusCode != null)
            {
                if (format == RuleEngine.PayloadFormat.JsonLight)
                {
                    passed = true;
                }
                else
                {
                    passed = false;
                    detail.ErrorMessage = "Get above URI with accept header 'application/json', the response is not JSON format.";
                }
            }
            else
            {
                passed = false;
                detail.ErrorMessage = String.Format("No response returned from above URI with accept header 'application/json'.");
            }

            info = new ExtensionRuleViolationInfo(context.Destination, context.ResponsePayload, detail);
            return(passed);
        }
        /// <summary>
        /// Extension method to properly format xml or json content
        /// </summary>
        /// <param name="payload">the content to be formatted</param>
        /// <param name="formatHint">format hint indicating whether content is xml/atom, json, or other</param>
        /// <returns>well-formatted string breaking into logical lines</returns>
        public static string FineFormat(this string payload, PayloadFormat formatHint)
        {
            switch (formatHint)
            {
            case PayloadFormat.Xml:
                return(payload.FineFormatAsXml());

            case PayloadFormat.Atom:
                return(payload.FineFormatAsXml());

            case PayloadFormat.Json:
            case PayloadFormat.JsonLight:
            {
                JObject jo;
                if (payload.TryToJObject(out jo))
                {
                    return(jo.FineFormat());
                }
                else
                {
                    return(null);
                }
            }

            default:
                return(payload);
            }
        }
        /// <summary>
        /// Gets payload type from payload content, format hint, and HTTP header if existent
        /// </summary>
        /// <param name="payload">The payload content</param>
        /// <param name="payloadFormat">The payload format hint</param>
        /// <param name="headers">The HTTP header</param>
        /// <returns>The payload type</returns>
        public static PayloadType GetPayloadType(string payload, PayloadFormat payloadFormat, string headers, string metadata = null)
        {
            var payloadType = payload.GetTypeFromPayload(payloadFormat, metadata);

            // for other arbitrary payload to further differentiate those that seem response from an OData producer
            if (payloadType == PayloadType.Other && !string.IsNullOrEmpty(headers))
            {
                if (Regex.IsMatch(headers, @"^\s*DataServiceVersion\s*:", RegexOptions.Multiline) ||
                    Regex.IsMatch(headers, @"^\s*OData-Version\s*:", RegexOptions.Multiline))
                {
                    payloadType = PayloadType.RawValue;
                }
            }

            //ContentType header shall be used to reveal raw value messages disguised with live producers
            if (!string.IsNullOrEmpty(headers))
            {
                if (payloadType == PayloadType.Property || payloadType == PayloadType.Link)
                {
                    if (Regex.IsMatch(headers, @"^\s*Content-Type\s*:\s*text/plain\s*;", RegexOptions.Multiline))
                    {
                        payloadType = PayloadType.RawValue;
                    }
                }
            }

            return(payloadType);
        }
        /// <summary>
        /// Extension method to determine the type of payload by looking at its content
        /// </summary>
        /// <param name="payload">payload content</param>
        /// <param name="formatHint">content format (atom/xml or json)</param>
        /// <returns>Feed, Entry, SvcDoc, Metadata etc payload type based on payload content</returns>
        public static PayloadType GetTypeFromPayload(this string payload, PayloadFormat formatHint, string metadata = null)
        {
            if (string.IsNullOrEmpty(payload))
            {
                return(PayloadType.None);
            }

            switch (formatHint)
            {
            case PayloadFormat.Atom:
                return(payload.IsAtomFeed() ? PayloadType.Feed:PayloadType.Entry);

            case PayloadFormat.Json:
                return(GetTypeFromJsonVerbosePayload(payload));

            case PayloadFormat.JsonLight:
                return(GetTypeFromJsonLightPayload(payload, metadata));

            case PayloadFormat.Xml:
                return(GetTypeFromXmlPayload(payload));

            default:
            {
                return(PayloadType.Other);
            }
            }
        }
Example #6
0
        public static List<EventSet> CreateEventSetsFromStream(Stream stream, PayloadFormat format)
        {
            IPayloadReader reader = null;
            if (format == PayloadFormat.Binary)
                reader = new BinaryPayloadReader(stream);
            else
                reader = new JsonPayloadReader(stream);

            return reader.ReadList<EventSet>(string.Empty);
        }
Example #7
0
 /// <summary>
 /// Gets collection of feeds defined in the service document
 /// </summary>
 /// <param name="serviceDocument">The OData service document</param>
 /// <param name="payloadFormat">The format type of service document</param>
 /// <returns>The collection of feed exposed</returns>
 public static IEnumerable <string> GetFeeds(string serviceDocument, PayloadFormat payloadFormat)
 {
     if (payloadFormat == PayloadFormat.Json || payloadFormat == PayloadFormat.JsonLight)
     {
         return(JsonHelper.GetFeeds(serviceDocument));
     }
     else
     {
         return(XmlHelper.GetFeeds(serviceDocument));
     }
 }
Example #8
0
 /// <summary>
 /// Gets collection of entries from the feed resource
 /// </summary>
 /// <param name="feed">The feed resource content</param>
 /// <param name="payloadFormat">The format of feed resource content</param>
 /// <returns>The entries included in the feed content</returns>
 public static IEnumerable <string> GetEntries(string feed, PayloadFormat payloadFormat)
 {
     if (payloadFormat == PayloadFormat.Json || payloadFormat == PayloadFormat.JsonLight)
     {
         return(JsonHelper.GetEntries(feed));
     }
     else
     {
         return(XmlHelper.GetEntries(feed));
     }
 }
Example #9
0
        /// <summary>
        /// Gets the self id string of feed or entry payload
        /// </summary>
        /// <param name="payload">The payload content</param>
        /// <param name="format">The payload format</param>
        /// <returns>The Uri string pointing to itself</returns>
        public static string GetIdFromFeedOrEntry(this string payload, PayloadFormat format)
        {
            string  id = null;
            JObject jo;

            if (format == PayloadFormat.Json)
            {
                if (payload.TryToJObject(out jo))
                {
                    string idEntry = jo.GetEntitySetFullPath();
                    if (JsonHelper.IsJsonVerboseFeed(payload))
                    {
                        int    posLeftParenthesis = idEntry.LastIndexOf('(');
                        string idFeed             = posLeftParenthesis >= 0 ? idEntry.Substring(0, posLeftParenthesis) : idEntry;
                        id = idFeed;
                    }
                    else if (JsonHelper.IsJsonVerboseEntry(payload))
                    {
                        id = idEntry;
                    }
                }
            }
            else if (format == PayloadFormat.JsonLight)
            {
                if (payload.TryToJObject(out jo))
                {
                    if (JsonHelper.IsJsonLightFeed(payload))
                    {
                        var valueArray = (JArray)jo[Constants.Value];

                        if (valueArray != null && valueArray.Count > 0 && ((JArray)valueArray).First[Constants.OdataId] != null)
                        {
                            string idEntry            = ((JArray)valueArray).First[Constants.OdataId].Value <string>();
                            int    posLeftParenthesis = idEntry.LastIndexOf('(');
                            string idFeed             = posLeftParenthesis >= 0 ? idEntry.Substring(0, posLeftParenthesis) : idEntry;
                            id = idFeed;
                        }
                    }
                    else if (JsonHelper.IsJsonLightEntry(payload) && jo[Constants.OdataId] != null)
                    {
                        id = jo[Constants.OdataId].Value <string>();
                    }
                }
            }
            else
            {
                id = XmlHelper.GetIdFromFeedOrEntry(payload);
            }

            return(id);
        }
        /// <summary>
        /// Verify Metadata.Core.4015
        /// </summary>
        /// <param name="context">Service context</param>
        /// <param name="info">out parameter to return violation information when rule fail</param>
        /// <returns>true if rule passes; false otherwise</returns>
        public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            bool?passed = null;

            info = null;

            XmlDocument metadata = new XmlDocument();

            metadata.LoadXml(context.MetadataDocument);
            string      xpath             = @"/edmx:Edmx/edmx:Reference";
            XmlNodeList referenceElements = metadata.SelectNodes(xpath, ODataNamespaceManager.Instance);

            foreach (XmlNode reference in referenceElements)
            {
                if (reference.Attributes["Uri"] != null)
                {
                    try
                    {
                        WebRequest req  = WebRequest.Create(reference.Attributes["Uri"].Value);
                        Response   resp = WebResponseHelper.Get(req as HttpWebRequest, null, RuleEngineSetting.Instance().DefaultMaximumPayloadSize);

                        PayloadFormat          payloadFormat = resp.ResponsePayload.GetFormatFromPayload();
                        RuleEngine.PayloadType payloadType   = ContextHelper.GetPayloadType(resp.ResponsePayload, payloadFormat, resp.ResponseHeaders);
                        if (payloadType != RuleEngine.PayloadType.Metadata)
                        {
                            passed = false; break;
                        }
                        else
                        {
                            passed = true;
                        }
                    }
                    catch (Exception e)
                    {
                        if (!ExceptionHelper.IsCatchableExceptionType(e))
                        {
                            throw;
                        }
                        passed = false; break;
                    }
                }
            }

            info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
            return(passed);
        }
Example #11
0
        public static List <EventSet> CreateEventSetsFromStream(Stream stream, PayloadFormat format)
        {
            IPayloadReader reader = null;

            if (format == PayloadFormat.Binary)
            {
                reader = new BinaryPayloadReader(stream);
            }
            else
            {
                reader = new JsonPayloadReader(stream);
            }

            return(reader.ReadList <EventSet>(string.Empty));
        }
        /// <summary>
        /// Decides whether the payload and metadata are matched
        /// </summary>
        /// <param name="payload">The payload content</param>
        /// <param name="metadata">The metadata document content</param>
        /// <param name="payloadFormat">The payload format</param>
        /// <param name="payloadType">The payload type</param>
        /// <returns>True if they are matched; false otherwise</returns>
        private static bool IsMetadataMacthing(string payload, string metadata, PayloadFormat payloadFormat, PayloadType payloadType)
        {
            bool matched = false;

            // only payloads of feed or entry can check metadata matching
            if (payloadType == PayloadType.Feed || payloadType == PayloadType.Entry)
            {
                XElement xmlMetadata;
                if (metadata.TryToXElement(out xmlMetadata))
                {
                    // try to extract domain namespace defined as attribute of edmN:Schema node in CSDL metadata
                    var nodeSchema = xmlMetadata.XPathSelectElement("/*/*[local-name()='Schema' and @Namespace]", ODataNamespaceManager.Instance);
                    if (nodeSchema != null)
                    {
                        string domainNamespace = nodeSchema.Attribute("Namespace").Value;

                        // namespace must qualify the full entity type name
                        string entityTypeFullName = payload.GetFullEntityTypeFromPayload(payloadType, payloadFormat);

                        if (string.IsNullOrEmpty(entityTypeFullName))
                        {
                            string entitySetName = payload.GetEntitySetFromPayload(payloadType, payloadFormat);
                            entityTypeFullName = xmlMetadata.GetFullEntityTypeFromMetadata(entitySetName);
                        }

                        if (!string.IsNullOrEmpty(entityTypeFullName))
                        {
                            matched = entityTypeFullName.StartsWith(domainNamespace + ".");
                        }
                    }
                }
            }
            else if (payloadType == PayloadType.Metadata)
            {
                matched = string.Equals(payload, metadata, StringComparison.Ordinal);
            }
            else
            {
                matched = true;
            }

            return(matched);
        }
        private ServiceContext CreateEntryJob(ServiceContext feedJob, PayloadFormat feedFormat, ref List <KeyValuePair <string, Exception> > failedTargets)
        {
            ServiceContext context = null;
            string         entry   = string.Empty;

            if (!string.IsNullOrEmpty(feedJob.ResponsePayload))
            {
                var entries = ContextHelper.GetEntries(feedJob.ResponsePayload, feedFormat).ToArray();

                if (entries.Any())
                {
                    entry = entries.First();
                }
                else
                {
                    string acceptHeader = Constants.V3AcceptHeaderJsonFullMetadata;

                    if (feedJob.Version == ODataVersion.V4)
                    {
                        acceptHeader = Constants.V4AcceptHeaderJsonFullMetadata;
                    }

                    var response = WebHelper.Get(feedJob.Destination, acceptHeader, RuleEngineSetting.Instance().DefaultMaximumPayloadSize, feedJob.RequestHeaders);

                    if (response != null && !string.IsNullOrEmpty(response.ResponsePayload))
                    {
                        entries = ContextHelper.GetEntries(response.ResponsePayload, feedFormat).ToArray();

                        if (entries.Any())
                        {
                            entry = entries.First();
                        }
                    }
                }

                Uri target = new Uri(entry);
                context = this.SetupCrawlSubJob(target, ref failedTargets);
            }

            return(context);
        }
Example #14
0
        public static void WriteToStream(this IEnumerable<EventSet> events, Stream stream, PayloadFormat format)
        {
            IPayloadWriter writer = null;

            if (format == PayloadFormat.Binary)
                writer = new BinaryPayloadWriter(stream);
            else
                writer = new JsonPayloadWriter(stream);

            using (writer)
            {
                writer.Write(string.Empty, events);
            }
        }
 /// <summary>
 /// Filters rules based on payload format.
 /// </summary>
 /// <param name="rules">The collection of input rules</param>
 /// <param name="payloadFormat">Payload format</param>
 /// <returns>The subset of input rules that meet the condition of payload format</returns>
 private static IEnumerable <Rule> SelectRules(this IEnumerable <Rule> rules, PayloadFormat payloadFormat)
 {
     return(from r in rules
            where !r.PayloadFormat.HasValue || r.PayloadFormat == payloadFormat
            select r);
 }
Example #16
0
 /// <summary>
 /// Gets projection of properties of the specified entity type from payload
 /// </summary>
 /// <param name="payload">The payload content</param>
 /// <param name="format">The payload format</param>
 /// <param name="metadata">The metadata document</param>
 /// <param name="shortEntityType">The short name of entity type</param>
 /// <returns>Collection of projected properties</returns>
 public static IEnumerable <string> GetProjectedPropertiesFromFeedOrEntry(this string payload, PayloadFormat format, string metadata, string shortEntityType)
 {
     if (format == PayloadFormat.Json)
     {
         return(JsonHelper.GetProjectedPropertiesFromJsonVerboseFeedOrEntry(payload, metadata, shortEntityType));
     }
     else if (format == PayloadFormat.JsonLight)
     {
         return(JsonHelper.GetProjectedPropertiesFromJsonLightFeedOrEntry(payload, metadata, shortEntityType));
     }
     else
     {
         return(XmlHelper.GetProjectedPropertiesFromFeedOrEntry(payload, metadata, shortEntityType));
     }
 }
Example #17
0
        /// <summary>
        /// Extension method to indicate whether a payload is about a Media Link Entry
        /// </summary>
        /// <param name="payload">text content of the payload</param>
        /// <param name="typeHint">payload type, like feed, entry, etc</param>
        /// <param name="formatHint">payload format, like atom, json, etc</param>
        /// <returns>true if payload is a Media Link Entry; otherwise false</returns>
        public static bool IsMediaLinkEntry(this string payload, PayloadType typeHint, PayloadFormat formatHint)
        {
            if (typeHint == PayloadType.Entry)
            {
                switch (formatHint)
                {
                case PayloadFormat.Atom:
                {
                    XElement xml;
                    if (payload.TryToXElement(out xml))
                    {
                        return(xml.IsMediaLinkEntry());
                    }
                }

                break;

                case PayloadFormat.Json:
                {
                    JObject jo;
                    if (payload.TryToJObject(out jo))
                    {
                        return(jo.IsMediaLinkEntry());
                    }
                }

                break;
                }
            }

            return(false);
        }
Example #18
0
        /// <summary>
        /// Gets the full entity type name from payload content with resolution of metadata if applicable
        /// </summary>
        /// <param name="payload">The payload content</param>
        /// <param name="payloadType">The payload type</param>
        /// <param name="payloadFormat">The payload format</param>
        /// <param name="metadataDocument">The metadata document</param>
        /// <returns>The fuly-qualified entity type name that be found; null if not found</returns>
        public static string GetFullEntityType(this string payload, PayloadType payloadType, PayloadFormat payloadFormat, string metadataDocument)
        {
            string entityType = null;

            if (!string.IsNullOrEmpty(payload))
            {
                entityType = payload.GetFullEntityTypeFromPayload(payloadType, payloadFormat);
                if (string.IsNullOrEmpty(entityType) && !string.IsNullOrEmpty(metadataDocument))
                {
                    string entitySet = payload.GetEntitySetFromPayload(payloadType, payloadFormat);
                    if (!string.IsNullOrEmpty(entitySet) && !string.IsNullOrEmpty(metadataDocument))
                    {
                        XElement metadata;
                        if (metadataDocument.TryToXElement(out metadata))
                        {
                            entityType = metadata.GetFullEntityTypeFromMetadata(entitySet);
                        }
                    }
                }
            }

            return(entityType);
        }
Example #19
0
        /// <summary>
        /// Extension method to extract th interesting entity type value from payload content
        /// </summary>
        /// <param name="payload">payload content</param>
        /// <param name="typeHint">type of payload content</param>
        /// <param name="formatHint">format of payload content</param>
        /// <returns>the interesting entityset value (with namespace) if payload is entry or feed</returns>
        public static string GetFullEntityTypeFromPayload(this string payload, PayloadType typeHint, PayloadFormat formatHint)
        {
            if (!string.IsNullOrEmpty(payload) && (typeHint == PayloadType.Entry || typeHint == PayloadType.Feed))
            {
                switch (formatHint)
                {
                case PayloadFormat.Atom:
                {
                    XElement xml;
                    if (payload.TryToXElement(out xml))
                    {
                        return(xml.GetEntityType());
                    }
                }

                break;

                case PayloadFormat.Json:
                {
                    JObject jo;
                    if (payload.TryToJObject(out jo))
                    {
                        return(jo.GetJsonVerboseEntityType());
                    }
                }

                break;

                case PayloadFormat.JsonLight:
                {
                    JObject jo;
                    if (payload.TryToJObject(out jo))
                    {
                        if (typeHint == PayloadType.Feed)
                        {
                            return(jo.GetJsonLightEntityTypeFromFeed());
                        }
                        else if (typeHint == PayloadType.Entry)
                        {
                            return(jo.GetJsonLightEntityTypeFromEntry());
                        }
                    }
                }
                break;
                }
            }

            return(null);
        }
Example #20
0
        /// <summary>
        /// Gets EntitySet value from payload
        /// </summary>
        /// <param name="payload">The payload content</param>
        /// <param name="typeHint">The type of payload</param>
        /// <param name="formatHint">The format of payload</param>
        /// <returns>EntitySet value extracted from the payload if one is found; null otherwise</returns>
        public static string GetEntitySetFromPayload(this string payload, PayloadType typeHint, PayloadFormat formatHint)
        {
            string entitySet = null;

            if (!string.IsNullOrEmpty(payload) && (typeHint == PayloadType.Entry || typeHint == PayloadType.Feed))
            {
                switch (formatHint)
                {
                case PayloadFormat.Atom:
                {
                    XElement xml;
                    if (payload.TryToXElement(out xml))
                    {
                        entitySet = ContextHelper.GetEntitySetName(xml.GetEntitySetFullPath());
                    }
                }

                break;

                case PayloadFormat.Json:
                {
                    JObject jo;
                    if (payload.TryToJObject(out jo))
                    {
                        entitySet = ContextHelper.GetEntitySetName(jo.GetEntitySetFullPath());
                    }
                }

                break;

                case PayloadFormat.JsonLight:
                {
                    entitySet = ContextHelper.GetEntitySetNameFromJsonLightPayload(payload);
                }
                break;
                }
            }

            return(entitySet);
        }
Example #21
0
        private bool HandleSwitchboardSession(IPSession session)
        {
            List <PacketSlice> slices = new List <PacketSlice>(1);

            logger.AddMessage(String.Format("\r\n\r\nparsing session with remote endpoint: {0}\r\n", session.RemoteEndpoint));

            while (true)
            {
                PacketStream stream = session.GetNextStreamDirection();

                if (stream.GetBytesAvailable() == 0)
                {
                    stream = session.GetNextStreamDirection();
                    if (stream.GetBytesAvailable() == 0)
                    {
                        break;
                    }
                }

                IPPacket        pkt       = stream.CurPacket;
                PacketDirection direction = pkt.Direction;

                try
                {
                    string line = stream.PeekLineUTF8();

                    // Split the line up into CMD and the rest (being arguments, if any)
                    string[] tokens = line.Split(new char[] { ' ' }, 2);

                    logger.AddMessage(String.Format("{0} parsing command '{1}' (line: {2})",
                                                    (direction == PacketDirection.PACKET_DIRECTION_INCOMING) ? "<<" : ">>",
                                                    tokens[0], line));

                    // Set cmd and create an array of arguments if present
                    string   cmd       = tokens[0];
                    string[] arguments = new string[0];
                    if (tokens.Length > 1)
                    {
                        arguments = tokens[1].Split(new char[] { ' ' });
                    }

                    // Create command node
                    TransactionNode node = new TransactionNode("MSNSBCommand");
                    node.Description = cmd;

                    // Command field
                    stream.ReadBytes(StaticUtils.GetUTF8ByteCount(tokens[0]), slices);
                    node.AddField("Command", tokens[0], "Switchboard command.", slices);

                    if (arguments.Length > 0)
                    {
                        // Skip space between command and arguments
                        stream.ReadByte();

                        stream.ReadBytes(StaticUtils.GetUTF8ByteCount(tokens[1]), slices);

                        // Arguments fields
                        node.AddField("Arguments", tokens[1], "Arguments to command.", slices);
                    }

                    // Skip CRLF
                    stream.ReadBytes(2);

                    // Is there a payload?
                    bool hasPayload = false;
                    if (arguments.Length > 0)
                    {
                        List <string> payloadCommands =
                            (direction == PacketDirection.PACKET_DIRECTION_OUTGOING) ? payloadCommandsFromClient : payloadCommandsFromServer;

                        hasPayload = payloadCommands.Contains(cmd);
                    }

                    if (hasPayload)
                    {
                        int payloadLength = -1;

                        try
                        {
                            payloadLength = (int)Convert.ToUInt32(arguments[arguments.Length - 1]);
                        }
                        catch (FormatException)
                        {
                        }

                        if (payloadLength > 0)
                        {
                            TransactionNode payloadNode = new TransactionNode(node, "Payload");

                            logger.AddMessage(String.Format("Parsing {0} bytes of payload", payloadLength));

                            PayloadFormat format = PayloadFormat.TEXT;

                            string cmdUpper = cmd.ToUpper();
                            if (payloadCommandFormats.ContainsKey(cmdUpper))
                            {
                                format = payloadCommandFormats[cmdUpper];
                            }

                            if (format == PayloadFormat.MESSAGE)
                            {
                                SBParseMSG(stream, payloadNode, payloadLength);
                            }
                            else
                            {
                                string body = stream.ReadStringUTF8(payloadLength, slices);

                                switch (format)
                                {
                                case PayloadFormat.SLP:
                                    payloadNode.AddTextField("MSNSLP", body, "MSNSLP data.", slices);
                                    break;

                                case PayloadFormat.XML:
                                    payloadNode.AddXMLField("XML", body, "XML data.", slices);
                                    break;

                                default:
                                    payloadNode.AddTextField("Text", body, "Text.", slices);
                                    break;
                                }
                            }
                        }
                    }

                    session.AddNode(node);
                }
                catch (EndOfStreamException e)
                {
                    logger.AddMessage(String.Format("MSNSwitchboard: EOS at {0} ({1})", stream.Position, e));
                    break;
                }
            }

            logger.AddMessage("done with session\r\n\r\n");

            return(true);
        }
 /// <summary>
 /// Filters rules based on payload format.
 /// </summary>
 /// <param name="rules">The collection of input rules</param>
 /// <param name="payloadFormat">Payload format</param>
 /// <returns>The subset of input rules that meet the condition of payload format</returns>
 private static IEnumerable<Rule> SelectRules(this IEnumerable<Rule> rules, PayloadFormat payloadFormat)
 {
     return from r in rules
            where !r.PayloadFormat.HasValue || r.PayloadFormat == payloadFormat
            select r;
 }
Example #23
0
        public static void WriteToStream(this IEnumerable <EventSet> events, Stream stream, PayloadFormat format)
        {
            IPayloadWriter writer = null;

            if (format == PayloadFormat.Binary)
            {
                writer = new BinaryPayloadWriter(stream);
            }
            else
            {
                writer = new JsonPayloadWriter(stream);
            }

            using (writer)
            {
                writer.Write(string.Empty, events);
            }
        }
        /// <summary>
        /// Decides whether the payload and metadata are matched
        /// </summary>
        /// <param name="payload">The payload content</param>
        /// <param name="metadata">The metadata document content</param>
        /// <param name="payloadFormat">The payload format</param>
        /// <param name="payloadType">The payload type</param>
        /// <returns>True if they are matched; false otherwise</returns>
        private static bool IsMetadataMacthing(string payload, string metadata, PayloadFormat payloadFormat, PayloadType payloadType)
        {
            bool matched = false;

            // only payloads of feed or entry can check metadata matching
            if (payloadType == PayloadType.Feed || payloadType == PayloadType.Entry)
            {
                XElement xmlMetadata;
                if (metadata.TryToXElement(out xmlMetadata))
                {
                    // try to extract domain namespace defined as attribute of edmN:Schema node in CSDL metadata
                    var nodeSchema = xmlMetadata.XPathSelectElement("/*/*[local-name()='Schema' and @Namespace]", ODataNamespaceManager.Instance);
                    if (nodeSchema != null)
                    {
                        string domainNamespace = nodeSchema.Attribute("Namespace").Value;

                        // namespace must qualify the full entity type name
                        string entityTypeFullName = payload.GetFullEntityTypeFromPayload(payloadType, payloadFormat);

                        if (string.IsNullOrEmpty(entityTypeFullName))
                        {
                            string entitySetName = payload.GetEntitySetFromPayload(payloadType, payloadFormat);
                            entityTypeFullName = xmlMetadata.GetFullEntityTypeFromMetadata(entitySetName);
                        }

                        if (!string.IsNullOrEmpty(entityTypeFullName))
                        {
                            matched = entityTypeFullName.StartsWith(domainNamespace + ".");
                        }
                    }
                }
            }
            else if (payloadType == PayloadType.Metadata)
            {
                matched = string.Equals(payload, metadata, StringComparison.Ordinal);
            }
            else
            {
                matched = true;
            }

            return matched;
        }
Example #25
0
 public ProcessArgumentBuilder BuildWindowsArguments(ProcessArgumentBuilder args)
 {
     //var args = new ProcessArgumentBuilder();
     args.Append("/Y");
     if (Pattern.IsDefined())
     {
         args.AppendSwitchQuoted("/Pattern", ":", Pattern);
     }
     if (DestinationKey.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/DestKey", ":", DestinationKey);
     }
     if (DestinationSAS.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/DestSAS", ":", DestinationSAS);
     }
     if (SourceKey.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/SourceKey", ":", SourceKey);
     }
     if (SourceSAS.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/SourceSAS", ":", SourceSAS);
     }
     if (Recursive)
     {
         args.Append("/S");
     }
     if (BlobType != null)
     {
         args.AppendSwitchQuoted("/BlobType", ":", BlobType.ToString());
     }
     if (UseChecksum)
     {
         args.Append("/CheckMD5");
     }
     if (LogFile != null)
     {
         args.AppendSwitchQuoted("/V", ":", LogFile.FullPath);
     }
     if (ParameterFiles.Any())
     {
         foreach (var file in ParameterFiles)
         {
             args.AppendSwitchQuoted("@", ":", file.FullPath);
         }
     }
     if (FileHandlingBehaviour != null)
     {
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.ArchiveOnly))
         {
             args.Append("/A");
         }
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.ExcludeNewerSource))
         {
             args.Append("/XN");
         }
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.ExcludeOlderSource))
         {
             args.Append("/XO");
         }
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.UpdateLastModified))
         {
             args.Append("/MT");
         }
     }
     if (Delimiter != null)
     {
         args.AppendSwitchQuoted("/Delimiter", ":", Delimiter.ToString());
     }
     if (ConcurrentOperations != 0)
     {
         args.AppendSwitchQuoted("/NC", ":", ConcurrentOperations.ToString());
     }
     if (TargetContentType != null)
     {
         // Could be present but empty
         if (TargetContentType.Equals(String.Empty))
         {
             // If you specify this option without a value, then AzCopy sets each blob or file's content type according to its file extension.
             // https://docs.microsoft.com/en-us/azure/storage/common/storage-use-azcopy#setcontenttypecontent-type
             args.AppendSwitchQuoted("/SetContentType", String.Empty);
         }
         else
         {
             args.AppendSwitchQuoted("/SetContentType", ":", TargetContentType);
         }
     }
     if (PayloadFormat != PayloadFormat.Default)
     {
         args.AppendSwitchQuoted("/PayloadFormat", ":", PayloadFormat.ToString());
     }
     return(args);
 }
Example #26
0
 public static AzCopySettings SetPayloadFormat(this AzCopySettings settings, PayloadFormat format)
 {
     settings.PayloadFormat = format;
     return(settings);
 }
Example #27
0
 public ProcessArgumentBuilder BuildWindowsArguments(ProcessArgumentBuilder args)
 {
     //var args = new ProcessArgumentBuilder();
     args.Append("/Y");
     if (Pattern.IsDefined())
     {
         args.AppendSwitchQuoted("/Pattern", ":", Pattern);
     }
     if (DestinationKey.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/DestKey", ":", DestinationKey);
     }
     if (DestinationSAS.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/DestSAS", ":", DestinationSAS);
     }
     if (SourceKey.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/SourceKey", ":", SourceKey);
     }
     if (SourceSAS.IsDefined())
     {
         args.AppendSwitchQuotedSecret("/SourceSAS", ":", SourceSAS);
     }
     if (Recursive)
     {
         args.Append("/S");
     }
     if (BlobType != null)
     {
         args.AppendSwitchQuoted("/BlobType", ":", BlobType.ToString());
     }
     if (UseChecksum)
     {
         args.Append("/CheckMD5");
     }
     if (LogFile != null)
     {
         args.AppendSwitchQuoted("/V", ":", LogFile.FullPath);
     }
     if (ParameterFiles.Any())
     {
         foreach (var file in ParameterFiles)
         {
             args.AppendSwitchQuoted("@", ":", file.FullPath);
         }
     }
     if (FileHandlingBehaviour != null)
     {
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.ArchiveOnly))
         {
             args.Append("/A");
         }
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.ExcludeNewerSource))
         {
             args.Append("/XN");
         }
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.ExcludeOlderSource))
         {
             args.Append("/XO");
         }
         if (FileHandlingBehaviour.Value.HasFlag(FileHandling.UpdateLastModified))
         {
             args.Append("/MT");
         }
     }
     if (Delimiter != null)
     {
         args.AppendSwitchQuoted("/Delimiter", ":", Delimiter.ToString());
     }
     if (ConcurrentOperations != 0)
     {
         args.AppendSwitchQuoted("/NC", ":", ConcurrentOperations.ToString());
     }
     if (TargetContentType.IsDefined())
     {
         args.AppendSwitchQuoted("/SetContentType", ":", TargetContentType);
     }
     if (PayloadFormat != PayloadFormat.Default)
     {
         args.AppendSwitchQuoted("/PayloadFormat", ":", PayloadFormat.ToString());
     }
     return(args);
 }