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); } } }
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> /// 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)); } }
/// <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)); } }
/// <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); }
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); }
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); }
/// <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)); } }
/// <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); }
/// <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); }
/// <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); }
/// <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); }
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; }
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; }
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); }
public static AzCopySettings SetPayloadFormat(this AzCopySettings settings, PayloadFormat format) { settings.PayloadFormat = format; return(settings); }
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); }