void IAssemblerComponent.AddDocument(IPipelineContext pContext, IBaseMessage pInMsg) { if (this.GetFault(pInMsg) != null) { qOutputMsgs.Enqueue(pInMsg); } else { MultipartMessageDefinition tempMessage = MultipartMessageManager.GenerateFromMessage(pInMsg); StringWriter sw = new StringWriter(); XmlSerializer ser = new XmlSerializer(typeof(MultipartMessageDefinition), Constants.SUBMISSION_NAMESPACE); ser.Serialize(sw, tempMessage); byte[] arrByte = System.Text.Encoding.UTF8.GetBytes(sw.ToString().Replace("utf-16", "utf-8")); //GetBytes(sw.ToString().Replace("utf-16", "utf-8")); //GetBytes(sw.ToString()); MemoryStream tempStream = new MemoryStream(arrByte); tempStream.Seek(0, SeekOrigin.Begin); IBaseMessage outMsg = pContext.GetMessageFactory().CreateMessage(); IBaseMessagePart outPart = pContext.GetMessageFactory().CreateMessagePart(); outPart.Data = tempStream; outPart.Charset = "utf-8"; outMsg.AddPart("ConstructedPart", outPart, true); //outMsg.BodyPart.Data = tempStream; outMsg.Context = pInMsg.Context; outMsg.Context.Promote(BTSProperties.messageType.Name.Name, BTSProperties.messageType.Name.Namespace, "http://BizWTF.Mocking.Schemas.Submission#MultipartMessage"); qOutputMsgs.Enqueue(outMsg); pContext.ResourceTracker.AddResource(tempStream); } }
/// <summary> /// Implements IComponent.Execute method. /// </summary> /// <param name="pc">Pipeline context</param> /// <param name="inmsg">Input message.</param> /// <returns>Processed input message with appended or prepended data.</returns> /// <remarks> /// Converts xsl-fo transformed messages to pdf /// </remarks> public IBaseMessage Execute(IPipelineContext pc, IBaseMessage inmsg) { IBaseMessagePart bodyPart = inmsg.BodyPart; if (bodyPart.Data != null) { VirtualStream vtstm = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); FonetDriver driver = FonetDriver.Make(); driver.CloseOnExit = false;//important for biztalk to work ... set position = 0 PdfRendererOptions options = new PdfRendererOptions(); options.Title = Title; options.Subject = Subject; options.UserPassword = Password; driver.Options = options; Stream stm = bodyPart.GetOriginalDataStream(); stm.Seek(0, SeekOrigin.Begin); driver.Render(stm, vtstm); vtstm.Seek(0, SeekOrigin.Begin); bodyPart.Data = vtstm; } return(inmsg); }
private IBaseMessage BuildBTSMessage(IPipelineContext pContext, IBaseMessageContext sourceContext, List <Part> partList) { IBaseMessage newMessage = pContext.GetMessageFactory().CreateMessage(); IBaseMessagePart msgPart = pContext.GetMessageFactory().CreateMessagePart(); newMessage.Context = sourceContext; foreach (Part part in partList) { if (part.Data != null) { msgPart.Charset = "utf-8"; msgPart.ContentType = part.ContentType; msgPart.Data = GetPartStream(part.Data); newMessage.AddPart(part.PartName, msgPart, part.IsBodyPart); } else { System.IO.MemoryStream memStrm = new MemoryStream(); StreamWriter sw = new StreamWriter(memStrm); sw.Write(part.RawData); sw.Flush(); memStrm.Position = 0; msgPart.ContentType = part.ContentType; msgPart.Data = memStrm; newMessage.AddPart(part.PartName, msgPart, part.IsBodyPart); } } return(newMessage); }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { XmlDocument sourceDoc = new XmlDocument(); pInMsg.BodyPart.Data.Position = 0; sourceDoc.Load(pInMsg.BodyPart.Data); XmlDocument outputDoc = Tools.ApplyXSLTransform(sourceDoc, TransformResources.MAP_ToMockService); byte[] arrByte = System.Text.Encoding.UTF8.GetBytes(outputDoc.OuterXml.Replace("utf-16", "utf-8")); MemoryStream tempStream = new MemoryStream(arrByte); tempStream.Seek(0, SeekOrigin.Begin); IBaseMessage outMsg = pContext.GetMessageFactory().CreateMessage(); IBaseMessagePart bodyMsgPart = pContext.GetMessageFactory().CreateMessagePart(); bodyMsgPart.Data = tempStream; bodyMsgPart.Charset = "utf-8"; outMsg.AddPart("body", bodyMsgPart, true); outMsg.Context = pInMsg.Context; outMsg.Context.Promote(BTSProperties.messageType.Name.Name, BTSProperties.messageType.Name.Namespace, "http://NWT.Mocking.Services#SubmitMessage"); pContext.ResourceTracker.AddResource(tempStream); return(outMsg); }
/// <summary> /// copies all message parts part of the inbound message onto the outbound message /// </summary> /// <param name="pc">the <see cref="IPipelineContext"/> this message belongs to</param> /// <param name="inmsg">the inbound message</param> /// <param name="outmsg">the outbound message</param> /// <param name="bodyPart">the body part</param> /// <param name="allowUnrecognizeMessage">whether to allow unrecognized messages</param> public static void CopyMessageParts( IPipelineContext pc, IBaseMessage inmsg, IBaseMessage outmsg, IBaseMessagePart bodyPart, bool allowUnrecognizeMessage) { string text1 = inmsg.BodyPartName; for (int num1 = 0; num1 < inmsg.PartCount; num1++) { string text2 = null; IBaseMessagePart part1 = inmsg.GetPartByIndex(num1, out text2); if ((part1 == null) && !allowUnrecognizeMessage) { throw new ArgumentNullException("otherOutPart[" + num1 + "]"); } if (text1 != text2) { outmsg.AddPart(text2, part1, false); } else { outmsg.AddPart(text1, bodyPart, true); } } }
/// <summary> /// Creates IBaseMessage objects from array of streams /// </summary> /// <param name="mf">Reference to BizTalk message factory object</param> /// <param name="url">Address of receive location where this message will be submitted to</param> /// <param name="data">Payloads for each message</param> /// <returns>Array of BizTalk message objects</returns> public static IBaseMessage[] CreateMessages(IBaseMessageFactory mf, string url, Stream[] data) { IBaseMessagePart part = null; IBaseMessageContext ctx = null; IBaseMessage[] msgs = null; SystemMessageContext smc = null; msgs = new IBaseMessage[data.Length]; for (int c = 0; c < data.Length; c++) { // Create a new message msgs[c] = mf.CreateMessage(); part = mf.CreateMessagePart(); part.Data = data[c]; ctx = msgs[c].Context; msgs[c].AddPart("body", part, true); // Set the system context properties smc = new SystemMessageContext(ctx); if (null != url) { smc.InboundTransportLocation = url; } } return(msgs); }
/// <summary> /// Creates IBaseMessage object from string /// </summary> /// <param name="mf">Reference to BizTalk message factory object</param> /// <param name="url">Address of receive location where this message will be submitted</param> /// <param name="data">Payload of the message</param> /// <returns>BizTalk message object</returns> public static IBaseMessage CreateMessage(IBaseMessageFactory mf, string url, string data) { IBaseMessagePart part = null; IBaseMessageContext ctx = null; IBaseMessage msg = null; SystemMessageContext smc = null; // Write the data to a new stream... StreamWriter sw = new StreamWriter(new MemoryStream()); sw.Write(data); sw.Flush(); sw.BaseStream.Seek(0, SeekOrigin.Begin); // Create a new message msg = mf.CreateMessage(); part = mf.CreateMessagePart(); part.Data = sw.BaseStream; ctx = msg.Context; msg.AddPart("body", part, true); // Set the system context properties smc = new SystemMessageContext(ctx); if (null != url) { smc.InboundTransportLocation = url; } return(msg); }
/// <summary> /// Creates an array of IBaseMessage objects from array of strings /// </summary> /// <param name="mf">Reference to BizTalk message factory object</param> /// <param name="url">Address of receive location where this message will be submitted to</param> /// <param name="data">Payloads for each message</param> /// <returns>Array of BizTalk message objects</returns> public static IBaseMessage[] CreateMessages(IBaseMessageFactory mf, string url, string[] data) { IBaseMessagePart part = null; IBaseMessageContext ctx = null; IBaseMessage[] msgs = null; SystemMessageContext smc = null; msgs = new IBaseMessage[data.Length]; for (int c = 0; c < data.Length; c++) { // Write the data to a new stream... StreamWriter sw = new StreamWriter(new MemoryStream()); sw.Write(data[c]); sw.Flush(); sw.BaseStream.Seek(0, SeekOrigin.Begin); // Create a new message msgs[c] = mf.CreateMessage(); part = mf.CreateMessagePart(); part.Data = sw.BaseStream; ctx = msgs[c].Context; msgs[c].AddPart("body", part, true); // Set the system context properties smc = new SystemMessageContext(ctx); if (null != url) { smc.InboundTransportLocation = url; } } return(msgs); }
/// <summary> /// Obtains a byte array representation of an IBaseMessagePart. The underlying message stream is read in /// order to populate the byte array. /// </summary> /// <param name="pipelineContext">The pipeline context.</param> /// <param name="messagePart">The message part.</param> /// <returns>A byte array representation of the IBaseMessagePart.</returns> public static byte[] MessageToByteArray(IPipelineContext pipelineContext, IBaseMessagePart messagePart) { byte[] buffer = null; Stream dataStream = null; try { dataStream = GetReadOnlySeekableDataStream(pipelineContext, messagePart); if (dataStream.Position != 0L) { dataStream.Position = 0L; } byte[] bufferFromStream = new byte[dataStream.Length]; int count = dataStream.Read(bufferFromStream, 0, bufferFromStream.Length); buffer = bufferFromStream; } catch (Exception) { // Ignore exceptions here. If the document can not be read into a byte array then the method returns null. } finally { if (dataStream != null && dataStream.CanSeek) { dataStream.Position = 0L; } } return(buffer); }
internal static IBaseMessage CloneMessage(IBaseMessage inmsg, IPipelineContext pc) { IBaseMessageFactory messageFactory = pc.GetMessageFactory(); var outmsg = messageFactory.CreateMessage(); outmsg.Context = PipelineUtil.CloneMessageContext(inmsg.Context); // Generate new empty message body part, we will retain nothing from the old IBaseMessagePart body = messageFactory.CreateMessagePart(); if ((inmsg != null) && (inmsg.BodyPart != null)) { body.PartProperties = PipelineUtil.CopyPropertyBag(inmsg.BodyPart.PartProperties, messageFactory); } // This is what the XmlWriter will end up generating, and what appears in the // directive at the top of the file body.Charset = "UTF-8"; body.ContentType = "text/xml"; body.Data = null; CloneParts(pc, inmsg, outmsg, body); return(outmsg); }
private IBaseMessage CreateMessage(Shared.Components.Entry message) { MemoryStream mem = new MemoryStream(UTF8Encoding.UTF8.GetBytes(message.Content)); IBaseMessageFactory factory = this.transportProxy.GetMessageFactory(); IBaseMessagePart part = factory.CreateMessagePart(); part.Data = mem; IBaseMessage msg = factory.CreateMessage(); msg.AddPart("body", part, true); // We must add these context properties SystemMessageContext context = new SystemMessageContext(msg.Context); context.InboundTransportLocation = this.uri; context.InboundTransportType = this.transportType; //Set ActionOnFailure to zero in the context property of each messaqe that you do not want BizTalk Server to suspend on a processing exception. //Failure to set this property allows BizTalk Server to fall back to its default behavior //of suspending the message on a processing exception. //context.ActionOnFailure = 0; //we could promote entity id and updated, msg.Context.Promote(ns, message.Id return(msg); }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { string errorMessage; if (!Validate(out errorMessage)) { throw new ArgumentException(errorMessage); } String value = null; IBaseMessagePart bodyPart = pInMsg.BodyPart; Stream inboundStream = bodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream); XmlTextReader xmlTextReader = new XmlTextReader(readOnlySeekableStream); XPathCollection xPathCollection = new XPathCollection(); XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection); xPathCollection.Add(XPath); while (xPathReader.ReadUntilMatch()) { if (xPathReader.Match(0)) { if (xPathReader.NodeType == XmlNodeType.Attribute) { value = xPathReader.GetAttribute(xPathReader.Name); } else { value = xPathReader.ReadString(); } if (PromoteProperty) { pInMsg.Context.Promote(new ContextProperty(PropertyPath), value); } else { pInMsg.Context.Write(new ContextProperty(PropertyPath), value); } break; } } if (string.IsNullOrEmpty(value) && ThrowIfNoMatch) { throw new InvalidOperationException("The specified XPath did not exist or contained an empty value."); } readOnlySeekableStream.Position = 0; pContext.ResourceTracker.AddResource(readOnlySeekableStream); bodyPart.Data = readOnlySeekableStream; return(pInMsg); }
IBaseMessage IComponent.Execute(IPipelineContext pContext, IBaseMessage pInMsg) { Trace.WriteLine("DotNetTypesToJsonConverter Pipeline - Entered Execute()"); Trace.WriteLine("DotNetTypesToJsonConverter Pipeline - TypeName is set to: " + TypeName); IBaseMessagePart bodyPart = pInMsg.BodyPart; if (bodyPart != null) { Stream originalStream = bodyPart.GetOriginalDataStream(); if (originalStream != null) { Type myClassType = Type.GetType(TypeName); object reqObj = PcHelper.FromXml(originalStream, myClassType); string jsonText = JsonConvert.SerializeObject(reqObj, myClassType, Formatting.None, new JsonSerializerSettings()); Trace.WriteLine("DotNetTypesToJsonConverter output: " + jsonText); byte[] outBytes = Encoding.ASCII.GetBytes(jsonText); var memStream = new MemoryStream(); memStream.Write(outBytes, 0, outBytes.Length); memStream.Position = 0; bodyPart.Data = memStream; pContext.ResourceTracker.AddResource(memStream); } } Trace.WriteLine("DotNetTypesToJsonConverter Pipeline - Exited Execute()"); return(pInMsg); }
/// <summary> /// Returns an XmlDocument over the message part content. /// </summary> /// <param name="messagePart">A pipeline messagePart part.</param> /// <returns>An XML document.</returns> public static XmlDocument AsXmlDocument(this IBaseMessagePart messagePart) { var bodyXml = new XmlDocument(); // Preserve whitespace to render document as original by default bodyXml.PreserveWhitespace = true; if (messagePart.Data == null) { return(bodyXml); } var currentPosition = messagePart.Data.Position; messagePart.WithStreamAtStart(); try { bodyXml.Load(messagePart.Data); } catch (XmlException) { return(new XmlDocument()); } messagePart.Data.Seek(currentPosition, SeekOrigin.Begin); return(bodyXml); }
private IBaseMessage CreateMessage(BrokeredMessage message) { Stream stm = message.GetBody <Stream>(); IBaseMessageFactory factory = this.transportProxy.GetMessageFactory(); IBaseMessagePart part = factory.CreateMessagePart(); part.Data = stm; IBaseMessage msg = factory.CreateMessage(); msg.AddPart("body", part, true); // We must add these context properties SystemMessageContext context = new SystemMessageContext(msg.Context); context.InboundTransportLocation = this.uri; context.InboundTransportType = this.transportType; msg.Context.Promote("SequenceNumber", this.propertyNamespace, message.SequenceNumber.ToString()); return(msg); }
/// <summary> /// Remove outer nodes from the message part content and leave the body. /// </summary> /// <param name="messagePart">The message part</param> /// <param name="bodyContainerXPath">The XPath specifying the body of the message.</param> /// <returns>The message part with the envelope removed.</returns> public static IBaseMessagePart RemoveEnvelope(this IBaseMessagePart messagePart, string bodyContainerXPath) { if (string.IsNullOrEmpty(bodyContainerXPath)) { return(messagePart); } var bodyXml = messagePart.AsXmlDocument(); // Assign content back to part var contentStream = new MemoryStream(); var sw = new StreamWriter(contentStream); var selectSingleNode = bodyXml.SelectSingleNode(bodyContainerXPath); if (selectSingleNode != null) { sw.Write(selectSingleNode.FirstChild.OuterXml); } sw.Flush(); contentStream.StreamAtStart(); messagePart.Data = contentStream; return(messagePart); }
/// <summary> /// Create the output message when validation errors are captured /// </summary> /// <param name="pContext">Pipeline context</param> /// <param name="pInMsg">Input message in the pipeline</param> /// <param name="errorStream">Stream for the Validation Errors</param> /// <param name="requestId">Request Id</param> /// <returns></returns> public static IBaseMessage CreateOutPutMessage(IPipelineContext pContext, IBaseMessage pInMsg, VirtualStream errorStream, string requestId) { VirtualStream seekableStream = new VirtualStream(pInMsg.BodyPart.GetOriginalDataStream()); seekableStream.Position = 0; errorStream.Position = 0; VirtualStream outMsgStream = CreateValidationErrorMessage(seekableStream, errorStream, requestId); outMsgStream.Position = 0; IBaseMessageFactory messageFactory = pContext.GetMessageFactory(); IBaseMessage pOutMsg = messageFactory.CreateMessage(); IBaseMessagePart pOutMsgBodyPart = messageFactory.CreateMessagePart(); IBasePropertyBag pOutPb = PipelineUtil.CopyPropertyBag(pInMsg.BodyPart.PartProperties, messageFactory); pOutMsg.Context = PipelineUtil.CloneMessageContext(pInMsg.Context); pOutMsgBodyPart.Charset = Constants.BodyPartCharSet; pOutMsgBodyPart.ContentType = Constants.BodyPartContentType; pOutMsgBodyPart.Data = outMsgStream; string outMessageType = string.Format("{0}#{1}", Constants.AIBPValidationErrorNameSpace, Constants.AIBPValidationErrorRootNode); pOutMsg.Context.Promote(Constants.MessageTypePropName, Constants.SystemPropertiesNamespace, outMessageType); pOutMsg.AddPart("Body", pOutMsgBodyPart, true); // Add resources to the resource tracker to be disposed of at correct time pContext.ResourceTracker.AddResource(seekableStream); pContext.ResourceTracker.AddResource(outMsgStream); pContext.ResourceTracker.AddResource(errorStream); return(pOutMsg); }
public object Clone() { int partCount = this.PartCount; IBaseMessageFactory factory = new MessageFactory(); IBaseMessage message = factory.CreateMessage(); Message message2 = (Message)message; message2.messageId = this.MessageID; IBaseMessageContext oldCtx = this.Context; if (oldCtx != null) { IBaseMessageContext context2 = PipelineUtil.CloneMessageContext(oldCtx); message.Context = context2; } Exception errorInfo = this.GetErrorInfo(); if (errorInfo != null) { message.SetErrorInfo(errorInfo); } string bodyPartName = this.BodyPartName; for (int i = 0; i < partCount; i++) { string str2; IBaseMessagePart partByIndex = this.GetPartByIndex(i, out str2); IBaseMessagePart part = ((MessagePart)partByIndex).CopyMessagePart(factory); message.AddPart(str2, part, bodyPartName == str2); } return(message); }
private string GetFileName(IBaseMessagePart part) { var receivedFileNameProperty = new ContextProperty(FileProperties.ReceivedFileName); var receivedFileName = part.PartProperties.Read(receivedFileNameProperty.PropertyName, receivedFileNameProperty.PropertyNamespace) as string; string fileName; string extension = string.Empty; if (!string.IsNullOrEmpty(receivedFileName)) { fileName = receivedFileName; } else { if (!string.IsNullOrEmpty(part.ContentType)) { extension = MimeUtils.GetFileExtensionForMimeType(part.ContentType); } else if (!string.IsNullOrEmpty(DefaultZipEntryFileExtension)) { extension = string.Concat(".", DefaultZipEntryFileExtension); } fileName = Guid.NewGuid() + extension; } return(fileName); }
/// <summary> /// Synchronously executes the task using the specified <see cref="RuntimeTaskExecutionContext"/> execution context object. /// </summary> /// <param name="context">The execution context.</param> public override void Run(RuntimeTaskExecutionContext context) { var callToken = TraceManager.CustomComponent.TraceIn(); IBaseMessageFactory msgFactory = context.PipelineContext.GetMessageFactory(); IBaseMessage responseMsg = msgFactory.CreateMessage(); IBaseMessageContext responseMsgCtx = msgFactory.CreateMessageContext(); IBaseMessageContext requestMsgCtx = context.Message.Context; responseMsg.Context = responseMsgCtx; if (BizTalkUtility.ContainsResponsePart(context.Message)) { IBaseMessagePart responsePart = BizTalkUtility.GetResponsePart(context.Message); responseMsg.AddPart(context.Message.BodyPartName, responsePart, true); } else { responseMsg.AddPart(context.Message.BodyPartName, context.Message.BodyPart, true); } responseMsgCtx.Promote(EpmRRCorrelationToken.Name.Name, EpmRRCorrelationToken.Name.Namespace, requestMsgCtx.Read(EpmRRCorrelationToken.Name.Name, EpmRRCorrelationToken.Name.Namespace)); responseMsgCtx.Promote(RouteDirectToTP.Name.Name, RouteDirectToTP.Name.Namespace, true); responseMsgCtx.Promote(CorrelationToken.Name.Name, CorrelationToken.Name.Namespace, requestMsgCtx.Read(CorrelationToken.Name.Name, CorrelationToken.Name.Namespace)); responseMsgCtx.Promote(ReqRespTransmitPipelineID.Name.Name, ReqRespTransmitPipelineID.Name.Namespace, requestMsgCtx.Read(ReqRespTransmitPipelineID.Name.Name, ReqRespTransmitPipelineID.Name.Namespace)); responseMsgCtx.Write(ReceivePipelineResponseConfig.Name.Name, ReceivePipelineResponseConfig.Name.Namespace, requestMsgCtx.Read(ReceivePipelineResponseConfig.Name.Name, ReceivePipelineResponseConfig.Name.Namespace)); context.Message = responseMsg; TraceManager.CustomComponent.TraceOut(callToken); }
private string GetFileName(IBaseMessagePart part) { var receivedFileNameProperty = new ContextProperty(FileProperties.ReceivedFileName); var receivedFileName = part.PartProperties.Read(receivedFileNameProperty.PropertyName, receivedFileNameProperty.PropertyNamespace) as string; string fileName; string extension = string.Empty; if (!string.IsNullOrEmpty(receivedFileName)) { fileName = receivedFileName; } else { if (!string.IsNullOrEmpty(part.ContentType)) { extension = MimeUtils.GetFileExtensionForMimeType(part.ContentType); } else if (!string.IsNullOrEmpty(DefaultZipEntryFileExtension)) { extension = string.Concat(".",DefaultZipEntryFileExtension); } fileName = Guid.NewGuid() + extension; } return fileName; }
public static void CloneAndAddMessageParts(IPipelineContext pipelineContext, IBaseMessage sourceMessage, IBaseMessage destinationMessage) { if (pipelineContext == null) { throw new ArgumentNullException("pipelineContext"); } if (sourceMessage == null) { throw new ArgumentNullException("sourceMessage"); } if (destinationMessage == null) { throw new ArgumentNullException("destinationMessage"); } try { string bodyPartName = sourceMessage.BodyPartName; for (int index = 0; index < sourceMessage.PartCount; ++index) { string partName = (string)null; IBaseMessagePart partByIndex = sourceMessage.GetPartByIndex(index, out partName); IBaseMessagePart part = MessageHelper.CloneMessagePart(pipelineContext, partByIndex); bool bBody = string.Compare(partName, bodyPartName, true, CultureInfo.CurrentCulture) == 0; destinationMessage.AddPart(partName, part, bBody); } } catch (Exception ex) { DECore.TraceProvider.Logger.TraceError(ex); throw; } }
public void SubmitMessage(IBaseMessage message, object userData = null) { if (_submitResponseMessageArray != null) { throw new InvalidOperationException("SubmitResponseMessage and SubmitMessage operations cannot be in the same batch"); } // We need to have data (body part) to handle batch failures. IBaseMessagePart bodyPart = message.BodyPart; if (bodyPart == null) { throw new InvalidOperationException("The message doesn't contain body part"); } Stream stream = bodyPart.GetOriginalDataStream(); if (stream == null || stream.CanSeek == false) { throw new InvalidOperationException("Cannot submit empty body or body with non-seekable stream"); } _transportBatch.SubmitMessage(message); if (null == _submitArray) { _submitArray = new List <BatchMessage>(); } _submitArray.Add(new BatchMessage(message, userData)); _workToBeDone = true; }
/// <summary> /// (1) Gets the file from the sftp host /// (2) Creates a IBaseMessage /// (3) Sets varius properties such as uri, messagepart, transporttype etc /// (4) Adds the message to the batch /// </summary> /// <param name="fileName"></param> /// <param name="uri"></param> /// <param name="size"></param> /// <param name="afterGetAction"></param> /// <param name="afterGetFilename"></param> /// <returns></returns> internal IBaseMessage CreateMessage(string fileName, string uri, long size, SftpReceiveProperties.AfterGetActions afterGetAction, string afterGetFilename) { try { TraceMessage("[SftpReceiverEndpoint] Reading file to stream " + fileName); // Retrieves the message from sftp server. var stream = _sftp.Get(fileName); stream.Position = 0; // Creates new message IBaseMessageFactory messageFactory = _transportProxy.GetMessageFactory(); IBaseMessagePart part = messageFactory.CreateMessagePart(); part.Data = stream; var message = messageFactory.CreateMessage(); message.AddPart(MessageBody, part, true); // Setting metadata SystemMessageContext context = new SystemMessageContext(message.Context) { InboundTransportLocation = uri, InboundTransportType = _transportType }; // Write/Promote any adapter specific properties on the message context message.Context.Write(Remotefilename, _propertyNamespace, fileName); SetReceivedFileName(message, fileName); message.Context.Write("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/" + _transportType.ToLower() + "-properties", fileName); message.Context.Write("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/file-properties", fileName); // Add the file to the batch Files.Add(new BatchMessage(message, fileName, BatchOperationType.Submit, afterGetAction, afterGetFilename)); // Greg Sharp: Let the caller set this as the file size may be stale // Add the size of the file to the stream //if (message.BodyPart.Data.CanWrite) // message.BodyPart.Data.SetLength(size); return(message); } catch (Exception ex) { TraceMessage("[SftpReceiverEndpoint] Error Adding file [" + fileName + "]to batch. Error: " + ex.Message); if (_useLoadBalancing) { DataBaseHelper.CheckInFile(uri, Path.GetFileName(fileName), _traceFlag); } return(null); } }
/// <summary> /// Helper method to consume the part stream /// </summary> /// <param name="part">Part to consume</param> public static void ConsumeStream(IBaseMessagePart part) { if (part == null) { throw new ArgumentNullException("part"); } ConsumeStream(part.Data); }
/// <summary> /// called by the messaging engine when a new message arrives /// </summary> /// <param name="pc">the pipeline context</param> /// <param name="inmsg">the actual message</param> public void Disassemble(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg) { // // TODO: implement message retrieval logic IBaseMessagePart Body = inmsg.BodyPart; if (Body != null) { Stream originalStream = Body.GetOriginalDataStream(); if (originalStream != null) { var xml = XElement.Load(originalStream); var rootElement = xml.Name; // Child elements from source file to split by. var childNodes = xml.Descendants(this.DescendantElement); // This is the total number of elements to be sliced up into // separate files. int cnt = childNodes.Count(); var skip = 0; var take = this.BatchSize; var fileno = 0; // Split elements into chunks and save to disk. while (skip < cnt) { // Extract portion of the xml elements. var c1 = childNodes .Skip(skip) .Take(take); // Setup number of elements to skip on next iteration. skip += take; // File sequence no for split file. fileno += 1; // Filename for split file. // Create a partial xml document. XElement frag = new XElement(rootElement, c1); // Save to disk. var newStream = new MemoryStream(); frag.Save(newStream); newStream.Position = 0; pc.ResourceTracker.AddResource(newStream); IBaseMessage newmsg = pc.GetMessageFactory().CreateMessage(); newmsg.AddPart("Body", pc.GetMessageFactory().CreateMessagePart(), true); newmsg.BodyPart.Data = newStream; newmsg.Context = PipelineUtil.CloneMessageContext(inmsg.Context); //outMsg.Context.Promote("MessageType", "http://schemas.microsoft.com/BizTalk/2003/system-properties", "Namespace#Root"); var msgtype = (string.IsNullOrEmpty(rootElement.Namespace.NamespaceName)?"" : rootElement.Namespace.NamespaceName + "#") + rootElement.LocalName; newmsg.Context.Write("MessageType", "http://schemas.microsoft.com/BizTalk/2003/system-properties", msgtype); newmsg.Context.Promote("MessageType", "http://schemas.microsoft.com/BizTalk/2003/system-properties", msgtype); _msgs.Enqueue(newmsg); } } } }
public void Disassemble(IPipelineContext pContext, IBaseMessage pInMsg) { IBaseMessagePart bodyPart = pInMsg.BodyPart; if (bodyPart != null) { Stream originalStream = bodyPart.GetOriginalDataStream(); if (originalStream != null) { using (ZipInputStream zipInputStream = new ZipInputStream(originalStream)) { if (_password != null && _password.Length > 0) { zipInputStream.Password = _password; } ZipEntry entry = zipInputStream.GetNextEntry(); while (entry != null) { MemoryStream memStream = new MemoryStream(); byte[] buffer = new Byte[1024]; int bytesRead = 1024; while (bytesRead != 0) { bytesRead = zipInputStream.Read(buffer, 0, buffer.Length); memStream.Write(buffer, 0, bytesRead); } string fileName = entry.FileName.ToString(); //file name in zip file string extension = Path.GetExtension(fileName); IBaseMessage outMessage; outMessage = pContext.GetMessageFactory().CreateMessage(); outMessage.AddPart("Body", pContext.GetMessageFactory().CreateMessagePart(), true); memStream.Position = 0; outMessage.BodyPart.Data = memStream; IBaseMessageContext context = pInMsg.Context; string receivePortName = context.Read("ReceivePortName", "http://schemas.microsoft.com/BizTalk/2003/system-properties").ToString(); string fullPath = context.Read("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/file-properties").ToString(); string filePath = Path.GetDirectoryName(fullPath); outMessage.Context = PipelineUtil.CloneMessageContext(pInMsg.Context); outMessage.Context.Promote("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/file-properties", fileName); outMessage.Context.Promote("ReceivePortName", "http://schemas.microsoft.com/BizTalk/2003/system-properties", receivePortName); _qOutMessages.Enqueue(outMessage); entry = zipInputStream.GetNextEntry(); } } } } }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { String value = null; bool suspend = false; IBaseMessagePart bodyPart = pInMsg.BodyPart; Stream inboundStream = bodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream); XmlTextReader xmlTextReader = new XmlTextReader(readOnlySeekableStream); XPathCollection xPathCollection = new XPathCollection(); XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection); xPathCollection.Add(XPath); while (xPathReader.ReadUntilMatch()) { if (xPathReader.Match(0)) { if (xPathReader.NodeType == XmlNodeType.Attribute) { value = xPathReader.GetAttribute(xPathReader.Name); } else { value = xPathReader.ReadString(); } break; } } suspend = ScriptExpressionHelper.ValidateExpression(value, Expression); if (suspend) { readOnlySeekableStream.Position = 0; pContext.ResourceTracker.AddResource(readOnlySeekableStream); bodyPart.Data = readOnlySeekableStream; pInMsg.Context.Write("SuspendAsNonResumable", "http://schemas.microsoft.com/BizTalk/2003/system-properties", true); pInMsg.Context.Write("SuppressRoutingFailureDiagnosticInfo", "http://schemas.microsoft.com/BizTalk/2003/system-properties", true); throw new Exception(String.Format("Expression {0} {1} did not evaluate to true", value, Expression)); } else { pInMsg = null; } return(pInMsg); }
/// <summary> /// Creates a new message part /// </summary> /// <param name="body">Body of the part</param> /// <returns>The new part</returns> public static IBaseMessagePart CreatePartFromStream(Stream body) { if (body == null) throw new ArgumentNullException("body"); IBaseMessagePart part = _factory.CreateMessagePart(); part.Data = body; return part; }
/// <summary> /// Helper method to read back a stream as a string /// </summary> /// <param name="part">Part to consume</param> public static String ReadString(IBaseMessagePart part) { if (part == null) throw new ArgumentNullException("part"); Encoding enc = Encoding.UTF8; if (!String.IsNullOrEmpty(part.Charset)) enc = Encoding.GetEncoding(part.Charset); return ReadString(part.Data, enc); }
public static object Read(this IBaseMessagePart part, ContextProperty property) { if (property == null) { throw new ArgumentNullException("property"); } return(part.PartProperties.Read(property.PropertyName, property.PropertyNamespace)); }
public void AddPart(string partName, IBaseMessagePart part, bool bBody) { if (bBody) { this._bodyPartName = partName; this._bodyPart = part; } this._partDictionary[partName] = part; }
private static void CloneParts(IPipelineContext pc, IBaseMessage inmsg, IBaseMessage outmsg, IBaseMessagePart bodyPart) { for (int i = 0; i < inmsg.PartCount; i++) { string partName = null; IBaseMessagePart currentPart = inmsg.GetPartByIndex(i, out partName); if (currentPart == null) continue; outmsg.AddPart(partName, partName == inmsg.BodyPartName ? bodyPart : currentPart, partName == inmsg.BodyPartName); } }
/// <summary> /// Helper method to consume the part stream /// </summary> /// <param name="part">Part to consume</param> public static void ConsumeStream(IBaseMessagePart part) { if ( part == null ) throw new ArgumentNullException("part"); ConsumeStream(part.Data); }
internal IBaseMessage WithPart(string partName, IBaseMessagePart part, bool bBody) { this.AddPart(partName, part, bBody); return this; }
/// <summary> /// Helper method to read back a stream as a string /// </summary> /// <param name="part">Part to consume</param> public static String ReadString(IBaseMessagePart part) { if ( part == null ) throw new ArgumentNullException("part"); Encoding enc = Encoding.UTF8; if ( !String.IsNullOrEmpty(part.Charset) ) enc = Encoding.GetEncoding(part.Charset); return ReadString(part.Data, enc); }