public string DownloadNzb(Stream nzb, string title, string category, int priority, NzbgetSettings settings)
{
var parameters = new object[] { title, category, priority, false, Convert.ToBase64String(nzb.ToBytes()) };
var request = BuildRequest(new JsonRequest("append", parameters));
var response = Json.Deserialize<NzbgetResponse<Boolean>>(ProcessRequest(request, settings));
_logger.Trace("Response: [{0}]", response.Result);
if (!response.Result)
{
return null;
}
var queue = GetQueue(settings);
var item = queue.FirstOrDefault(q => q.NzbName == title.Substring(0, title.Length - 4));
if (item == null)
{
return null;
}
var droneId = Guid.NewGuid().ToString().Replace("-", "");
var editResult = EditQueue("GroupSetParameter", 0, "drone=" + droneId, item.LastId, settings);
if (editResult)
{
_logger.Debug("Nzbget download drone parameter set to: {0}", droneId);
}
return droneId;
}
private StorageAction UpsertInternal(object key, TDoc document = default(TDoc), Stream data = null, IEnumerable <string> tags = null, bool forceInsert = false, DateTime?timestamp = null)
{
// http://www.databasejournal.com/features/mssql/using-the-merge-statement-to-perform-an-upsert.html
// http://stackoverflow.com/questions/2479488/syntax-for-single-row-merge-upsert-in-sql-server
using (var conn = CreateConnection())
{
StorageAction result;
var sql = new StringBuilder();
if (!forceInsert && Exists(key, tags))
{
result = Update(key, document, data, tags, sql);
}
else
{
result = Insert(key, document, data, tags, sql);
}
// PARAMS
var parameters = new DynamicParameters();
parameters.Add("key", key.ToString().SafeSubstring(0, 900));
parameters.Add("tags", $"||{tags.Join("||")}||".SafeSubstring(0, 900));
parameters.Add("hash", Hasher?.Compute(document).SafeSubstring(0, 900));
parameters.Add("timestamp", timestamp ?? DateTime.UtcNow);
parameters.Add("value", Serializer.ToJson(document));
parameters.Add("data", data.ToBytes().Compress(), DbType.Binary);
AddIndexParameters(document, parameters);
conn.Open();
conn.Execute(sql.ToString(), parameters);
return(result);
}
}
public IQuery Enqueue(string sourceQueueUri, TransportMessage transportMessage, Stream stream)
{
return(RawQuery.Create(@"insert into [dbo].[InspectionQueue] (SourceQueueUri, MessageId, MessageBody) values (@SourceQueueUri, @MessageId, @MessageBody)")
.AddParameterValue(InspectionQueueColumns.SourceQueueUri, sourceQueueUri)
.AddParameterValue(InspectionQueueColumns.MessageId, transportMessage.MessageId)
.AddParameterValue(InspectionQueueColumns.MessageBody, stream.ToBytes()));
}
private CryptoAlterations PerformEncryptionOrSigning(Stream data, CertInfo certificateInfo, string startingContentType)
{
var content = data.ToBytes();
var returnValue = new CryptoAlterations();
var alteredContentType = startingContentType;
if (certificateInfo.Sign)
{
content = MimeUtils.CreateMessage(alteredContentType, "binary", "", content);
var signResult = MimeUtils.Sign(content, certificateInfo.SendingCertifcatePath, certificateInfo.SendingCertPassword);
content = signResult.Item1;
alteredContentType = signResult.Item2;
returnValue.Headers.Add("EDIINT-Features", "multiple-attachments");
}
if (certificateInfo.Encrypt)
{
if (string.IsNullOrEmpty(certificateInfo.ReceiversCertificatePath))
{
throw new ArgumentNullException(certificateInfo.ReceiversCertificatePath, "if encrytionAlgorithm is specified then recipientCertFilename must be specified");
}
var signedContentTypeHeader = Encoding.ASCII.GetBytes($"Content-Type: {alteredContentType}{Environment.NewLine}");
var contentWithContentTypeHeaderAdded = MimeUtils.ConcatBytes(signedContentTypeHeader, content);
content = EncryptionUtils.Encrypt(contentWithContentTypeHeaderAdded, certificateInfo.ReceiversCertificatePath, EncryptionAlgorithm.DES3);
alteredContentType = "application/pkcs7-mime; smime-type=enveloped-data; name=\"smime.p7m\"";
}
returnValue.ContentType = alteredContentType;
returnValue.Data = new MemoryStream(content);
return(returnValue);
}
public void Enqueue(TransportMessage message, Stream stream)
{
Guard.AgainstNull(message, nameof(message));
Guard.AgainstNull(stream, nameof(stream));
_queueClient.SendMessage(Convert.ToBase64String(stream.ToBytes()));
}
private WebHeaderCollection ProcessHeaderStream(HttpRequest request, CookieContainer cookies, Stream headerStream)
{
headerStream.Position = 0;
var headerData = headerStream.ToBytes();
var headerString = Encoding.ASCII.GetString(headerData);
var webHeaderCollection = new WebHeaderCollection();
// following a redirect we could have two sets of headers, so only process the last one
foreach (var header in headerString.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Reverse())
{
if (!header.Contains(":"))
{
break;
}
webHeaderCollection.Add(header);
}
var setCookie = webHeaderCollection.Get("Set-Cookie");
if (setCookie != null && setCookie.Length > 0 && cookies != null)
{
try
{
cookies.SetCookies((Uri)request.Url, FixSetCookieHeader(setCookie));
}
catch (CookieException ex)
{
_logger.Debug("Rejected cookie {0}: {1}", ex.InnerException.Message, setCookie);
}
}
return(webHeaderCollection);
}
public void Enqueue(TransportMessage transportMessage, Stream stream)
{
Guard.AgainstNull(transportMessage, "transportMessage");
Guard.AgainstNull(stream, "stream");
if (transportMessage.HasExpired())
{
return;
}
AccessQueue(() =>
{
var model = GetChannel().Model;
var properties = model.CreateBasicProperties();
properties.Persistent = _parser.Persistent;
properties.CorrelationId = transportMessage.MessageId.ToString();
if (transportMessage.HasExpiryDate())
{
var milliseconds = (long)(transportMessage.ExpiryDate - DateTime.Now).TotalMilliseconds;
if (milliseconds < 1)
{
return;
}
properties.Expiration = milliseconds.ToString();
}
model.BasicPublish("", _parser.Queue, false, properties, stream.ToBytes());
});
}
/// <summary>
/// 保存文件
/// </summary>
/// <param name="stream"></param>
/// <param name="path"></param>
/// <returns></returns>
public static ReResult SaveFile(Stream stream, List <string> path, string filename, string genpath, string user = "******")
{
try
{
var rex = new Record();
var time = DateTime.Now.ToString("yyyy-MM-dd");
var filenames = filename.Split(".")?.ToList() ?? new List <string>();
var filename1 = filenames[0] + DateTime.Now.ToString("yyyyMMddHmmss") + "." + filenames[1];
var fielpath = genpath + $@"\upload\{string.Join(@"\", path)}\{time}\{filename1}";
var type = Path.GetExtension(filename);
var url = Configs.webpath + $"/upload/{string.Join("/", path)}/{time}/{filename1}";
var getPath = Path.GetDirectoryName(fielpath);
if (!Directory.Exists(getPath))
{
Directory.CreateDirectory(getPath);
}
var arry = stream.ToBytes();
var size = 0;
using (FileStream fs = new FileStream(fielpath, FileMode.Create))
{
fs.Write(arry, 0, arry.Length);
size = (int)Math.Ceiling(fs.Length / 1024.0);
fs.Close();
stream.Close();
}
rex.Put("filename", filename).Put("filepath", fielpath).Put("webfilepath", url).Put("filesize", size).Put("filetype", type)
.Put("id", Guid.NewGuid().ToString().Replace("-", "")).Put("create_time", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")).Put("status", "0").Put("create_user", user);
return(new ReResult().setData(rex));
}
catch (IOException e)
{
return(new ReResult(400, e.Message));
}
}
/// <summary>
/// 文件对比是不是同一个文件
/// </summary>
/// <param name="filePath1"></param>
/// <param name="filePath2"></param>
/// <returns></returns>
public static bool CompareFile(this Stream stream_1, string filePath2)
{
try
{
if (stream_1.IsBlank() || stream_1.Length == 0 || filePath2.IsBlank())
{
return(false);
}
// 使用.NET内置的MD5库
using (var md5 = MD5.Create())
{
byte[] one = md5.ComputeHash(stream_1.ToBytes()), two;
using (var fs2 = File.Open(filePath2, FileMode.Open))
{
// 以FileStream读取文件内容,计算HASH值
two = md5.ComputeHash(fs2);
}
// 将MD5结果(字节数组)转换成字符串进行比较
return(BitConverter.ToString(one) == BitConverter.ToString(two));
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Uploads a file to Fortnox Archive from provided data stream.
/// </summary>
/// <returns>Created file.</returns>
public File UploadFileData(Stream stream, string name, string folderId = "")
{
stream.Position = 0;
var arr = stream.ToBytes();
return(UploadFileData(arr, name, folderId));
}
/// <summary>
///
/// </summary>
/// <param name="requestStream"></param>
/// <param name="productName"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public static Stream ExecuteStreamInternal(Stream requestStream, string productName, ISerializer serializer)
{
XdsResponseDocument xdsResponse = null;
MemoryStream result = null;
try {
Guard.Assert(requestStream != null && requestStream.Length > 0, "요청 정보가 없습니다.");
CheckProductExists(productName);
var xdsRequest = (XdsRequestDocument)serializer.Deserialize(requestStream.ToBytes());
xdsResponse = XmlDataServiceFacade.Execute(xdsRequest, productName);
}
catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.ErrorException("예외가 발생했습니다.", ex);
}
if (xdsResponse == null)
{
xdsResponse = new XdsResponseDocument();
}
xdsResponse.ReportError(ex);
}
finally {
result = new MemoryStream(serializer.Serialize(xdsResponse));
}
return(result);
}
/// <summary>
/// POST 방식으로 서버에 접속하여 응답 Stream을 반환 받는다.
/// </summary>
/// <param name="stream">서버에 전달할 내용</param>
/// <returns></returns>
protected virtual Stream PostStream(Stream stream)
{
stream.ShouldNotBeNull("stream");
if (IsDebugEnabled)
{
log.Debug("지정된 스트림을 전송합니다.");
}
Request.Credentials = GetCredentials();
Request.Method = WebRequestMethods.Http.Post;
Request.ContentType = POST_CONTENT_TYPE;
if (stream == null)
{
Request.ContentLength = 0;
}
if (stream != null)
{
byte[] payload = stream.ToBytes();
using (var requestStream = Request.GetRequestStream())
using (var bw = new BinaryWriter(requestStream, XmlTool.XmlEncoding)) {
bw.Write(payload);
}
}
return(IsAsync
? With.TryFunctionAsync(() => Request.GetResponseStreamAsync().Result)
: Request.GetResponse().GetResponseStream());
}
/// <summary>
/// StreamToFile
/// </summary>
/// <param name="stream"></param>
/// <param name="filePath"></param>
/// <returns></returns>
public static void ToFile(this Stream stream, string filePath)
{
// 把 Stream 转换成 byte[]
byte[] bytes = stream.ToBytes();
//有一种更简捷的方法把 byte[]写入文件：system.io.file.WriteAllBytes(string path,bytes)
System.IO.File.WriteAllBytes(filePath, bytes);
}
public async Task SaveBlob(string container, string key, Stream bloblStream)
{
await Task.Run(() =>
{
lock (_lockObject)
GetBlob(container).AddOrReplace(key, new MemoryStream(bloblStream.ToBytes()));
});
}
public byte[] ConvertImageToJpg(Stream originalImage)
{
if (Image.DetectFormat(originalImage) == ImageFormats.Jpeg)
{
return(originalImage.ToBytes());
}
return(this.ConvertImageToJpg(this.LoadImageFromStream(originalImage)));
}
private static readonly SKPaint Paint = new SKPaint(); // Reuse for performance. Only for opacity
public static BitmapInfo LoadBitmap(Stream bitmapStream)
{
bitmapStream.Position = 0;
var image = SKImage.FromEncodedData(SKData.CreateCopy(bitmapStream.ToBytes()));
return(new BitmapInfo {
Bitmap = image
});
}
public void SendFrameStream(Stream stream)
{
Guard.AgainstNull(stream, nameof(stream));
_responseSocket.SendFrame(stream.ToBytes());
_stream.Dispose();
_stream = null;
}
/// <summary>
/// 원본 스트림을 압축하여, 대상 스트림에 씁니다.
/// </summary>
/// <param name="sourceStream"></param>
/// <param name="destinationStream"></param>
public virtual void CompressAsync(Stream sourceStream, Stream destinationStream)
{
sourceStream.ShouldNotBeNull("sourceStream");
destinationStream.ShouldNotBeNull("destinationStream");
var compressedBytes = Compress(sourceStream.ToBytes());
destinationStream.WriteAsync(compressedBytes, 0, compressedBytes.Length);
}
/// <summary>
/// 将 Stream 写入文件
/// </summary>
public static void ToFile(this Stream stream, string 文件路径及名称)
{
FileStream fs = new FileStream(文件路径及名称, FileMode.Create);
BinaryWriter bw = new BinaryWriter(fs);
bw.Write(stream.ToBytes());
bw.Close();
fs.Close();
}
/// <summary>
/// Extracts the resource at the given namespace path and returns it as a byte array
/// </summary>
public static byte[] GetBytes(string resourcePath)
{
if (EntryAssembly == null)
{
EntryAssembly = Assembly.GetEntryAssembly();
}
using (Stream stream = EntryAssembly.GetManifestResourceStream(resourcePath)) {
return(stream.ToBytes());
}
}
public void Enqueue(TransportMessage transportMessage, Stream stream)
{
using (_databaseContextFactory.Create(_connectionName))
{
_databaseGateway.ExecuteUsing(
RawQuery.Create(_enqueueQueryStatement)
.AddParameterValue(QueueColumns.MessageId, transportMessage.MessageId)
.AddParameterValue(QueueColumns.MessageBody, stream.ToBytes()));
}
}
public Stream Decompress(Stream stream)
{
var comp = stream.ToBytes();
UInt32 decompressedSize = (uint)(comp[4] << 24 | comp[5] << 16 | comp[6] << 8 | comp[7]);
var data = Decompress(comp);
// var data = EveryFileExplorer.YAZ0.Decompress(comp);
// System.IO.File.WriteAllBytes("testYaz0.dec", data);
return(new MemoryStream(data));
}
/// <summary>
/// 원본 스트림을 압축 해제하여, 대상 스트림에 씁니다.
/// </summary>
/// <param name="sourceStream"></param>
/// <param name="targetStream"></param>
public virtual void DecompressAsync(Stream sourceStream, Stream targetStream)
{
sourceStream.ShouldNotBeNull("sourceStream");
targetStream.ShouldNotBeNull("destinationStream");
var decompresedBytes = Decompress(sourceStream.ToBytes());
targetStream.WriteAsync(decompresedBytes, 0, decompresedBytes.Length);
targetStream.SetStreamPosition();
}
public void Enqueue(TransportMessage message, Stream stream)
{
Guard.AgainstNull(message, nameof(message));
Guard.AgainstNull(stream, nameof(stream));
lock (_lock)
{
_queue.Enqueue(new QueueMessage(stream.ToBytes()));
}
}
/// <summary>
/// Read bytes from TImage based on File System
/// </summary>
/// <param name="tImage">TImage</param>
/// <param name="fs">Umbraco file system (default or Azure)</param>
/// <returns></returns>
public static byte[] ToBytes(this TImage tImage, IFileSystem fs)
{
byte[] data;
string path = fs.GetRelativePath(tImage.AbsoluteUrl);
using (Stream fileStream = fs.OpenFile(path))
{
data = fileStream.ToBytes();
}
return(data);
}
public void AddDeferredMessage(TransportMessage processingTransportMessage, Stream deferredTransportMessageStream)
{
using (_databaseConnectionFactory.Create(IdempotenceDataSource))
{
_databaseGateway.ExecuteUsing(
IdempotenceDataSource,
RawQuery.Create(_scriptProvider.GetScript(Script.IdempotenceSendDeferredMessage))
.AddParameterValue(IdempotenceColumns.MessageId, processingTransportMessage.MessageId)
.AddParameterValue(IdempotenceColumns.MessageBody, deferredTransportMessageStream.ToBytes()));
}
}
public static byte[] ToBytesOrNull(this Stream stream)
{
if (stream == null)
{
return(null);
}
else
{
return(stream.ToBytes());
}
}
public static string ToStringEx(this Stream str)
{
try
{
return(str.ToBytes().ToString());
}
catch
{
return(string.Empty);
}
}
public void Enqueue(TransportMessage message, Stream stream)
{
Guard.AgainstNull(message, nameof(message));
Guard.AgainstNull(stream, nameof(stream));
NetMQException.GuardAgainstException <Response, EnqueueRequest>(_requestClient.GetResponse <Response>(new EnqueueRequest
{
TransportMessage = message,
StreamBytes = stream.ToBytes()
}, _uriParser.QueueName));
}
private static X509Certificate2 GetEmbededPublicCertificate()
{
byte[] rawData = null;
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("MCS.Library.Cloud.W3.Resources." +
W3Settings.GetSettings().GetSelectedIssuer().PublicCA))
{
rawData = stream.ToBytes();
}
return(new X509Certificate2(rawData));
}
public void Enqueue(TransportMessage message, Stream stream)
{
Guard.AgainstNull(message, nameof(message));
Guard.AgainstNull(stream, nameof(stream));
GuardAgainstUnresolvedQueueUrl();
_client.SendMessageAsync(new SendMessageRequest
{
QueueUrl = _queueUrl,
MessageBody = Convert.ToBase64String(stream.ToBytes())
}).Wait();
}
public void AddDeferredMessage(TransportMessage processingTransportMessage,
TransportMessage deferredTransportMessage,
Stream deferredTransportMessageStream)
{
using (_databaseContextFactory.Create(SqlServerConfiguration.ProviderName, _idempotenceConnectionString))
{
_databaseGateway.ExecuteUsing(
RawQuery.Create(_scriptProvider.GetScript(Script.IdempotenceSendDeferredMessage))
.AddParameterValue(IdempotenceColumns.MessageId, deferredTransportMessage.MessageId)
.AddParameterValue(IdempotenceColumns.MessageIdReceived, processingTransportMessage.MessageId)
.AddParameterValue(IdempotenceColumns.MessageBody, deferredTransportMessageStream.ToBytes()));
}
}
public SabnzbdAddResponse DownloadNzb(Stream nzb, string title, string category, int priority, SabnzbdSettings settings)
{
var request = new RestRequest(Method.POST);
var action = String.Format("mode=addfile&cat={0}&priority={1}", category, priority);
request.AddFile("name", nzb.ToBytes(), title, "application/x-nzb");
SabnzbdAddResponse response;
if (!Json.TryDeserialize<SabnzbdAddResponse>(ProcessRequest(request, action, settings), out response))
{
response = new SabnzbdAddResponse();
response.Status = true;
}
return response;
}
public Task SaveBlobAsync(string container, string key, Stream bloblStream)
{
return PostHttpReqest(container, key, bloblStream.ToBytes());
}
/// <summary>
/// 원본 스트림을 압축 해제하여, 대상 스트림에 씁니다.
/// </summary>
/// <param name="sourceStream"></param>
/// <param name="targetStream"></param>
public virtual void DecompressAsync(Stream sourceStream, Stream targetStream) {
sourceStream.ShouldNotBeNull("sourceStream");
targetStream.ShouldNotBeNull("destinationStream");
var decompresedBytes = Decompress(sourceStream.ToBytes());
targetStream.WriteAsync(decompresedBytes, 0, decompresedBytes.Length);
targetStream.SetStreamPosition();
}
/// <summary>
/// 지정된 스트림을 압축합니다.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public virtual byte[] Compress(Stream input) {
input.ShouldNotBeNull("input");
return Compress(input.ToBytes());
}
private WebHeaderCollection ProcessHeaderStream(HttpRequest request, CookieContainer cookies, Stream headerStream)
{
headerStream.Position = 0;
var headerData = headerStream.ToBytes();
var headerString = Encoding.ASCII.GetString(headerData);
var webHeaderCollection = new WebHeaderCollection();
// following a redirect we could have two sets of headers, so only process the last one
foreach (var header in headerString.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Reverse())
{
if (!header.Contains(":")) break;
webHeaderCollection.Add(header);
}
var setCookie = webHeaderCollection.Get("Set-Cookie");
if (setCookie != null && setCookie.Length > 0 && cookies != null)
{
try
{
cookies.SetCookies((Uri)request.Url, FixSetCookieHeader(setCookie));
}
catch (CookieException ex)
{
_logger.Debug("Rejected cookie {0}: {1}", ex.InnerException.Message, setCookie);
}
}
return webHeaderCollection;
}
/// <summary>
/// 원본 스트림을 압축하여, 대상 스트림에 씁니다.
/// </summary>
/// <param name="sourceStream"></param>
/// <param name="destinationStream"></param>
public virtual void CompressAsync(Stream sourceStream, Stream destinationStream) {
sourceStream.ShouldNotBeNull("sourceStream");
destinationStream.ShouldNotBeNull("destinationStream");
var compressedBytes = Compress(sourceStream.ToBytes());
destinationStream.WriteAsync(compressedBytes, 0, compressedBytes.Length);
}
public void Enqueue(Guid messageId, Stream stream)
{
try
{
using (_databaseConnectionFactory.Create(_dataSource))
{
_databaseGateway.ExecuteUsing(
_dataSource,
RawQuery.Create(_enqueueQueryStatement)
.AddParameterValue(QueueColumns.MessageId, messageId)
.AddParameterValue(QueueColumns.MessageBody, stream.ToBytes()));
}
}
catch (Exception ex)
{
_log.Error(
string.Format(SqlResources.EnqueueError, messageId, Uri, ex.Message));
throw;
}
}
private WebHeaderCollection ProcessHeaderStream(HttpWebRequest webRequest, Stream headerStream)
{
headerStream.Position = 0;
var headerData = headerStream.ToBytes();
var headerString = Encoding.ASCII.GetString(headerData);
var webHeaderCollection = new WebHeaderCollection();
foreach (var header in headerString.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Skip(1))
{
webHeaderCollection.Add(header);
}
var setCookie = webHeaderCollection.Get("Set-Cookie");
if (setCookie != null && setCookie.Length > 0 && webRequest.CookieContainer != null)
{
webRequest.CookieContainer.SetCookies(webRequest.RequestUri, setCookie);
}
return webHeaderCollection;
}
public static Stream Decompress(Stream input) {
return new MemoryStream(Decompress(input.ToBytes()));
}
public override void Store(Stream stream, FileSystemObject fso)
{
SaveToMap(stream.ToBytes(), fso);
}
/// <summary>
/// POST 방식으로 서버에 접속하여 응답 Stream을 반환 받는다.
/// </summary>
/// <param name="stream">서버에 전달할 내용</param>
/// <returns></returns>
protected virtual Stream PostStream(Stream stream) {
stream.ShouldNotBeNull("stream");
if(IsDebugEnabled)
log.Debug("지정된 스트림을 전송합니다.");
Request.Credentials = GetCredentials();
Request.Method = WebRequestMethods.Http.Post;
Request.ContentType = POST_CONTENT_TYPE;
if(stream == null) {
Request.ContentLength = 0;
}
if(stream != null) {
byte[] payload = stream.ToBytes();
using(var requestStream = Request.GetRequestStream())
using(var bw = new BinaryWriter(requestStream, XmlTool.XmlEncoding)) {
bw.Write(payload);
}
}
return IsAsync
? With.TryFunctionAsync(() => Request.GetResponseStreamAsync().Result)
: Request.GetResponse().GetResponseStream();
}
public void Enqueue(Guid messageId, Stream stream)
{
try
{
using (databaseConnectionFactory.Create(dataSource))
{
databaseGateway.ExecuteUsing(
dataSource,
RawQuery.CreateFrom(enqueueQueryStatement)
.AddParameterValue(QueueColumns.MessageId, messageId)
.AddParameterValue(QueueColumns.MessageBody, stream.ToBytes()));
}
}
catch (Exception ex)
{
log.Debug(
string.Format(
"Could not enqueue message id '{0}' on queue '{1}'. Exception: {2}", messageId, Uri, ex.Message));
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="requestStream"></param>
/// <param name="productName"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public static Stream ExecuteStreamInternal(Stream requestStream, string productName, ISerializer serializer) {
XdsResponseDocument xdsResponse = null;
MemoryStream result = null;
try {
Guard.Assert(requestStream != null && requestStream.Length > 0, "요청 정보가 없습니다.");
CheckProductExists(productName);
var xdsRequest = (XdsRequestDocument)serializer.Deserialize(requestStream.ToBytes());
xdsResponse = XmlDataServiceFacade.Execute(xdsRequest, productName);
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("예외가 발생했습니다.", ex);
if(xdsResponse == null)
xdsResponse = new XdsResponseDocument();
xdsResponse.ReportError(ex);
}
finally {
result = new MemoryStream(serializer.Serialize(xdsResponse));
}
return result;
}
