/// <summary>
/// Implementation for AsyncTransmitterEndpoint::ProcessMessage
/// Transmit the message and optionally return the response message (for Request-Response support)
/// </summary>
public override IBaseMessage ProcessMessage(IBaseMessage message)
{
Stream source = message.BodyPart.Data;
// build url
DotNetFileTransmitProperties props = new DotNetFileTransmitProperties(message, propertyNamespace);
string filePath = DotNetFileTransmitProperties.CreateFileName(message, props.Uri);
// Create the new file
using (FileStream fileStream = new FileStream(filePath, props.FileMode))
{
// Seek to the end of the file in case we're appending to existing data
fileStream.Seek(0, SeekOrigin.End);
source.Seek(0, SeekOrigin.Begin);
// Copy the data from the msg to the file
byte[] buffer = new byte[IO_BUFFER_SIZE];
int bytesRead;
while (0 != (bytesRead = source.Read(buffer, 0, buffer.Length)))
{
fileStream.Write(buffer, 0, bytesRead);
}
}
return(null);
}
protected override void HandlerPropertyBagLoaded()
{
IPropertyBag config = this.HandlerPropertyBag;
if (null != config)
{
XmlDocument handlerConfigDom = ConfigProperties.IfExistsExtractConfigDom(config);
if (null != handlerConfigDom)
{
DotNetFileTransmitProperties.ReadTransmitHandlerConfiguration(handlerConfigDom);
}
}
}
public ConfigProperties CreateProperties(string uri)
{
ConfigProperties properties = new DotNetFileTransmitProperties(uri);
return(properties);
}
/// <summary>
/// Used to transmit an individual message. The message stream is read into
/// a buffer and written to disc. Note, we need to process the data in a
/// streaming fashion, since the strean we receive is most likely a forward-
/// only stream we have no idea how big it is. We therefore need to process
/// it in a streaming fashion to avoid an out-of-memory (OOM) situation
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
private bool TransmitMessage(TransmitterMessage msg)
{
bool result = false;
try
{
int numBytesRead = 0;
Stream s = msg.Message.BodyPart.Data;
// build url
DotNetFileTransmitProperties props = (DotNetFileTransmitProperties)msg.Properties;
string filePath = ConfigProperties.CreateFileName(msg.Message, props.Uri);
byte[] buffer = new byte[DotNetFileTransmitProperties.BufferSize];
// If we needed to use SSO to lookup the remote system credentials we will
// need the following code.
// Additionally:
// TransmitLocation.xsd in the design-time project must also be edited to
// expose the necessary SSO properties.
// DotNetFileProperties.cs within the run-time project must be edited
// to load these properties from the XML configuration.
/*
* string ssoAffiliateApplication = props.AffiliateApplication;
* if (ssoAffiliateApplication.Length > 0)
* {
* SSOResult ssoResult = new SSOResult(msg, affiliateApplication);
* string userName = ssoResult.UserName;
* string password = ssoResult.Result[0];
* string etcEtcEtc = ssoResult.Result[1]; // (you can have additional metadata associated with the login in SSO)
*
* // use these credentials to login to the remote system
* // ideally zero off the password memory once we are done
* }
*/
// Create the new file
FileStream fs = new FileStream(filePath, props.FileMode);
// Setup the stream writter and reader
BinaryWriter w = new BinaryWriter(fs);
w.BaseStream.Seek(0, SeekOrigin.End);
if (s != null)
{
s.Seek(0, SeekOrigin.Begin);
// Copy the data from the msg to the file
int n = 0;
do
{
n = s.Read(buffer, 0, DotNetFileTransmitProperties.BufferSize);
if (n == 0) // We're at EOF
{
break;
}
w.Write(buffer, 0, n);
numBytesRead += n;
} while (n > 0);
}
w.Flush();
w.Close();
result = true;
}
catch (Exception e)
{
// If we failed, we need to set the exception on
// the message. BTS will include this exception in
// the event log message and also in HAT
msg.Message.SetErrorInfo(e);
}
return(result);
}