public static MongoGridFSFileInfo UploadFile(this IMongoRepository repository, string remoteFilename, Stream stream,
MongoGridFSCreateOptions createOptions) {
stream.ShouldNotBeNull("stream");
remoteFilename.ShouldNotBeWhiteSpace("remoteFilename");
return repository.GridFS.Upload(stream, remoteFilename, createOptions);
}
/// <summary>
/// 주어진 Stream 내용을 지정된 인코딩 방식으로 문자열로 변환한다.
/// </summary>
/// <param name="stream"></param>
/// <param name="enc"></param>
/// <returns></returns>
public static string ToString(this Stream stream, Encoding enc)
{
stream.ShouldNotBeNull("stream");
using (var sr = new StreamReader(stream, enc))
return(sr.ReadToEnd().TrimEnd('\0'));
}
/// <summary>
/// FTP 서버에 있는 원격 파일을 다운로드하여, <paramref name="localStream"/>에 씁니다.
/// </summary>
/// <param name="ftpClient"></param>
/// <param name="remoteFilename"></param>
/// <param name="localStream"></param>
/// <returns></returns>
public static Task <bool> DownloadTask(this FtpClient ftpClient, string remoteFilename, Stream localStream)
{
localStream.ShouldNotBeNull("localStream");
if (IsDebugEnabled)
{
log.Debug("원격 파일을 다운로드 받는 작업을 생성합니다... remoteFilename=[{0}]", remoteFilename);
}
remoteFilename = ftpClient.AdjustRemoteFilename(remoteFilename);
var uri = ftpClient.Hostname + remoteFilename;
return
(ftpClient
.GetResponseStreamTask(uri, WebRequestMethods.Ftp.DownloadFile)
.ContinueWith(task => {
task.Result.CopyStreamToStream(localStream);
task.Result.Close();
if (IsDebugEnabled)
{
log.Debug("원격 파일 다운로드가 완료되었습니다. remoteFilename=[{0}]", remoteFilename);
}
return true;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// 생성자
/// </summary>
/// <param name="writableTargetStream">실제 Data가 쓰일 대상 Stream</param>
public TransferStream(Stream writableTargetStream)
{
writableTargetStream.ShouldNotBeNull("writableTargetStream");
Guard.Assert(writableTargetStream.CanWrite, "Target stream is not writable.");
_writableTargetStream = writableTargetStream;
_chunks = new BlockingCollection <byte[]>();
// _chunks 에 입력이 들어올 때까지 기다렸다가, 대상 Stream에 쓰는 Background 작업을 정의합니다.
_processingTask =
Task.Factory.StartNew(() => {
if (IsDebugEnabled)
{
log.Debug("스트림 정보 복사를 시작합니다...");
}
foreach (var chunk in _chunks.GetConsumingEnumerable())
{
_writableTargetStream.Write(chunk, 0, chunk.Length);
}
if (IsDebugEnabled)
{
log.Debug("스트림 정보 복사를 완료되었습니다!!!");
}
});
}
/// <summary>
/// 지정한 데이터를 압축하여, <paramref name="destinationStream"/> 에 저장합니다.
/// </summary>
/// <param name="input"></param>
/// <param name="destinationStream"></param>
public virtual void Decompress(byte[] input, Stream destinationStream) {
input.ShouldNotBeNull("input");
destinationStream.ShouldNotBeNull("destinationStream");
var decompressedBytes = Decompress(input);
destinationStream.Write(decompressedBytes, 0, decompressedBytes.Length);
}
public static void DownloadFile(this IMongoRepository repository, Stream stream, MongoGridFSFileInfo fileInfo)
{
stream.ShouldNotBeNull("stream");
fileInfo.ShouldNotBeNull("fileinfo");
repository.GridFS.Download(stream, fileInfo);
}
/// <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>
/// 주어진 객체를 Xml 직렬화하여 Stream 객체에 쓴다.
/// </summary>
/// <param name="target">직렬화할 개체</param>
/// <param name="enc">인코딩 방식</param>
/// <param name="useIndent">들여쓰기를 이용한 포맷 사용여부</param>
/// <param name="outStream">직렬화한 정보가 담길 stream</param>
/// <exception cref="ArgumentNullException">target이 null이거나 stream이 null인 경우</exception>
public static void Serialize(object target, Stream outStream, Encoding enc, bool useIndent)
{
target.ShouldNotBeNull("target");
outStream.ShouldNotBeNull("outStream");
if (IsDebugEnabled)
{
log.Debug("Xml 직렬화를 시작합니다... target=[{0}], encoding=[{1}], useIndent=[{2}]", target.GetType(), enc, useIndent);
}
try {
var settings = new XmlWriterSettings
{
Encoding = enc,
Indent = useIndent
};
var writer = XmlWriter.Create(outStream, settings);
var serializer = new XmlSerializer(target.GetType());
lock (target) {
serializer.Serialize(writer, target);
writer.Flush();
}
writer.Close();
}
catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.Error("직렬화에 실패했습니다!!! target=[{0}]", target);
log.Error(ex);
}
throw;
}
}
/// <summary>
/// 지정된 스트림을 Html 형식으로 Encoding한다.
/// </summary>
/// <param name="stream">스트림</param>
/// <returns>인코딩된 문자열</returns>
public static string HtmlEncode(Stream stream) {
stream.ShouldNotBeNull("stream");
return HtmlEncode(stream.ToText());
// return HtmlEncode(StringTool.ToString(stream));
}
public static void DownloadFile(this IMongoRepository repository, Stream stream, string remoteFilename, int version)
{
stream.ShouldNotBeNull("stream");
remoteFilename.ShouldNotBeWhiteSpace("remoteFilename");
repository.GridFS.Download(stream, remoteFilename, version);
}
/// <summary>
/// <paramref name="stream"/> 정보를 읽어서 XmlDocument 인스턴스를 생성한다.
/// </summary>
/// <param name="stream">원본 Stream 객체</param>
public XmlDoc(Stream stream)
{
stream.ShouldNotBeNull("strem");
stream.SetStreamPosition();
Load(stream);
}
/// <summary>
/// <paramref name="ftpClient"/>를 이용하여, 로컬 파일 스트림을 FTP 서버로 Upload 합니다.
/// </summary>
/// <param name="ftpClient"></param>
/// <param name="localStream"></param>
/// <param name="remoteFilename"></param>
/// <returns></returns>
public static Task <bool> UploadTask(this FtpClient ftpClient, Stream localStream, string remoteFilename)
{
if (IsDebugEnabled)
{
log.Debug("FTP 서버로 스트림을 비동기 방식으로 업로드합니다... RemoteFile=[{0}]", remoteFilename);
}
localStream.ShouldNotBeNull("localStream");
remoteFilename = ftpClient.AdjustRemoteFilename(remoteFilename);
var uri = ftpClient.Hostname + remoteFilename;
return
(GetRequestStreamTask(ftpClient, uri, WebRequestMethods.Ftp.UploadFile)
.ContinueWith(task => {
localStream.CopyStreamToStream(task.Result);
task.Result.Close();
if (IsDebugEnabled)
{
log.Debug("FTP 서버로 파일을 업로드를 완료했습니다. RemoteFile=[{0}]", remoteFilename);
}
return true;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// <paramref name="stream"/> 내용을 읽어 문자열로 반환합니다.
/// </summary>
/// <param name="stream">읽을 스트림</param>
/// <returns></returns>
public static string ToString(Stream stream)
{
stream.ShouldNotBeNull("stream");
using (var reader = new StreamReader(stream))
return(reader.ReadToEnd().TrimEnd('\0'));
}
/// <summary>
/// 저장소에 저장한다.<br/>
/// overwrite:false 인 경우 동일한 파일명이 있는경우 새로운 파일명으로 저장후 파일명을 반환합니다.
/// </summary>
/// <param name="stream">저장할 Stream</param>
/// <param name="destFile">대상 파일경로</param>
/// <param name="overwrite">덮어쓰기 여부</param>
/// <returns>저장된 파일명</returns>
public override Task <string> SaveAs(Stream stream, string destFile, bool overwrite)
{
if (IsDebugEnabled)
{
log.Debug("==>S stream={0}, destFile={1}, overwrite={2}", stream, destFile, overwrite);
}
stream.ShouldNotBeNull("저장할 파일정보가 없습니다.");
destFile.ShouldNotBeWhiteSpace("저장할 대상파일정보가 없습니다.");
var destFilePath = destFile;
var task = Task.Factory.StartNew(() =>
{
var path = GetDestFile(destFilePath, overwrite);
FileTool.Save(path, stream, overwrite);
return(path);
}).ContinueWith((antecedent) => antecedent.Result);
task.Wait();
destFile = task.Result;
if (IsDebugEnabled)
{
log.Debug("==>>E destFile={0}", destFile);
}
//return destFile;
return(task);
}
/// <summary>
/// <paramref name="stream"/>을 읽어, <paramref name="filepath"/>의 파일에 저장합니다.
/// 해당 파일이 존재하면 겹쳐 쓰거나 추가를 할 수 있습니다. 파일이 없으면 새로 생성합니다.
/// </summary>
/// <param name="filepath">대상 파일 경로</param>
/// <param name="stream">저장할 내용</param>
/// <param name="overwrite">겹쳐쓰기 여부</param>
public static void Save(string filepath, Stream stream, bool overwrite)
{
filepath.ShouldNotBeWhiteSpace("filepath");
stream.ShouldNotBeNull("stream");
if (IsDebugEnabled)
{
log.Debug("스트림 내용을 파일에 저장합니다... filepath=[{0}], overwrite=[{1}]", filepath, overwrite);
}
stream.SetStreamPosition(0);
if (overwrite && FileExists(filepath))
{
if (IsDebugEnabled)
{
log.Debug("기존 파일이 존재하고, 겹쳐쓰기를 해야 하므로, 기존 파일을 삭제합니다. filepath=[{0}]", filepath);
}
DeleteFile(filepath);
}
//using(var fs = File.Open(filepath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
//using(var bs = new BufferedStream(fs))
using (var bs = GetBufferedFileStream(filepath, FileOpenMode.ReadWrite)) {
var buffer = new byte[DEFAULT_BUFFER_SIZE];
int readCount;
while ((readCount = stream.Read(buffer, 0, DEFAULT_BUFFER_SIZE)) > 0)
{
bs.Write(buffer, 0, readCount);
}
bs.Flush();
}
}
public static MongoGridFSFileInfo UploadFile(this IMongoRepository repository, string remoteFilename, Stream stream)
{
stream.ShouldNotBeNull("stream");
remoteFilename.ShouldNotBeWhiteSpace("remoteFilename");
return(repository.GridFS.Upload(stream, remoteFilename));
}
/// <summary>
/// 지정된 스트림을 Html 형식으로 Encoding한다.
/// </summary>
/// <param name="stream">스트림</param>
/// <returns>인코딩된 문자열</returns>
public static string HtmlEncode(Stream stream)
{
stream.ShouldNotBeNull("stream");
return(HtmlEncode(stream.ToText()));
// return HtmlEncode(StringTool.ToString(stream));
}
/// <summary>
/// 지정된 스트림을 Html 형식으로 Encoding 한다.
/// </summary>
/// <param name="s"></param>
/// <param name="output">인코딩된 문자가 담긴 stream</param>
public static void HtmlEncode(string s, Stream output)
{
output.ShouldNotBeNull("output");
using (var writer = new StreamWriter(output)) {
HttpUtility.HtmlEncode(s, writer);
writer.Flush();
}
}
/// <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>
/// 지정한 데이터를 압축하여, <paramref name="destinationStream"/> 에 저장합니다.
/// </summary>
/// <param name="input"></param>
/// <param name="destinationStream"></param>
public virtual void Decompress(byte[] input, Stream destinationStream)
{
input.ShouldNotBeNull("input");
destinationStream.ShouldNotBeNull("destinationStream");
var decompressedBytes = Decompress(input);
destinationStream.Write(decompressedBytes, 0, decompressedBytes.Length);
}
/// <summary>
/// 주어진 Stream 내용을 지정된 인코딩 방식으로 문자열로 변환한다.
/// </summary>
/// <param name="stream">문자열로 바꿀 스트림</param>
/// <param name="enc">인코딩 방식</param>
/// <returns>변환된 문자열</returns>
public static string ToText(this Stream stream, Encoding enc)
{
stream.ShouldNotBeNull("stream");
enc.ShouldNotBeNull("enc");
stream.SetStreamPosition();
var reader = new StreamReader(stream, enc);
return(reader.ReadToEnd().TrimEnd(NullTerminatorChar));
}
/// <summary>
/// <paramref name="stream"/> 내용을 읽어 문자열로 반환합니다.
/// </summary>
/// <param name="stream">문자열로 바꿀 스트림</param>
/// <returns>변환된 문자열</returns>
public static string ToText(this Stream stream)
{
stream.ShouldNotBeNull("stream");
// reader 를 닫으면, stream 도 닫혀서 후속 작업에서는 사용하지 못합니다.
//
var reader = new StreamReader(stream);
return(reader.ReadToEnd().TrimEnd(NullTerminatorChar));
}
/// <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>
/// 지정한 <paramref name="stream"/>을 비동기적으로 압축복원하는 Task를 빌드합니다.
/// </summary>
/// <param name="compressor">Compressor</param>
/// <param name="stream">압축 해제할 스트림</param>
/// <returns>압축해제된 스트림을 결과로 제공하는 <see cref="Task{Stream}"/></returns>
public static Task <Stream> DecompressTask(this ICompressor compressor, Stream stream)
{
compressor.ShouldNotBeNull("compressor");
stream.ShouldNotBeNull("stream");
// GZipStream, DeflateStream의 비동기 함수인 BeginRead, BeginWrite 등은 실제로는 StreamExtensions 에서 처리해주고,
// 메모리에 다 올라온 byte[]에 대해서 Computed-bound 비동기 방식으로 압축 해제를 수행한다.
return
(stream.ReadAllBytesAsync()
.ContinueWith <Stream>(antecedent => new MemoryStream(compressor.DecompressTask(antecedent.Result).Result),
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// <paramref name="stream"/> 의 현재 위치부터 끝까지 읽어서 바이트배열로 변환합니다.
/// </summary>
/// <param name="stream">읽을 스트림</param>
/// <returns></returns>
public static byte[] ReadAllBytes(this Stream stream)
{
stream.ShouldNotBeNull("stream");
if (IsDebugEnabled)
{
log.Debug("스트림의 현재 위치서부터 끝까지 모두 읽어 바이트 배열로 반환합니다...");
}
byte[] buffer = new byte[stream.Length - stream.Position];
stream.Read(buffer, (int)stream.Position, buffer.Length);
return(buffer);
}
private static IEnumerable <Task> CopyStreamIterator(Stream input, Stream output)
{
input.ShouldNotBeNull("input");
output.ShouldNotBeNull("output");
if (IsDebugEnabled)
{
log.Debug("입출력 스트림 간의 데이타 복사를 수행하는 Task의 열거자를 생성합니다...");
}
// 두개의 버퍼를 만든다.
// 하나는 읽기 전용, 하나는 쓰기 전용. 계속해서 두개의 버퍼 내용을 스위칭하여 사용한다.
//
var buffers = new[] { new byte[BufferSize], new byte[BufferSize] };
var filledBufferNo = 0;
Task writeTask = null;
while (true)
{
// 비동기 stream 읽기 작업
var readTask = input.ReadAsync(buffers[filledBufferNo], 0, buffers[filledBufferNo].Length);
if (writeTask == null)
{
yield return(readTask);
// Wait() 호출은 Task 작업 중에 예외발생 시, 예외를 전파시키기 위해서이다.
readTask.Wait();
}
else
{
var tasks = new[] { readTask, writeTask };
yield return(Task.Factory.WhenAll(tasks));
// Wait() 호출은 Task 작업 중에 예외발생시, 예외를 전파시키기 위해서이다.
Task.WaitAll(tasks);
}
// 더 이상 읽을 데이타가 없다면 중지한다.
if (readTask.Result <= 0)
{
break;
}
// 읽어들인 버퍼 내용을 output stream에 비동기적으로 씁니다.
writeTask = output.WriteAsync(buffers[filledBufferNo], 0, readTask.Result);
// Swap buffers
filledBufferNo ^= 1;
}
}
/// <summary>
/// Serialize specified <paramref name="graph"/> with specified <paramref name="formatter"/>, then save to stream.
/// </summary>
/// <param name="graph">serializing target object.</param>
/// <param name="stream">where put serialization data.</param>
/// <param name="formatter">serialization format</param>
public static void Serialize(object graph, Stream stream, IFormatter formatter)
{
if (graph == null)
{
return;
}
stream.ShouldNotBeNull("stream");
formatter.ShouldNotBeNull("formatter");
lock (stream) {
formatter.Serialize(stream, graph);
}
}
/// <summary>
/// 지정된 Stream을 읽어서 Xml Deserialize를 수행한다.
/// </summary>
/// <param name="targetType">역직렬화해서 만들 객체의 수형</param>
/// <param name="stream">직렬화 정보를 가진 Stream</param>
/// <param name="enc">XML 인코딩 방식</param>
/// <returns>역직렬화된 객체</returns>
public static object Deserialize(Type targetType, Stream stream, Encoding enc)
{
stream.ShouldNotBeNull("stream");
if (IsDebugEnabled)
{
log.Debug("Deserialize stream... stream=[{0}], enc=[{1}]", stream, enc);
}
stream.SetStreamPosition(0);
var serializer = new XmlSerializer(targetType);
return(serializer.Deserialize(new StreamReader(stream)));
}
/// <summary>
/// <paramref name="stream"/> 내용의 일부분을 읽어 문자열로 반환합니다.
/// </summary>
/// <param name="stream"></param>
/// <param name="length"></param>
/// <returns></returns>
public static string ToText(this Stream stream, int length)
{
stream.ShouldNotBeNull("stream");
var buffer = new char[length];
var reader = new StreamReader(stream);
reader.Read(buffer, 0, length);
#if !SILVERLIGHT
return(ToTextUnsafe(buffer));
#else
return(new string(buffer));
#endif
}
// ** NOTE: Referece to a nice SO answer about FTP uploading: http://stackoverflow.com/a/25016741/30674
/// <summary>
/// Uploads some simple string data to an Ftp Server.
/// </summary>
/// <param name="inputStream">A stream of the content to upload.</param>
/// <param name="fileName">The destination filename.</param>
/// <returns>A Task representing the asynchronous operation.</returns>
public async Task UploadAsync(Stream inputStream,
string fileName)
{
_loggingService.Verbose("UploadAsync");
inputStream.ShouldNotBeNull();
fileName.ShouldNotBeNullOrEmpty();
var destinationUri = GenerateDestinationUri(fileName);
_loggingService.Debug($"Ftp Uploading string data -> destination: {destinationUri.AbsoluteUri}. Data size: {inputStream.Length}.");
var ftpWebRequest = (FtpWebRequest)WebRequest.Create(destinationUri);
ftpWebRequest.Method = WebRequestMethods.Ftp.UploadFile; // This is the classic 'STOR' command.
ftpWebRequest.Credentials = _networkCredential;
ftpWebRequest.UsePassive = UsePasive;
ftpWebRequest.EnableSsl = EnableSsl;
ftpWebRequest.KeepAlive = KeepAlive;
ftpWebRequest.UseBinary = UseBinary;
if (Proxy != null)
{
ftpWebRequest.Proxy = Proxy;
}
if (Timeout.HasValue)
{
ftpWebRequest.Timeout = Timeout.Value;
}
var stopwatch = Stopwatch.StartNew();
// Now start writing the request to the ftp server.
using (var ftpStream = await ftpWebRequest.GetRequestStreamAsync())
{
await CopyToWithEvent(inputStream, ftpStream, FireUploadProgressEventEveryXBytes);
_loggingService.Debug("Closing service....");
ftpStream.Close();
_loggingService.Debug("Closed..");
}
stopwatch.Stop();
_loggingService.Information(
$"Successfully Ftp-uploaded {inputStream.Length.ToString("N0")} characters to {destinationUri.AbsoluteUri} in {stopwatch.Elapsed.ToString("g")}.");
}
private async Task CopyToWithEvent(Stream source,
Stream destination,
long fireEventAfterCopingBytes)
{
source.ShouldNotBeNull();
destination.ShouldNotBeNull();
var eventId = 0;
long totalBytesCopied = 0;
long currentBytesCopied = 0;
var buffer = new byte[4 * 1024];
int bytesRead;
_loggingService.Debug($" #### Source length: { source.Length}");
while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
await destination.WriteAsync(buffer, 0, bytesRead);
// Do we need to fire an event?
if (OnUploadProgress == null)
{
continue;
}
totalBytesCopied += bytesRead;
currentBytesCopied += bytesRead;
// Partial progress report -or- final report.
if (currentBytesCopied >= fireEventAfterCopingBytes ||
totalBytesCopied == source.Length)
{
// We have copied more-or-equal bytes to fire off an event.
// So lets tell anyone the current event!
OnUploadProgress(new UploadProgressArgs(++eventId, totalBytesCopied, currentBytesCopied, source.Length));
currentBytesCopied = 0; // Reset.
}
if (totalBytesCopied >= source.Length)
{
await destination.FlushAsync();
}
}
}
/// <summary>
/// <paramref name="srcStream"/> 스트림을 읽어, <paramref name="destStream"/>에 쓴다.
/// </summary>
/// <param name="srcStream">원본 스트림</param>
/// <param name="destStream">대상 스트림</param>
/// <param name="bufferSize">버퍼 크기</param>
public static void CopyStreamToStream(this Stream srcStream, Stream destStream, int bufferSize)
{
srcStream.ShouldNotBeNull("srcStream");
destStream.ShouldNotBeNull("destStream");
bufferSize.ShouldBePositive("bufferSize");
if (IsDebugEnabled)
{
log.Debug("원본 스트림으로부터 대상 스트림으로 복사합니다. bufferSize=[{0}]", bufferSize);
}
var buffer = new byte[bufferSize];
int readCount;
while ((readCount = srcStream.Read(buffer, 0, buffer.Length)) > 0)
{
destStream.Write(buffer, 0, readCount);
}
}
/// <summary>
/// 원격 파일을 다운받아 지정된 스트림에 쓴다.
/// </summary>
/// <param name="remoteFilename">원격 파일 전체 경로 (예: /Users/debop/readme.txt)</param>
/// <param name="localStream">원격파일 정보를 저장할 Stream 객체</param>
/// <returns>다운로드 여부</returns>
public bool Download(string remoteFilename, Stream localStream)
{
localStream.ShouldNotBeNull("localStream");
if (IsDebugEnabled)
{
log.Debug("원격 파일을 다운로드 받아 localStream에 씁니다.... remoteFilename=[{0}]", remoteFilename);
}
remoteFilename = AdjustRemoteFilename(remoteFilename);
var uri = Hostname + remoteFilename;
try {
using (var responseStream = GetDownloadResponseStream(uri)) {
byte[] buffer = new byte[FTP_FILE_BUFFER];
int readCount;
do
{
readCount = responseStream.Read(buffer, 0, FTP_FILE_BUFFER);
localStream.Write(buffer, 0, readCount);
} while(readCount > 0);
// localStream.Flush();
}
if (IsDebugEnabled)
{
log.Debug("Download the remote file is success. remoteFilename=[{0}]", remoteFilename);
}
return(true);
}
catch (Exception ex) {
if (log.IsWarnEnabled)
{
log.Warn("Fail to download the remote file. remoteFilename=[{0}]", remoteFilename);
log.Warn(ex);
}
return(false);
}
}
/// <summary>
/// 생성자
/// </summary>
/// <param name="writableTargetStream">실제 Data가 쓰일 대상 Stream</param>
public TransferStream(Stream writableTargetStream) {
writableTargetStream.ShouldNotBeNull("writableTargetStream");
Guard.Assert(writableTargetStream.CanWrite, "Target stream is not writable.");
_writableTargetStream = writableTargetStream;
_chunks = new BlockingCollection<byte[]>();
// _chunks 에 입력이 들어올 때까지 기다렸다가, 대상 Stream에 쓰는 Background 작업을 정의합니다.
_processingTask =
Task.Factory.StartNew(() => {
if(IsDebugEnabled)
log.Debug("스트림 정보 복사를 시작합니다...");
foreach(var chunk in _chunks.GetConsumingEnumerable())
_writableTargetStream.Write(chunk, 0, chunk.Length);
if(IsDebugEnabled)
log.Debug("스트림 정보 복사를 완료되었습니다!!!");
});
}
public static void DownloadFile(this IMongoRepository repository, Stream stream, string remoteFilename, int version) {
stream.ShouldNotBeNull("stream");
remoteFilename.ShouldNotBeWhiteSpace("remoteFilename");
repository.GridFS.Download(stream, remoteFilename, version);
}
public static void DownloadFile(this IMongoRepository repository, Stream stream, IMongoQuery query, int version) {
stream.ShouldNotBeNull("stream");
repository.GridFS.Download(stream, query ?? Query.Null, version);
}
public static void DownloadFile(this IMongoRepository repository, Stream stream, MongoGridFSFileInfo fileInfo) {
stream.ShouldNotBeNull("stream");
fileInfo.ShouldNotBeNull("fileinfo");
repository.GridFS.Download(stream, fileInfo);
}
/// <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>
/// 저장소에 저장한다.
/// </summary>
/// <param name="stream">저장할 Stream</param>
/// <param name="destFile">대상 파일경로</param>
/// <param name="overwrite">덮어쓰기 여부</param>
/// <returns>저장된 파일명</returns>
public override Task<string> SaveAs(Stream stream, string destFile, bool overwrite)
{
if(IsDebugEnabled)
log.Debug("==>S stream={0}, destFile={1}, overwrite={2}", stream, destFile, overwrite);
stream.ShouldNotBeNull("저장할 파일정보가 없습니다.");
destFile.ShouldNotBeWhiteSpace("저장할 대상파일정보가 없습니다.");
var destFilePath = destFile;
var task = Task.Factory.StartNew(() =>
{
var path = GetDestFile(destFilePath, overwrite);
var uploadTask = _ftpClient.UploadTask(stream, path);
if(IsDebugEnabled)
log.Debug("task.Result={0}", uploadTask.Result);
return path;
}).ContinueWith((antecedent) => antecedent.Result);
task.Wait();
destFile = task.Result;
if(IsDebugEnabled)
log.Debug("==>>E task.Result={0}, destFile={1}", task.Result, destFile);
return task;
}
/// <summary>
/// 지정된 스트림 정보를 FTP서버에 지정된 파일명으로 저장한다.
/// </summary>
/// <param name="localStream"></param>
/// <param name="remoteFilename"></param>
/// <returns></returns>
public bool Upload(Stream localStream, string remoteFilename) {
if(IsDebugEnabled)
log.Debug("Upload localStream to ftp server. remoteFilename=[{0}]", remoteFilename);
localStream.ShouldNotBeNull("localStream");
remoteFilename = AdjustRemoteFilename(remoteFilename);
var uri = Hostname + remoteFilename;
var buffer = new byte[FTP_FILE_BUFFER];
try {
using(Stream requestStream = GetUploadRequestStream(uri)) {
int dataRead;
do {
dataRead = localStream.Read(buffer, 0, FTP_FILE_BUFFER);
requestStream.Write(buffer, 0, dataRead);
} while(dataRead > 0);
}
if(IsDebugEnabled)
log.Debug("Upload file is success. remoteFilename=[{0}]", remoteFilename);
return true;
}
catch(Exception ex) {
if(log.IsWarnEnabled) {
log.Warn("Upload a file is failed. eat the exception and return false");
log.Warn(ex);
}
return false;
}
}
private static IEnumerable<Task> CopyStreamIterator(Stream input, Stream output) {
input.ShouldNotBeNull("input");
output.ShouldNotBeNull("output");
if(IsDebugEnabled)
log.Debug("입출력 스트림 간의 데이타 복사를 수행하는 Task의 열거자를 생성합니다...");
// 두개의 버퍼를 만든다.
// 하나는 읽기 전용, 하나는 쓰기 전용. 계속해서 두개의 버퍼 내용을 스위칭하여 사용한다.
//
var buffers = new[] { new byte[BufferSize], new byte[BufferSize] };
var filledBufferNo = 0;
Task writeTask = null;
while(true) {
// 비동기 stream 읽기 작업
var readTask = input.ReadAsync(buffers[filledBufferNo], 0, buffers[filledBufferNo].Length);
if(writeTask == null) {
yield return readTask;
// Wait() 호출은 Task 작업 중에 예외발생 시, 예외를 전파시키기 위해서이다.
readTask.Wait();
}
else {
var tasks = new[] { readTask, writeTask };
yield return Task.Factory.WhenAll(tasks);
// Wait() 호출은 Task 작업 중에 예외발생시, 예외를 전파시키기 위해서이다.
Task.WaitAll(tasks);
}
// 더 이상 읽을 데이타가 없다면 중지한다.
if(readTask.Result <= 0)
break;
// 읽어들인 버퍼 내용을 output stream에 비동기적으로 씁니다.
writeTask = output.WriteAsync(buffers[filledBufferNo], 0, readTask.Result);
// Swap buffers
filledBufferNo ^= 1;
}
}
/// <summary>
/// <paramref name="stream"/>을 읽어, <paramref name="filepath"/>의 파일에 저장합니다.
/// 해당 파일이 존재하면 겹쳐 쓰거나 추가를 할 수 있습니다. 파일이 없으면 새로 생성합니다.
/// </summary>
/// <param name="filepath">대상 파일 경로</param>
/// <param name="stream">저장할 내용</param>
/// <param name="overwrite">겹쳐쓰기 여부</param>
public static void Save(string filepath, Stream stream, bool overwrite) {
filepath.ShouldNotBeWhiteSpace("filepath");
stream.ShouldNotBeNull("stream");
if(IsDebugEnabled)
log.Debug("스트림 내용을 파일에 저장합니다... filepath=[{0}], overwrite=[{1}]", filepath, overwrite);
stream.SetStreamPosition(0);
if(overwrite && FileExists(filepath)) {
if(IsDebugEnabled)
log.Debug("기존 파일이 존재하고, 겹쳐쓰기를 해야 하므로, 기존 파일을 삭제합니다. filepath=[{0}]", filepath);
DeleteFile(filepath);
}
//using(var fs = File.Open(filepath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
//using(var bs = new BufferedStream(fs))
using(var bs = GetBufferedFileStream(filepath, FileOpenMode.ReadWrite)) {
var buffer = new byte[DEFAULT_BUFFER_SIZE];
int readCount;
while((readCount = stream.Read(buffer, 0, DEFAULT_BUFFER_SIZE)) > 0) {
bs.Write(buffer, 0, readCount);
}
bs.Flush();
}
}
/// <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());
}
/// <summary>
/// <paramref name="stream"/> 정보를 읽어서 XmlDocument 인스턴스를 생성한다.
/// </summary>
/// <param name="stream">원본 Stream 객체</param>
public XmlDoc(Stream stream) {
stream.ShouldNotBeNull("strem");
stream.SetStreamPosition();
Load(stream);
}
/// <summary>
/// FTP 서버에 있는 원격 파일을 다운로드하여, <paramref name="localStream"/>에 씁니다.
/// </summary>
/// <param name="ftpClient"></param>
/// <param name="remoteFilename"></param>
/// <param name="localStream"></param>
/// <returns></returns>
public static Task<bool> DownloadTask(this FtpClient ftpClient, string remoteFilename, Stream localStream) {
localStream.ShouldNotBeNull("localStream");
if(IsDebugEnabled)
log.Debug("원격 파일을 다운로드 받는 작업을 생성합니다... remoteFilename=[{0}]", remoteFilename);
remoteFilename = ftpClient.AdjustRemoteFilename(remoteFilename);
var uri = ftpClient.Hostname + remoteFilename;
return
ftpClient
.GetResponseStreamTask(uri, WebRequestMethods.Ftp.DownloadFile)
.ContinueWith(task => {
task.Result.CopyStreamToStream(localStream);
task.Result.Close();
if(IsDebugEnabled)
log.Debug("원격 파일 다운로드가 완료되었습니다. remoteFilename=[{0}]", remoteFilename);
return true;
},
TaskContinuationOptions.ExecuteSynchronously);
}
/// <summary>
/// <paramref name="stream"/> 내용을 읽어 문자열로 반환합니다.
/// </summary>
/// <param name="stream">읽을 스트림</param>
/// <returns></returns>
public static string ToString(Stream stream) {
stream.ShouldNotBeNull("stream");
using(var reader = new StreamReader(stream))
return reader.ReadToEnd().TrimEnd('\0');
}
/// <summary>
/// <paramref name="ftpClient"/>를 이용하여, 로컬 파일 스트림을 FTP 서버로 Upload 합니다.
/// </summary>
/// <param name="ftpClient"></param>
/// <param name="localStream"></param>
/// <param name="remoteFilename"></param>
/// <returns></returns>
public static Task<bool> UploadTask(this FtpClient ftpClient, Stream localStream, string remoteFilename) {
if(IsDebugEnabled)
log.Debug("FTP 서버로 스트림을 비동기 방식으로 업로드합니다... RemoteFile=[{0}]", remoteFilename);
localStream.ShouldNotBeNull("localStream");
remoteFilename = ftpClient.AdjustRemoteFilename(remoteFilename);
var uri = ftpClient.Hostname + remoteFilename;
return
GetRequestStreamTask(ftpClient, uri, WebRequestMethods.Ftp.UploadFile)
.ContinueWith(task => {
localStream.CopyStreamToStream(task.Result);
task.Result.Close();
if(IsDebugEnabled)
log.Debug("FTP 서버로 파일을 업로드를 완료했습니다. RemoteFile=[{0}]", remoteFilename);
return true;
},
TaskContinuationOptions.ExecuteSynchronously);
}
/// <summary>
/// 지정된 스트림을 Html 형식으로 Encoding 한다.
/// </summary>
/// <param name="s"></param>
/// <param name="output">인코딩된 문자가 담긴 stream</param>
public static void HtmlEncode(string s, Stream output) {
output.ShouldNotBeNull("output");
using(var writer = new StreamWriter(output)) {
HttpUtility.HtmlEncode(s, writer);
writer.Flush();
}
}
private static IEnumerable<Task> ReadIterator(Stream input, int bufferSize, Action<byte[], int> bufferAvailable) {
input.ShouldNotBeNull("input");
bufferSize.ShouldBePositive("bufferSize");
bufferAvailable.ShouldNotBeNull("bufferAvailable");
var buffer = new byte[bufferSize];
while(true) {
var readTask = input.ReadAsync(buffer, 0, buffer.Length);
yield return readTask;
if(readTask.Result <= 0)
break;
bufferAvailable(buffer, readTask.Result);
}
}
/// <summary>
/// <paramref name="srcStream"/> 스트림을 읽어, <paramref name="destStream"/>에 쓴다.
/// </summary>
/// <param name="srcStream">원본 스트림</param>
/// <param name="destStream">대상 스트림</param>
/// <param name="bufferSize">버퍼 크기</param>
public static void CopyStreamToStream(this Stream srcStream, Stream destStream, int bufferSize) {
srcStream.ShouldNotBeNull("srcStream");
destStream.ShouldNotBeNull("destStream");
bufferSize.ShouldBePositive("bufferSize");
if(IsDebugEnabled)
log.Debug("원본 스트림으로부터 대상 스트림으로 복사합니다. bufferSize=[{0}]", bufferSize);
var buffer = new byte[bufferSize];
int readCount;
while((readCount = srcStream.Read(buffer, 0, buffer.Length)) > 0) {
destStream.Write(buffer, 0, readCount);
}
}
/// <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>
/// 원격 파일을 다운받아 지정된 스트림에 쓴다.
/// </summary>
/// <param name="remoteFilename">원격 파일 전체 경로 (예: /Users/debop/readme.txt)</param>
/// <param name="localStream">원격파일 정보를 저장할 Stream 객체</param>
/// <returns>다운로드 여부</returns>
public bool Download(string remoteFilename, Stream localStream) {
localStream.ShouldNotBeNull("localStream");
if(IsDebugEnabled)
log.Debug("원격 파일을 다운로드 받아 localStream에 씁니다.... remoteFilename=[{0}]", remoteFilename);
remoteFilename = AdjustRemoteFilename(remoteFilename);
var uri = Hostname + remoteFilename;
try {
using(var responseStream = GetDownloadResponseStream(uri)) {
byte[] buffer = new byte[FTP_FILE_BUFFER];
int readCount;
do {
readCount = responseStream.Read(buffer, 0, FTP_FILE_BUFFER);
localStream.Write(buffer, 0, readCount);
} while(readCount > 0);
// localStream.Flush();
}
if(IsDebugEnabled)
log.Debug("Download the remote file is success. remoteFilename=[{0}]", remoteFilename);
return true;
}
catch(Exception ex) {
if(log.IsWarnEnabled) {
log.Warn("Fail to download the remote file. remoteFilename=[{0}]", remoteFilename);
log.Warn(ex);
}
return false;
}
}
