Logic Apps always preserves the Content-Type in a received HTTP request or response.So if your logic app receives content with Content-Type set to application/octet-stream,and you include that content in a later action without casting,the outgoing request also has Content-Type set to application/octet-stream.That way, Logic Apps can guarantee that data doesn't get lost while moving through the workflow.However, the action state, or inputs and outputs, is stored in a JSON objectwhile the state moves through the workflow.
A MIME attachment with the content type application/octet-stream is a binary file. Typically, it is an application or a document that is opened in an application such as a spreadsheet or word processor. If the attachment has a filename extension associated with it, you may be able to determine what type of file it is.
The application/octet-stream MIME type is used for unknown binary files. It preserves the file contents, but requires the receiver to determine file type, for example, from the filename extension. The Internet media type for an arbitrary byte stream is application/octet-stream.
This feature works with the application/octet-stream MIME type and any other type that can be sent as binary bytes. For example, the REST Adapter can send outbound requests or process outbound responses using the application/pdf, application/zip, image/jpeg, image/png, and other formats. Commonly used types shown in the dropdown are:
// Tempblob is containing the image or document or whatever// ByteArray = System.Array from 'mscorlib'// first fill the byte arrayTempBlob.Blob.CREATEINSTREAM(InStream);MemoryStream := MemoryStream.MemoryStream; COPYSTREAM( MemoryStream, InStream); ByteArray := MemoryStream.ToArray();BytesRead := ByteArray.Length;......// use the request stream of the httprequest and put in the bytearray:RequestStream := HttpWebRequest.GetRequestStream;RequestStream.Write( ByteArray, 0, ByteArray.Length);
Spring Cloud Stream allows you to declaratively configure type conversion for inputs and outputs using the spring.cloud.stream.bindngs..content-type property of a binding.Note that general type conversion may also be accomplished easily by using a transformer inside your application.Currently, Spring Cloud Stream natively supports the following type conversions commonly used in streams:
Besides the conversions that it supports out of the box, Spring Cloud Stream also supports registering your own message conversion implementations.This allows you to send and receive data in a variety of custom formats, including binary, and associate them with specific contentTypes.Spring Cloud Stream registers all the beans of type org.springframework.messaging.converter.MessageConverter as custom message converters along with the out of the box message converters.
If your message converter needs to work with a specific content-type and target class (for both input and output), then the message converter needs to extend org.springframework.messaging.converter.AbstractMessageConverter.For conversion when using @StreamListener, a message converter that implements org.springframework.messaging.converter.MessageConverter would suffice.
Spring Cloud Stream provides support for schema-based message converters through its spring-cloud-stream-schema module.Currently, the only serialization format supported out of the box is Apache Avro, with more formats to be added in future versions.
Spring Cloud Stream provides a schema registry server implementation.In order to use it, you can simply add the spring-cloud-stream-server artifact to your project and use the @EnableSchemaRegistryServer annotation, adding the schema registry server REST controller to your application.This annotation is intended to be used with Spring Boot web applications, and the listening port of the server is controlled by the server.port setting.The spring.cloud.stream.schema.server.path setting can be used to control the root path of the schema server (especially when it is embedded in other applications).
For Spring Boot applications that have a SchemaRegistryClient bean registered with the application context, Spring Cloud Stream will auto-configure an Apache Avro message converter that uses the schema registry client for schema management.This eases schema evolution, as applications that receive messages can get easy access to a writer schema that can be reconciled with their own reader schema.
During the outbound conversion, the message converter will try to infer the schemas of the outbound messages based on their type and register them to a subject based on the payload type using the SchemaRegistryClient.If an identical schema is already found, then a reference to it will be retrieved.If not, the schema will be registered and a new version number will be provided.The message will be sent with a contentType header using the scheme application/[prefix].[subject].v[version]+avro, where prefix is configurable and subject is deduced from the payload type.
When receiving messages, the converter will infer the schema reference from the header of the incoming message and will try to retrieve it. The schema will be used as the writer schema in the deserialization process.
However, despite having the '.txt' file extension, Salesforce processes them as binaryAttachments, complete with a MIMEType of application/octet-stream. The 'toString' method fails due to the MIMEType, and EncodingUtil.base64Encode(Blob body) spits out gibberish.
Does anyone know if there is a way to change the 'mimeTypeSubType' value of an attachment so that the toString() method will operate? Or is there another way to extract plain text (ascii encoded) content from an application/octet-stream attachment?
The following DataWeave examples show how to convert a file stream into Base64 and to convert a Base64 string into a file stream. They use a PDF file as the input and output.Before you begin, note that 2.x versions of DataWeave are used by Mule 4 apps. ForDataWeave in Mule 3 apps, refer toDataWeave version 1.2 examples.For other DataWeave versions, you can use the version selector in the DataWeave table of contents.
This example performs Base64 encoding on a PDF file. It simulates the transformation in the Read operation from the XML configuration by converting a Base64 file stream (application/octet-stream) to Binary and outputting the Binary in the text/plain format.
The example assumes that the PDF file is in the src/main/resources directory of a Mule project in Anypoint Studio. It provides the name of the PDF file and specifies the MIME type as "application/octet-stream". Using "binary" as the second readUrl argument is also valid for this example.
This example simulates the transformation in the Write operation from the XML configuration by converting a Base64 file stream (application/octet-stream) to Binary and outputting the Binary in the application/PDF with binary format. The example does not generate a PDF file; a Write operation is required to generate such a file.
The example assumes that the PDF file is in the src/main/resources directory of a Mule project in Anypoint Studio. The function reads the input PDF as an octet-stream MIME type. Using the MIME type "binary" as the second readUrl argument is also valid for this example.
Octet stream to static tensor: You should set input-type and input-dim to describe tensor(s) information of outgoing buffer.If setting multiple tensors, converter will divide incoming buffer and set multiple memory chunks in outgoing buffer.
Octet stream to flexible tensor: With a caps filter (other/tensors,format=flexible), tensor-converter generates flexible tensor.In this case, you don't need to denote input-type and input-dim in pipeline description.Converter sets the dimension with buffer size (size:1:1:1) and type uint8, and appends this information (tensor-meta) in the memory of outgoing buffer.
Media to octet stream: If you need to convert media to octet stream, use capssetter.This element can update the caps of incoming buffer using it's properties. After updating the mimetye of media stream, it can be converted to tensor stream with tensor_converter.
Note that, only octet-stream in the default capabilities of sink pad supports configuring multiple tensors in outgoing buffer.When incoming media type is video, audio, or text, each frame (or a set of frames consisting a buffer) is supposed to be represented by a single tensor instance and it will have other/tensor capability.
Spring Cloud Stream exposes a mechanism to define and register additional MessageConverters.To use it, implement org.springframework.messaging.converter.MessageConverter, configure it as a @Bean, and annotate it with @StreamMessageConverter.It is then apended to the existing stack of `MessageConverter`s.
It is important to understand that custom MessageConverter implementations are added to the head of the existing stack.Consequently, custom MessageConverter implementations take precedence over the existing ones, which lets you override as well as add to the existing converters.
On Windows, when we get a bogus mimetype (application/octet-stream) from github, and no content-disposition header (so we don't force asking the user what to do, fixing which would be bug 453455) we realize the mimetype is bogus, and use the file extension (.pdf) instead. This is probably a good thing. We do a lookup based on the pdf extension, which gets us a mimeinfo object.
The problem is.. the external helper app code isn't what deals with this. For previewing the pdf, we should have hit the streamconverter for pdfjs earlier in this process. But we still honour the fact that the mime info object says "don't ask" (after all, the user preference isn't set up to "always ask"), and because neither use of the OS default helper or another external helper app is specified, we download the file. Without asking. Oops. 2b1af7f3a8