public async Task WriteAsync(string str)
{
if (!isHeaderWritten)
{
await WriteHeadAsync();
}
if (!string.IsNullOrEmpty(str))
{
var bytes = Encoding.UTF8.GetBytes(str);
await ResponseStream.WriteAsync(bytes, 0, bytes.Length);
}
await ResponseStream.FlushAsync();
}
/// <summary>
/// Implements the Dispose pattern
/// </summary>
/// <param name="disposing">Whether this object is being disposed via a call to Dispose
/// or garbage collected.</param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
if (this.ResponseStream != null)
{
ResponseStream.Dispose();
ResponseStream = null;
}
}
this.disposed = true;
}
}
public void WritePartialTo(IResponse response)
{
var contentLength = GetContentLength().GetValueOrDefault(int.MaxValue); //Safe as guarded by IsPartialRequest
var rangeHeader = RequestContext.GetHeader(HttpHeaders.Range);
long rangeStart, rangeEnd;
rangeHeader.ExtractHttpRanges(contentLength, out rangeStart, out rangeEnd);
if (rangeEnd > contentLength - 1)
{
rangeEnd = contentLength - 1;
}
response.AddHttpRangeResponseHeaders(rangeStart, rangeEnd, contentLength);
var outputStream = response.OutputStream;
if (FileInfo != null)
{
using (var fs = FileInfo.OpenRead())
{
fs.WritePartialTo(outputStream, rangeStart, rangeEnd);
}
}
else if (ResponseStream != null)
{
try
{
ResponseStream.WritePartialTo(outputStream, rangeStart, rangeEnd);
}
finally
{
DisposeStream();
}
}
else if (ResponseText != null)
{
using (var ms = MemoryStreamFactory.GetStream(Encoding.UTF8.GetBytes(ResponseText)))
{
ms.WritePartialTo(outputStream, rangeStart, rangeEnd);
}
}
else
{
throw new InvalidOperationException("Neither file, stream nor text were set when attempting to write to the Response Stream.");
}
}
private static string ConvertFile(string downloadUrl, string fromExt, Token token)
{
Global.Logger.Debug("GoogleDriveApp: convert file");
if (string.IsNullOrEmpty(downloadUrl))
{
Global.Logger.Error("GoogleDriveApp: downloadUrl is null");
throw new Exception("downloadUrl is null");
}
var request = (HttpWebRequest)WebRequest.Create(downloadUrl);
request.Method = "GET";
request.Headers.Add("Authorization", "Bearer " + token);
try
{
using (var response = request.GetResponse())
using (var fileStream = new ResponseStream(response))
{
Global.Logger.Debug("GoogleDriveApp: GetExternalUri - " + downloadUrl);
var key = DocumentServiceConnector.GenerateRevisionId(downloadUrl);
downloadUrl = DocumentServiceConnector.GetExternalUri(fileStream, response.ContentType, key);
}
}
catch (WebException e)
{
Global.Logger.Error("GoogleDriveApp: Error GetExternalUri", e);
request.Abort();
}
var toExt = FileUtility.GetInternalExtension(fromExt);
try
{
Global.Logger.Debug("GoogleDriveApp: GetConvertedUri- " + downloadUrl);
var key = DocumentServiceConnector.GenerateRevisionId(downloadUrl);
DocumentServiceConnector.GetConvertedUri(downloadUrl, fromExt, toExt, key, false, out downloadUrl);
}
catch (Exception e)
{
Global.Logger.Error("GoogleDriveApp: Error GetConvertedUri", e);
}
return(downloadUrl);
}
private static string CreateFile(string contentUrl, string fileName, string folderId, Token token)
{
if (string.IsNullOrEmpty(contentUrl))
{
Global.Logger.Error("GoogleDriveApp: downloadUrl is null");
throw new Exception("downloadUrl is null");
}
Global.Logger.Debug("GoogleDriveApp: create from - " + contentUrl);
var request = (HttpWebRequest)WebRequest.Create(contentUrl);
using (var content = new ResponseStream(request.GetResponse()))
{
return(CreateFile(content, fileName, folderId, token));
}
}
public static void Write(this NetworkStream stream, ResponseStream data)
{
byte[] buffer = new byte[10000];
try
{
while (!data.End && stream.CanWrite)
{
var len = data.GetChunk(buffer);
stream.Write(buffer, 0, len);
}
stream.Flush();
}
catch (Exception ex)
{
ConsoleUtils.WriteLn(ex);
}
}
public void Dispose()
{
if (ProxyRequest != null)
{
ProxyRequest.Abort();
}
if (ResponseStream != null)
{
ResponseStream.Dispose();
}
if (ServerResponse != null)
{
ServerResponse.Close();
}
}
public void CloseResponseStream()
{
if (ResponseStream != null)
{
try
{
ResponseStream.Close();
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
finally
{
ResponseStream = null;
}
}
}
/// <summary>
/// Returns streams associated with account.
/// </summary>
/// <param name="restApi">Server address</param>
/// <param name="apiToken">API token for account</param>
/// <returns>List of tuple containing the name and the streamID of each stream</returns>
public static async Task <List <Tuple <string, string> > > GetStreams(string restApi, string apiToken)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
ResponseStream response = await myClient.StreamsGetAllAsync("fields=name,streamId");
List <Tuple <string, string> > ret = new List <Tuple <string, string> >();
foreach (SpeckleStream s in response.Resources)
{
ret.Add(new Tuple <string, string>(s.Name, s.StreamId));
}
return(ret);
}
private void CloseResponseStream()
{
if (ResponseStream != null)
{
try
{
ResponseStream.Close();
}
catch
{
// ignored
}
finally
{
ResponseStream = null;
}
}
}
protected override void Complete(Exception e = null)
{
ResponseStream?.Close();
if (e != null)
{
try
{
File.Delete(Filename);
}
catch (Exception eOther)
{
e = new AggregateException(e, eOther);
}
}
base.Complete(e);
}
internal bool ResponsePage(ref AutoCSer.Memory.Pointer buffer, ref AutoCSer.Memory.Pointer encodeBuffer)
{
if (ResponseStream == null)
{
ResponseStream = new UnmanagedStream(default(AutoCSer.Memory.Pointer));
}
buffer = UnmanagedPool.Default.GetPointer();
ResponseStream.Reset(ref buffer);
using (ResponseStream)
{
if (EncodeStream == null)
{
EncodeStream = new UnmanagedStream(default(AutoCSer.Memory.Pointer));
}
encodeBuffer = UnmanagedPool.Default.GetPointer();
EncodeStream.Reset(ref encodeBuffer);
using (EncodeStream)
{
Response bodyResponse = new Response {
Stream = ResponseStream, EncodeStream = EncodeStream, Encoding = DomainServer.ResponseEncoding
};
if (IsAwaitMethod)
{
pageAsync(bodyResponse);
AsyncWaitHandle.Wait();
if (asyncReturn)
{
asyncReturn = false;
HttpResponse.SetBody(ResponseStream);
return(true);
}
}
else
{
if (page(ref bodyResponse))
{
HttpResponse.SetBody(ResponseStream);
return(true);
}
}
}
}
return(false);
}
private bool disposedValue = false; // 중복 호출을 검색하려면
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: 관리되는 상태(관리되는 개체)를 삭제합니다.
ResponseStream?.Dispose();
}
// TODO: 관리되지 않는 리소스(관리되지 않는 개체)를 해제하고 아래의 종료자를 재정의합니다.
// TODO: 큰 필드를 null로 설정합니다.
this.Name = null;
this.FileName = null;
disposedValue = true;
}
}
//-------------------------------------------------------------------------------------------------------------------------
private async Task ProcessResponse()
{
CurrentUri = HttpWebResponse.ResponseUri;
ResponseEncoding = (HttpWebResponse.CharacterSet == "") ? Encoding.UTF8 : Encoding.GetEncoding(HttpWebResponse.CharacterSet);
if (ResponseStream != null)
{
ResponseStream.Dispose();
}
if (PageSourceCache != String.Empty)
{
PageSourceCache = String.Empty;
}
ResponseStream = new MemoryStream();
await HttpWebResponse.GetResponseStream().CopyToAsync(ResponseStream);
ResponseStream.Position = 0;
}
private void SaveThumbnail(IFileDao <T> fileDao, File <T> file, string thumbnailUrl)
{
logger.DebugFormat("SaveThumbnail: FileId: {0}. ThumbnailUrl {1}.", file.ID, thumbnailUrl);
var req = (HttpWebRequest)WebRequest.Create(thumbnailUrl);
//HACK: http://ubuntuforums.org/showthread.php?t=1841740
if (WorkContext.IsMono && ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback += (s, c, n, p) => true;
}
using (var stream = new ResponseStream(req.GetResponse()))
{
Crop(fileDao, file, stream);
}
logger.DebugFormat("SaveThumbnail: FileId: {0}. Successfully saved.", file.ID);
}
public void Dispose()
{
if (OriginalResponse != null)
{
OriginalResponse.Dispose();
OriginalResponse = null;
}
if (ResponseStream != null)
{
ResponseStream.Dispose();
ResponseStream = null;
/*if (streamKey != null)
* {
* streamCache.ClearAsync(streamKey, StreamType.File).Wait();
* }*/
}
}
internal bool ResponsePage(ref byte *buffer, ref byte *encodeBuffer)
{
if (ResponseStream == null)
{
ResponseStream = new UnmanagedStream(null, 0);
}
ResponseStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
using (ResponseStream)
{
if (EncodeStream == null)
{
EncodeStream = new UnmanagedStream(null, 0);
}
EncodeStream.Reset(encodeBuffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
using (EncodeStream)
{
Response bodyResponse = new Response {
Stream = ResponseStream, EncodeStream = EncodeStream, Encoding = DomainServer.ResponseEncoding
};
if (IsAwaitMethod)
{
pageAsync(bodyResponse);
AsyncWaitHandle.Wait();
if (asyncReturn)
{
asyncReturn = false;
HttpResponse.SetBody(ResponseStream);
return(true);
}
}
else
{
if (page(ref bodyResponse))
{
HttpResponse.SetBody(ResponseStream);
return(true);
}
}
}
}
return(false);
}
public IPC()
{
Task.Run(async() =>
{
await foreach (var m in responseChannel.Reader.ReadAllAsync())
{
// Serialize the write
await(ResponseStream?.WriteAsync(m) ?? Task.CompletedTask);
}
}, cts.Token);
Task.Run(async() =>
{
await foreach (var m in browserResponseChannel.Reader.ReadAllAsync())
{
// Serialize the write
await(BrowserResponseStream?.WriteAsync(m) ?? Task.CompletedTask);
}
}, cts.Token);
}
private void ReadCallback(IAsyncResult ar)
{
try
{
var bytesRead = webResponseStream.EndRead(ar);
if (bytesRead <= 0)
{
ResponseStream.Position = 0;
EndRequest();
return;
}
ResponseStream.Write(readBuffer, 0, bytesRead);
webResponseStream.BeginRead(readBuffer, 0, readBuffer.Length, ReadCallback, null);
}
catch (Exception ex)
{
SetException(ex);
}
}
public void Close()
{
if (WebResponse != null)
{
CloseFile(WebResponse.LastModified);
}
else
{
CloseFile();
}
if (ResponseStream != null)
{
ResponseStream.Close();
ResponseStream = null;
}
if (WebResponse != null)
{
WebResponse.Close();
WebResponse = null;
}
}
/// <summary>
/// Closes this request.
/// </summary>
public void Close()
{
WriteResponse(new byte[0]);
var record = Record.CreateEndRequest(RequestId);
record.Send(ResponseStream);
if (ManagingApp != null)
{
ManagingApp.RequestClosed(this);
if (!KeepAlive)
{
ManagingApp.ConnectionClosed(ResponseStream as FCGIStream);
}
}
if (!KeepAlive)
{
ResponseStream.Close();
}
}
private static void StoringFileAfterError(string fileId, string userId, string downloadUri, string downloadType)
{
if (string.IsNullOrEmpty(downloadUri))
{
return;
}
try
{
if (string.IsNullOrEmpty(downloadType))
{
downloadType = FileUtility.GetFileExtension(downloadUri).Trim('.');
}
var fileName = Global.ReplaceInvalidCharsAndTruncate(fileId + "." + downloadType);
var path = string.Format(@"save_crash\{0}\{1}_{2}",
DateTime.UtcNow.ToString("yyyy_MM_dd"),
userId,
fileName);
var store = Global.GetStore();
var req = (HttpWebRequest)WebRequest.Create(downloadUri);
// hack. http://ubuntuforums.org/showthread.php?t=1841740
if (WorkContext.IsMono)
{
ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
}
using (var fileStream = new ResponseStream(req.GetResponse()))
{
store.Save(FileConstant.StorageDomainTmp, path, fileStream);
}
Global.Logger.DebugFormat("DocService storing to {0}", path);
}
catch (Exception ex)
{
Global.Logger.Error("DocService Error on save file to temp store", ex);
}
}
internal void Complete()
{
try
{
if (ResponseStream != null)
{
ResponseStream.Close();
ResponseStream = null;
}
if (ResponseBufferedStream != null)
{
ResponseBufferedStream.Position = 0;
}
}
catch (Exception ex)
{
if (Exception == null)
{
Exception = ex;
}
}
IsCompleted = true;
try
{
if (manualResetEvent != null)
{
manualResetEvent.Set();
}
}
catch (Exception ex)
{
if (Exception == null)
{
Exception = ex;
}
}
userCallback?.Invoke(this);
}
private async Task Subscribe()
{
try {
while (await _call !.ResponseStream.MoveNext().ConfigureAwait(false) &&
!_disposed.IsCancellationRequested)
{
var current = _call !.ResponseStream.Current;
switch (current.ContentCase)
{
case ReadResp.ContentOneofCase.Event:
try {
await _eventAppeared(this, ConvertToResolvedEvent(current),
current.Event.CountCase switch {
ReadResp.Types.ReadEvent.CountOneofCase.RetryCount => current.Event.RetryCount,
_ => default
}, _disposed.Token).ConfigureAwait(false);
if (_autoAck)
{
await AckInternal(Uuid.FromDto(current.Event.Link?.Id ?? current.Event.Event.Id))
.ConfigureAwait(false);
}
} catch (Exception ex) when(ex is ObjectDisposedException ||
ex is OperationCanceledException)
{
SubscriptionDropped(SubscriptionDroppedReason.Disposed);
return;
} catch (Exception ex) {
try {
SubscriptionDropped(SubscriptionDroppedReason.SubscriberError, ex);
} finally {
_disposed.Cancel();
}
return;
}
break;
}
/// Close a stream. In fact it just does a Dispose().
/// If either ResponseStream or WebResponse are open, then close these also.
public void Dispose()
{
if (Reader != null)
{
Reader.Dispose();
Reader = null;
}
if (ResponseStream != null)
{
ResponseStream.Close();
ResponseStream.Dispose();
ResponseStream = null;
}
if (WebResponse != null)
{
WebResponse.Close();
WebResponse.Dispose();
WebResponse = null;
}
}
private static void SaveHistory(File file, string changes, string differenceUrl)
{
if (file == null)
{
return;
}
if (file.ProviderEntry)
{
return;
}
if (string.IsNullOrEmpty(changes) || string.IsNullOrEmpty(differenceUrl))
{
return;
}
try
{
using (var fileDao = Global.DaoFactory.GetFileDao())
{
var req = (HttpWebRequest)WebRequest.Create(differenceUrl);
// hack. http://ubuntuforums.org/showthread.php?t=1841740
if (WorkContext.IsMono)
{
ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
}
using (var differenceStream = new ResponseStream(req.GetResponse()))
{
fileDao.SaveEditHistory(file, changes, differenceStream);
}
}
}
catch (Exception ex)
{
Global.Logger.Error("DocService save history error", ex);
}
}
private static void StoringFileAfterError(string fileId, string userId, string downloadUri)
{
try
{
var fileName = fileId + FileUtility.GetFileExtension(downloadUri);
var path = string.Format(@"save_crash\{0}\{1}_{2}",
DateTime.UtcNow.ToString("yyyy_MM_dd"),
userId,
fileName);
var store = Global.GetStore();
var req = (HttpWebRequest)WebRequest.Create(downloadUri);
using (var fileStream = new ResponseStream(req.GetResponse()))
{
store.Save(FileConstant.StorageDomainTmp, path, fileStream);
}
Global.Logger.DebugFormat("DocService storing to {0}", path);
}
catch (Exception ex)
{
Global.Logger.Error("DocService Error on save file to temp store", ex);
}
}
private static File CreateFileFromUri(Folder folder, string fileUri, string fileTitle)
{
if (string.IsNullOrEmpty(fileTitle))
{
fileTitle = Path.GetFileName(HttpUtility.UrlDecode(fileUri));
}
var file = new File
{
Title = fileTitle,
FolderID = folder.ID
};
var req = (HttpWebRequest)WebRequest.Create(fileUri);
using (var fileDao = Global.DaoFactory.GetFileDao())
using (var fileStream = new ResponseStream(req.GetResponse()))
{
file.ContentLength = fileStream.Length;
return(fileDao.SaveFile(file, fileStream));
}
}
/// <summary>
/// 关闭
/// </summary>
public void Close()
{
if (web_response_ != null)
{
CloseFile(web_response_.LastModified);
}
else
{
CloseFile();
}
if (ResponseStream != null)
{
ResponseStream.Close();
ResponseStream = null;
}
if (web_response_ != null)
{
web_response_.Close();
web_response_ = null;
}
}
internal void Complete()
{
try {
if (ResponseStream != null)
{
ResponseStream.Close();
ResponseStream = null;
}
if (ResponseBufferedStream != null)
{
ResponseBufferedStream.Position = 0;
}
}
catch (Exception ex) {
if (_exception == null)
{
_exception = ex;
}
}
_isCompleted = true;
try {
if (_manualResetEvent != null)
{
_manualResetEvent.Set();
}
}
catch (Exception ex) {
if (_exception == null)
{
_exception = ex;
}
}
if (_userCallback != null)
{
_userCallback(this);
}
}
/// <summary>Flush</summary>
public override void Flush()
{
byte[] bb = TempBuffer.GetBuffer();
if (bb != null && bb.Length > 0)
{
// 書き換え処理
Encoding enc = Response.ContentEncoding;
string content = enc.GetString(bb);
// JSON形式なので、JsonConvertでaccess_tokenを抜き出す。
Dictionary <string, object> accessTokenResponse = JsonConvert.DeserializeObject <Dictionary <string, object> >(content);
// refresh_tokenを削除
if (accessTokenResponse.ContainsKey(OAuth2AndOIDCConst.RefreshToken))
{
accessTokenResponse.Remove(OAuth2AndOIDCConst.RefreshToken);
bb = enc.GetBytes(JsonConvert.SerializeObject(accessTokenResponse));
}
}
ResponseStream.Write(bb, 0, bb.Length);
ResponseStream.Flush();
}
public void SaveFile(string fileId, string downloadUrl)
{
Global.Logger.Debug("GoogleDriveApp: save file stream " + fileId + " from - " + downloadUrl);
fileId = ThirdPartySelector.GetFileId(fileId);
var token = Token.GetToken(AppAttr);
var driveFile = GetDriveFile(fileId, token);
if (driveFile == null)
{
Global.Logger.Error("GoogleDriveApp: file is null");
throw new Exception("File not found");
}
var jsonFile = JObject.Parse(driveFile);
var curExt = GetCorrectExt(jsonFile);
var newExt = FileUtility.GetFileExtension(downloadUrl);
if (curExt != newExt)
{
try
{
Global.Logger.Debug("GoogleDriveApp: GetConvertedUri from " + newExt + " to " + curExt + " - " + downloadUrl);
var key = DocumentServiceConnector.GenerateRevisionId(downloadUrl);
DocumentServiceConnector.GetConvertedUri(downloadUrl, newExt, curExt, key, false, out downloadUrl);
}
catch (Exception e)
{
Global.Logger.Error("GoogleDriveApp: Error convert", e);
}
}
var downloadRequest = WebRequest.Create(downloadUrl);
using (var downloadResponse = downloadRequest.GetResponse())
using (var downloadStream = new ResponseStream(downloadResponse))
{
var request = (HttpWebRequest)WebRequest.Create(GoogleUrlUpload + "/{fileId}?uploadType=media".Replace("{fileId}", fileId));
request.Method = "PUT";
request.Headers.Add("Authorization", "Bearer " + token);
request.ContentType = downloadResponse.ContentType;
request.ContentLength = downloadResponse.ContentLength;
const int bufferSize = 2048;
var buffer = new byte[bufferSize];
int readed;
while ((readed = downloadStream.Read(buffer, 0, bufferSize)) > 0)
{
request.GetRequestStream().Write(buffer, 0, readed);
}
try
{
using (var response = request.GetResponse())
using (var stream = response.GetResponseStream())
{
var result = stream != null ? new StreamReader(stream).ReadToEnd() : null;
Global.Logger.Debug("GoogleDriveApp: save file stream response - " + result);
}
}
catch (WebException e)
{
Global.Logger.Error("GoogleDriveApp: Error save file stream", e);
request.Abort();
var httpResponse = (HttpWebResponse)e.Response;
if (httpResponse.StatusCode == HttpStatusCode.Forbidden)
{
throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException, e);
}
throw;
}
}
}
internal void SendHeaders(bool closing, MemoryStream ms)
{
Encoding encoding = content_encoding;
if (encoding == null)
encoding = Encoding.Default;
if (content_type != null) {
if (content_encoding != null && content_type.IndexOf ("charset=", StringComparison.Ordinal) == -1) {
string enc_name = content_encoding.WebName;
headers.SetInternal ("Content-Type", content_type + "; charset=" + enc_name);
} else {
headers.SetInternal ("Content-Type", content_type);
}
}
if (headers ["Server"] == null)
headers.SetInternal ("Server", "Mono-HTTPAPI/1.0");
CultureInfo inv = CultureInfo.InvariantCulture;
if (headers ["Date"] == null)
headers.SetInternal ("Date", DateTime.UtcNow.ToString ("r", inv));
if (!chunked) {
if (!cl_set && closing) {
cl_set = true;
content_length = 0;
}
if (cl_set)
headers.SetInternal ("Content-Length", content_length.ToString (inv));
}
Version v = context.Request.ProtocolVersion;
if (!cl_set && !chunked && v >= HttpVersion.Version11)
chunked = true;
/* Apache forces closing the connection for these status codes:
* HttpStatusCode.BadRequest 400
* HttpStatusCode.RequestTimeout 408
* HttpStatusCode.LengthRequired 411
* HttpStatusCode.RequestEntityTooLarge 413
* HttpStatusCode.RequestUriTooLong 414
* HttpStatusCode.InternalServerError 500
* HttpStatusCode.ServiceUnavailable 503
*/
bool conn_close = (status_code == 400 || status_code == 408 || status_code == 411 ||
status_code == 413 || status_code == 414 || status_code == 500 ||
status_code == 503);
if (conn_close == false)
conn_close = !context.Request.KeepAlive;
// They sent both KeepAlive: true and Connection: close!?
if (!keep_alive || conn_close) {
headers.SetInternal ("Connection", "close");
conn_close = true;
}
if (chunked)
headers.SetInternal ("Transfer-Encoding", "chunked");
int reuses = context.Connection.Reuses;
if (reuses >= 100) {
force_close_chunked = true;
if (!conn_close) {
headers.SetInternal ("Connection", "close");
conn_close = true;
}
}
if (!conn_close) {
headers.SetInternal ("Keep-Alive", String.Format ("timeout=15,max={0}", 100 - reuses));
if (context.Request.ProtocolVersion <= HttpVersion.Version10)
headers.SetInternal ("Connection", "keep-alive");
}
if (location != null)
headers.SetInternal ("Location", location);
if (cookies != null) {
foreach (Cookie cookie in cookies)
headers.SetInternal ("Set-Cookie", cookie.ToClientString ());
}
StreamWriter writer = new StreamWriter (ms, encoding, 256);
writer.Write ("HTTP/{0} {1} {2}\r\n", version, status_code, status_description);
string headers_str = headers.ToStringMultiValue ();
writer.Write (headers_str);
writer.Flush ();
int preamble = (encoding.CodePage == 65001) ? 3 : encoding.GetPreamble ().Length;
if (output_stream == null)
output_stream = context.Connection.GetResponseStream ();
/* Assumes that the ms was at position 0 */
ms.Position = preamble;
HeadersSent = true;
}
private static string ConvertFile(string downloadUrl, string fromExt, Token token)
{
Global.Logger.Debug("GoogleDriveApp: convert file");
if (string.IsNullOrEmpty(downloadUrl))
{
Global.Logger.Error("GoogleDriveApp: downloadUrl is null");
throw new Exception("downloadUrl is null");
}
var request = WebRequest.Create(downloadUrl);
request.Method = "GET";
request.Headers.Add("Authorization", "Bearer " + token);
try
{
using (var response = request.GetResponse())
using (var fileStream = new ResponseStream(response))
{
Global.Logger.Debug("GoogleDriveApp: GetExternalUri - " + downloadUrl);
var key = DocumentServiceConnector.GenerateRevisionId(downloadUrl);
downloadUrl = DocumentServiceConnector.GetExternalUri(fileStream, response.ContentType, key);
}
}
catch (WebException e)
{
Global.Logger.Error("GoogleDriveApp: Error GetExternalUri", e);
request.Abort();
}
var toExt = FileUtility.GetInternalExtension(fromExt);
try
{
Global.Logger.Debug("GoogleDriveApp: GetConvertedUri- " + downloadUrl);
var key = DocumentServiceConnector.GenerateRevisionId(downloadUrl);
DocumentServiceConnector.GetConvertedUri(downloadUrl, fromExt, toExt, key, false, out downloadUrl);
}
catch (Exception e)
{
Global.Logger.Error("GoogleDriveApp: Error GetConvertedUri", e);
}
return downloadUrl;
}
internal RequestState(HttpRequestMessage request, CancellationToken cancellationToken)
{
_request = request;
_responseTcs = new TaskCompletionSource<HttpResponseMessage>();
_sendingHeaders = () => { };
if (request.RequestUri.IsDefaultPort)
{
request.Headers.Host = request.RequestUri.Host;
}
else
{
request.Headers.Host = request.RequestUri.GetComponents(UriComponents.HostAndPort, UriFormat.UriEscaped);
}
OwinContext = new OwinContext();
OwinContext.Set("owin.Version", "1.0");
IOwinRequest owinRequest = OwinContext.Request;
owinRequest.Protocol = "HTTP/" + request.Version.ToString(2);
owinRequest.Scheme = request.RequestUri.Scheme;
owinRequest.Method = request.Method.ToString();
owinRequest.Path = PathString.FromUriComponent(request.RequestUri);
owinRequest.PathBase = PathString.Empty;
owinRequest.QueryString = QueryString.FromUriComponent(request.RequestUri);
owinRequest.CallCancelled = cancellationToken;
owinRequest.Set<Action<Action<object>, object>>("server.OnSendingHeaders", (callback, state) =>
{
var prior = _sendingHeaders;
_sendingHeaders = () =>
{
prior();
callback(state);
};
});
foreach (var header in request.Headers)
{
owinRequest.Headers.AppendValues(header.Key, header.Value.ToArray());
}
HttpContent requestContent = request.Content;
if (requestContent != null)
{
foreach (var header in request.Content.Headers)
{
owinRequest.Headers.AppendValues(header.Key, header.Value.ToArray());
}
}
_responseStream = new ResponseStream(CompleteResponse);
OwinContext.Response.Body = _responseStream;
OwinContext.Response.StatusCode = 200;
}
private void PageLoad()
{
var editPossible = !RequestEmbedded && !IsMobile;
var isExtenral = false;
File file;
var fileUri = string.Empty;
if (!ItsTry)
{
try
{
if (string.IsNullOrEmpty(RequestFileUrl))
{
_fileNew = (Request["new"] ?? "") == "true";
var app = ThirdPartySelector.GetAppByFileId(RequestFileId);
if (app == null)
{
var ver = string.IsNullOrEmpty(Request[FilesLinkUtility.Version]) ? -1 : Convert.ToInt32(Request[FilesLinkUtility.Version]);
file = DocumentServiceHelper.GetParams(RequestFileId, ver, RequestShareLinkKey, _fileNew, editPossible, !RequestView, out _docParams);
_fileNew = _fileNew && file.Version == 1 && file.ConvertedType != null && file.CreateOn == file.ModifiedOn;
}
else
{
isExtenral = true;
bool editable;
ThirdPartyApp = true;
file = app.GetFile(RequestFileId, out editable);
file = DocumentServiceHelper.GetParams(file, true, true, true, editable, editable, editable, out _docParams);
_docParams.FileUri = app.GetFileStreamUrl(file);
_docParams.FolderUrl = string.Empty;
}
}
else
{
isExtenral = true;
fileUri = RequestFileUrl;
var fileTitle = Request[FilesLinkUtility.FileTitle];
if (string.IsNullOrEmpty(fileTitle))
fileTitle = Path.GetFileName(HttpUtility.UrlDecode(fileUri)) ?? "";
if (CoreContext.Configuration.Standalone)
{
try
{
var webRequest = WebRequest.Create(RequestFileUrl);
using (var response = webRequest.GetResponse())
using (var responseStream = new ResponseStream(response))
{
var externalFileKey = DocumentServiceConnector.GenerateRevisionId(RequestFileUrl);
fileUri = DocumentServiceConnector.GetExternalUri(responseStream, MimeMapping.GetMimeMapping(fileTitle), externalFileKey);
}
}
catch (Exception error)
{
Global.Logger.Error("Cannot receive external url for \"" + RequestFileUrl + "\"", error);
}
}
file = new File
{
ID = RequestFileUrl,
Title = Global.ReplaceInvalidCharsAndTruncate(fileTitle)
};
file = DocumentServiceHelper.GetParams(file, true, true, true, false, false, false, out _docParams);
_docParams.CanEdit = editPossible && !CoreContext.Configuration.Standalone;
_editByUrl = true;
_docParams.FileUri = fileUri;
}
}
catch (Exception ex)
{
_errorMessage = ex.Message;
return;
}
}
else
{
FileType tryType;
try
{
tryType = (FileType)Enum.Parse(typeof(FileType), Request[FilesLinkUtility.TryParam]);
}
catch
{
tryType = FileType.Document;
}
var path = "demo";
if (!IsMobile)
{
path = FileConstant.NewDocPath + CultureInfo.CurrentUICulture.TwoLetterISOLanguageName + "/";
if (!Global.GetStoreTemplate().IsDirectory(path))
path = FileConstant.NewDocPath + "default/";
path += "new";
}
path += FileUtility.InternalExtension[tryType];
var store = Global.GetStoreTemplate();
fileUri = store.GetUri("", path).ToString();
var fileTitle = "Demo" + FileUtility.InternalExtension[tryType];
file = new File
{
ID = Guid.NewGuid(),
Title = Global.ReplaceInvalidCharsAndTruncate(fileTitle)
};
file = DocumentServiceHelper.GetParams(file, true, true, true, editPossible, editPossible, true, out _docParams);
_docParams.FileUri = CommonLinkUtility.GetFullAbsolutePath(fileUri);
_editByUrl = true;
_docParams.Lang = CultureInfo.CurrentUICulture.Name;
}
if (_docParams.ModeWrite && FileConverter.MustConvert(file))
{
try
{
file = FileConverter.ExecDuplicate(file, RequestShareLinkKey);
}
catch (Exception e)
{
_docParams = null;
_errorMessage = e.Message;
return;
}
var comment = "#message/" + HttpUtility.UrlEncode(FilesCommonResource.CopyForEdit);
Response.Redirect(FilesLinkUtility.GetFileWebEditorUrl(file.ID) + comment);
return;
}
Title = HeaderStringHelper.GetPageTitle(file.Title);
_newScheme = FileUtility.ExtsNewService.Contains(FileUtility.GetFileExtension(file.Title));
if (_newScheme)
{
DocServiceApiUrl = FilesLinkUtility.DocServiceApiUrlNew;
}
if (string.IsNullOrEmpty(_docParams.FolderUrl))
{
_docParams.FolderUrl = Request[FilesLinkUtility.FolderUrl] ?? "";
}
if (MobileDetector.IsRequestMatchesMobile(true))
{
_docParams.FolderUrl = string.Empty;
}
if (RequestEmbedded)
{
_docParams.Type = DocumentServiceParams.EditorType.Embedded;
var shareLinkParam = "&" + FilesLinkUtility.DocShareKey + "=" + RequestShareLinkKey;
_docParams.ViewerUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.FilesBaseAbsolutePath + FilesLinkUtility.EditorPage + "?" + FilesLinkUtility.Action + "=view" + shareLinkParam);
_docParams.DownloadUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.FileHandlerPath + "?" + FilesLinkUtility.Action + "=download" + shareLinkParam);
_docParams.EmbeddedUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.FilesBaseAbsolutePath + FilesLinkUtility.EditorPage + "?" + FilesLinkUtility.Action + "=embedded" + shareLinkParam);
}
else
{
_docParams.Type = IsMobile ? DocumentServiceParams.EditorType.Mobile : DocumentServiceParams.EditorType.Desktop;
if (FileSharing.CanSetAccess(file))
{
_docParams.SharingSettingsUrl = CommonLinkUtility.GetFullAbsolutePath(Share.Location + "?" + FilesLinkUtility.FileId + "=" + file.ID);
}
}
if (!isExtenral)
{
_docKeyForTrack = DocumentServiceHelper.GetDocKey(file.ID, -1, DateTime.MinValue);
if (!ItsTry)
FileMarker.RemoveMarkAsNew(file);
}
if (_docParams.ModeWrite)
{
_tabId = FileTracker.Add(file.ID, _fileNew);
_fixedVersion = FileTracker.FixedVersion(file.ID);
if (ItsTry)
{
AppendAuthControl();
}
}
else
{
_docParams.LinkToEdit = _editByUrl
? CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebEditorExternalUrl(fileUri, file.Title))
: FileConverter.MustConvert(_docParams.File) || _newScheme
? CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebEditorUrl(file.ID))
: string.Empty;
}
if (CoreContext.Configuration.Personal && IsMobile)
{
_docParams.CanEdit = false;
}
}
private static void SaveHistory(File file, string changes, string differenceUrl)
{
if (file == null) return;
if (file.ProviderEntry) return;
if (string.IsNullOrEmpty(changes) || string.IsNullOrEmpty(differenceUrl)) return;
try
{
using (var fileDao = Global.DaoFactory.GetFileDao())
{
var req = (HttpWebRequest) WebRequest.Create(differenceUrl);
// hack. http://ubuntuforums.org/showthread.php?t=1841740
if (WorkContext.IsMono)
{
ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
}
using (var differenceStream = new ResponseStream(req.GetResponse()))
{
fileDao.SaveEditHistory(file, changes, differenceStream);
}
}
}
catch (Exception ex)
{
Global.Logger.Error("DocService save history error", ex);
}
}
private static void StoringFileAfterError(string fileId, string userId, string downloadUri)
{
try
{
var fileName = Global.ReplaceInvalidCharsAndTruncate(fileId + FileUtility.GetFileExtension(downloadUri));
var path = string.Format(@"save_crash\{0}\{1}_{2}",
DateTime.UtcNow.ToString("yyyy_MM_dd"),
userId,
fileName);
var store = Global.GetStore();
var req = (HttpWebRequest) WebRequest.Create(downloadUri);
// hack. http://ubuntuforums.org/showthread.php?t=1841740
if (WorkContext.IsMono)
{
ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
}
using (var fileStream = new ResponseStream(req.GetResponse()))
{
store.Save(FileConstant.StorageDomainTmp, path, fileStream);
}
Global.Logger.DebugFormat("DocService storing to {0}", path);
}
catch (Exception ex)
{
Global.Logger.Error("DocService Error on save file to temp store", ex);
}
}
private void PageLoad()
{
var editPossible = !RequestEmbedded && !IsMobile;
var isExtenral = false;
File file;
var fileUri = string.Empty;
if (!ItsTry)
{
try
{
if (string.IsNullOrEmpty(RequestFileUrl))
{
_fileNew = !string.IsNullOrEmpty(Request[UrlConstant.New]) && Request[UrlConstant.New] == "true";
var ver = string.IsNullOrEmpty(Request[CommonLinkUtility.Version]) ? -1 : Convert.ToInt32(Request[CommonLinkUtility.Version]);
file = DocumentServiceHelper.GetParams(RequestFileId, ver, RequestShareLinkKey, _fileNew, editPossible, !RequestView, out _docParams);
_fileNew = file.Version == 1 && file.ConvertedType != null && _fileNew && file.CreateOn == file.ModifiedOn;
}
else
{
isExtenral = true;
fileUri = RequestFileUrl;
var fileTitle = Request[CommonLinkUtility.FileTitle];
if (string.IsNullOrEmpty(fileTitle))
fileTitle = Path.GetFileName(HttpUtility.UrlDecode(fileUri)) ?? "";
if (CoreContext.Configuration.Standalone)
{
try
{
var webRequest = WebRequest.Create(RequestFileUrl);
using (var response = webRequest.GetResponse())
using (var responseStream = new ResponseStream(response))
{
fileUri = DocumentServiceConnector.GetExternalUri(responseStream, MimeMapping.GetMimeMapping(fileTitle), "new");
}
}
catch (Exception error)
{
Global.Logger.Error("Cannot receive external url for \"" + RequestFileUrl + "\"", error);
}
}
file = new File
{
ID = fileUri.GetHashCode(),
Title = Global.ReplaceInvalidCharsAndTruncate(fileTitle)
};
file = DocumentServiceHelper.GetParams(file, true, true, true, false, false, false, out _docParams);
_docParams.CanEdit = editPossible && !CoreContext.Configuration.Standalone;
_editByUrl = true;
_docParams.FileUri = fileUri;
}
}
catch (Exception ex)
{
_errorMessage = ex.Message;
return;
}
}
else
{
FileType tryType;
try
{
tryType = (FileType)Enum.Parse(typeof(FileType), Request[CommonLinkUtility.TryParam]);
}
catch
{
tryType = FileType.Document;
}
var fileTitle = "Demo";
fileTitle += FileUtility.InternalExtension[tryType];
var relativeUri = string.Format(CommonLinkUtility.FileHandlerPath + UrlConstant.ParamsDemo, tryType);
fileUri = new Uri(Request.Url, relativeUri).ToString();
file = new File
{
ID = Guid.NewGuid(),
Title = Global.ReplaceInvalidCharsAndTruncate(fileTitle)
};
file = DocumentServiceHelper.GetParams(file, true, true, true, editPossible, editPossible, true, out _docParams);
_docParams.FileUri = fileUri;
_editByUrl = true;
}
if (_docParams.ModeWrite && FileConverter.MustConvert(file))
{
try
{
file = FileConverter.ExecDuplicate(file, RequestShareLinkKey);
}
catch (Exception e)
{
_docParams = null;
_errorMessage = e.Message;
return;
}
var comment = "#message/" + HttpUtility.UrlEncode(FilesCommonResource.CopyForEdit);
Response.Redirect(CommonLinkUtility.GetFileWebEditorUrl(file.ID) + comment);
return;
}
Title = HeaderStringHelper.GetPageTitle(file.Title);
if (string.IsNullOrEmpty(_docParams.FolderUrl))
{
_docParams.FolderUrl = Request[CommonLinkUtility.FolderUrl] ?? "";
}
if (MobileDetector.IsRequestMatchesMobile(Context.Request.UserAgent, true))
{
_docParams.FolderUrl = string.Empty;
}
if (RequestEmbedded)
{
_docParams.Type = DocumentServiceParams.EditorType.Embedded;
var shareLinkParam = "&" + CommonLinkUtility.DocShareKey + "=" + RequestShareLinkKey;
_docParams.ViewerUrl = CommonLinkUtility.GetFullAbsolutePath(CommonLinkUtility.FilesBaseAbsolutePath + CommonLinkUtility.EditorPage + "?" + CommonLinkUtility.Action + "=view" + shareLinkParam);
_docParams.DownloadUrl = CommonLinkUtility.GetFullAbsolutePath(CommonLinkUtility.FileHandlerPath + "?" + CommonLinkUtility.Action + "=download" + shareLinkParam);
_docParams.EmbeddedUrl = CommonLinkUtility.GetFullAbsolutePath(CommonLinkUtility.FilesBaseAbsolutePath + CommonLinkUtility.EditorPage + "?" + CommonLinkUtility.Action + "=embedded" + shareLinkParam);
}
else
{
_docParams.Type = IsMobile ? DocumentServiceParams.EditorType.Mobile : DocumentServiceParams.EditorType.Desktop;
if (FileSharing.CanSetAccess(file))
{
_docParams.SharingSettingsUrl = CommonLinkUtility.GetFullAbsolutePath(CommonLinkUtility.FilesBaseAbsolutePath + "share.aspx" + "?" + CommonLinkUtility.FileId + "=" + file.ID + "&" + CommonLinkUtility.FileTitle + "=" + HttpUtility.UrlEncode(file.Title));
}
}
if (!isExtenral)
{
_docKeyForTrack = DocumentServiceHelper.GetDocKey(file.ID, -1, DateTime.MinValue);
if (!ItsTry)
FileMarker.RemoveMarkAsNew(file);
}
if (_docParams.ModeWrite)
{
_tabId = FileLocker.Add(file.ID, _fileNew);
_lockVersion = FileLocker.LockVersion(file.ID);
if (ItsTry)
{
AppendAuthControl();
}
}
else
{
_docParams.LinkToEdit = _editByUrl
? CommonLinkUtility.GetFullAbsolutePath(string.Format(CommonLinkUtility.FileWebEditorExternalUrlString, HttpUtility.UrlEncode(fileUri), file.Title))
: FileConverter.MustConvert(_docParams.File)
? CommonLinkUtility.GetFullAbsolutePath(CommonLinkUtility.GetFileWebEditorUrl(file.ID))
: string.Empty;
}
if (CoreContext.Configuration.YourDocsDemo && IsMobile)
{
_docParams.CanEdit = false;
}
}
internal void Close(bool force_close)
{
if (sock != null) {
Stream st = GetResponseStream ();
st.Close ();
o_stream = null;
}
if (sock != null) {
force_close |= !context.Request.KeepAlive;
if (!force_close)
force_close = (context.Response.Headers ["connection"] == "close");
/*
if (!force_close) {
// bool conn_close = (status_code == 400 || status_code == 408 || status_code == 411 ||
// status_code == 413 || status_code == 414 || status_code == 500 ||
// status_code == 503);
force_close |= (context.Request.ProtocolVersion <= HttpVersion.Version10);
}
*/
if (!force_close && context.Request.FlushInput ()) {
if (chunked && context.Response.ForceCloseChunked == false) {
// Don't close. Keep working.
reuses++;
Unbind ();
Init ();
BeginReadRequest ();
return;
}
reuses++;
Unbind ();
Init ();
BeginReadRequest ();
return;
}
Socket s = sock;
sock = null;
try {
if (s != null)
s.Shutdown (SocketShutdown.Both);
} catch {
} finally {
if (s != null)
s.Close ();
}
Unbind ();
RemoveConnection ();
return;
}
}
public ResponseStream GetResponseStream()
{
// TODO: can we get this stream before reading the input?
if (o_stream == null) {
HttpListener listener = context.Listener;
bool ign = (listener == null) ? true : listener.IgnoreWriteExceptions;
o_stream = new ResponseStream (stream, context.Response, ign);
}
return o_stream;
}
private static void StreamFile(HttpContext context)
{
try
{
var fileId = context.Request[FilesLinkUtility.FileId];
var auth = context.Request[FilesLinkUtility.AuthKey];
var userId = context.Request[CommonLinkUtility.ParamName_UserUserID];
Global.Logger.Debug("GoogleDriveApp: get file stream " + fileId);
int validateTimespan;
int.TryParse(WebConfigurationManager.AppSettings["files.stream-url-minute"], out validateTimespan);
if (validateTimespan <= 0) validateTimespan = 5;
var validateResult = EmailValidationKeyProvider.ValidateEmailKey(fileId + userId, auth, TimeSpan.FromMinutes(validateTimespan));
if (validateResult != EmailValidationKeyProvider.ValidationResult.Ok)
{
var exc = new HttpException((int)HttpStatusCode.Forbidden, FilesCommonResource.ErrorMassage_SecurityException);
Global.Logger.Error(string.Format("GoogleDriveApp: validate error {0} {1}: {2}", FilesLinkUtility.AuthKey, validateResult, context.Request.Url), exc);
throw exc;
}
var token = Token.GetToken(AppAttr, userId);
var driveFile = GetDriveFile(fileId, token);
var jsonFile = JObject.Parse(driveFile);
var downloadUrl = jsonFile.Value<string>("downloadUrl");
var contentLength = jsonFile.Value<string>("fileSize");
if (string.IsNullOrEmpty(downloadUrl))
{
Global.Logger.Error("GoogleDriveApp: downloadUrl is null");
throw new Exception("downloadUrl is null");
}
Global.Logger.Debug("GoogleDriveApp: get file stream downloadUrl - " + downloadUrl);
var request = WebRequest.Create(downloadUrl);
request.Method = "GET";
request.Headers.Add("Authorization", "Bearer " + token);
using (var response = request.GetResponse())
using (var stream = new ResponseStream(response))
{
stream.StreamCopyTo(context.Response.OutputStream);
Global.Logger.Debug("GoogleDriveApp: get file stream contentLength - " + contentLength);
context.Response.AddHeader("Content-Length", contentLength);
}
}
catch (Exception ex)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
context.Response.Write(ex.Message);
Global.Logger.Error("GoogleDriveApp: Error request " + context.Request.Url, ex);
}
try
{
context.Response.Flush();
context.Response.End();
}
catch (HttpException)
{
}
}
private static string CreateFile(string contentUrl, string fileName, string folderId, Token token)
{
if (string.IsNullOrEmpty(contentUrl))
{
Global.Logger.Error("GoogleDriveApp: downloadUrl is null");
throw new Exception("downloadUrl is null");
}
Global.Logger.Debug("GoogleDriveApp: create from - " + contentUrl);
var request = WebRequest.Create(contentUrl);
using (var response = request.GetResponse())
using (var content = new ResponseStream(response))
{
return CreateFile(content, fileName, folderId, token);
}
}
private void init ()
{
_context = new HttpListenerContext (this);
_inputState = InputState.RequestLine;
_inputStream = null;
_lineState = LineState.None;
_outputStream = null;
_position = 0;
_prefix = null;
_requestBuffer = new MemoryStream ();
}
private static string CreateConvertedFile(string driveFile, Token token)
{
var jsonFile = JObject.Parse(driveFile);
var fileName = GetCorrectTitle(jsonFile);
fileName = FileUtility.ReplaceFileExtension(fileName, FileUtility.GetInternalExtension(fileName));
var folderId = (string)jsonFile.SelectToken("parents[0].id");
Global.Logger.Info("GoogleDriveApp: create copy - " + fileName);
var mimeType = (jsonFile.Value<string>("mimeType") ?? "").ToLower();
FileType fileType;
if (GoogleMimeTypes.TryGetValue(mimeType, out fileType))
{
var links = jsonFile["exportLinks"];
if (links == null)
{
Global.Logger.Error("GoogleDriveApp: exportLinks is null");
throw new Exception("exportLinks is null");
}
var internalExt = FileUtility.InternalExtension[fileType];
var requiredMimeType = MimeMapping.GetMimeMapping(internalExt);
var exportLinks = links.ToObject<Dictionary<string, string>>();
var downloadUrl = exportLinks[requiredMimeType] ?? "";
if (string.IsNullOrEmpty(downloadUrl))
{
Global.Logger.Error("GoogleDriveApp: exportLinks without requested mime - " + links);
throw new Exception("exportLinks without requested mime");
}
var request = WebRequest.Create(downloadUrl);
request.Method = "GET";
request.Headers.Add("Authorization", "Bearer " + token);
Global.Logger.Debug("GoogleDriveApp: download exportLink - " + downloadUrl);
try
{
using (var response = request.GetResponse())
using (var fileStream = new ResponseStream(response))
{
driveFile = CreateFile(fileStream, fileName, folderId, token);
}
}
catch (WebException e)
{
Global.Logger.Error("GoogleDriveApp: Error download exportLink", e);
request.Abort();
var httpResponse = (HttpWebResponse)e.Response;
if (httpResponse.StatusCode == HttpStatusCode.Unauthorized && fileType == FileType.Spreadsheet)
{
throw new SecurityException(FilesCommonResource.AppDriveSpreadsheetException, e);
}
}
}
else
{
var downloadUrl = jsonFile.Value<string>("downloadUrl");
var ext = GetCorrectExt(jsonFile);
var convertedUrl = ConvertFile(downloadUrl, ext, token);
driveFile = CreateFile(convertedUrl, fileName, folderId, token);
}
jsonFile = JObject.Parse(driveFile);
return jsonFile.Value<string>("id");
}
private static File CreateFileFromUri(Folder folder, string fileUri, string fileTitle)
{
if (string.IsNullOrEmpty(fileTitle))
fileTitle = Path.GetFileName(HttpUtility.UrlDecode(fileUri));
var file = new File
{
Title = fileTitle,
FolderID = folder.ID
};
var req = (HttpWebRequest)WebRequest.Create(fileUri);
using (var fileDao = Global.DaoFactory.GetFileDao())
using (var fileStream = new ResponseStream(req.GetResponse()))
{
file.ContentLength = fileStream.Length;
return fileDao.SaveFile(file, fileStream);
}
}
internal RequestState(HttpRequestMessage request, PathString pathBase)
{
_request = request;
_responseTcs = new TaskCompletionSource<HttpResponseMessage>();
_requestAbortedSource = new CancellationTokenSource();
_pipelineFinished = false;
if (request.RequestUri.IsDefaultPort)
{
request.Headers.Host = request.RequestUri.Host;
}
else
{
request.Headers.Host = request.RequestUri.GetComponents(UriComponents.HostAndPort, UriFormat.UriEscaped);
}
HttpContext = new DefaultHttpContext();
HttpContext.Features.Set<IHttpRequestFeature>(new RequestFeature());
_responseFeature = new ResponseFeature();
HttpContext.Features.Set<IHttpResponseFeature>(_responseFeature);
var serverRequest = HttpContext.Request;
serverRequest.Protocol = "HTTP/" + request.Version.ToString(2);
serverRequest.Scheme = request.RequestUri.Scheme;
serverRequest.Method = request.Method.ToString();
var fullPath = PathString.FromUriComponent(request.RequestUri);
PathString remainder;
if (fullPath.StartsWithSegments(pathBase, out remainder))
{
serverRequest.PathBase = pathBase;
serverRequest.Path = remainder;
}
else
{
serverRequest.PathBase = PathString.Empty;
serverRequest.Path = fullPath;
}
serverRequest.QueryString = QueryString.FromUriComponent(request.RequestUri);
foreach (var header in request.Headers)
{
serverRequest.Headers.Append(header.Key, header.Value.ToArray());
}
var requestContent = request.Content;
if (requestContent != null)
{
foreach (var header in request.Content.Headers)
{
serverRequest.Headers.Append(header.Key, header.Value.ToArray());
}
}
_responseStream = new ResponseStream(ReturnResponseMessage, AbortRequest);
HttpContext.Response.Body = _responseStream;
HttpContext.Response.StatusCode = 200;
HttpContext.RequestAborted = _requestAbortedSource.Token;
}
void Init()
{
context_bound = false;
i_stream = null;
o_stream = null;
prefix = null;
chunked = false;
ms = new MemoryStream();
position = 0;
input_state = InputState.RequestLine;
line_state = LineState.None;
context = new HttpListenerContext(this);
}
public override void setResponseStream (ResponseStream __p1) {
_facesContex.setResponseStream (__p1);
}
private void Init()
{
_chunked = false;
_context = new HttpListenerContext (this);
_contextWasBound = false;
_inputState = InputState.RequestLine;
_inputStream = null;
_lineState = LineState.None;
_outputStream = null;
_position = 0;
_prefix = null;
_requestBuffer = new MemoryStream ();
_timeout = 90000; // 90k ms for first request, 15k ms from then on.
}
private void PageLoad()
{
var editPossible = !RequestEmbedded;
var isExtenral = false;
File file;
var fileUri = string.Empty;
try
{
if (string.IsNullOrEmpty(RequestFileUrl))
{
_fileNew = (Request["new"] ?? "") == "true";
var app = ThirdPartySelector.GetAppByFileId(RequestFileId);
if (app == null)
{
var ver = string.IsNullOrEmpty(Request[FilesLinkUtility.Version]) ? -1 : Convert.ToInt32(Request[FilesLinkUtility.Version]);
file = DocumentServiceHelper.GetParams(RequestFileId, ver, RequestShareLinkKey, _fileNew, editPossible, !RequestView, out _docParams);
_fileNew = _fileNew && file.Version == 1 && file.ConvertedType != null && file.CreateOn == file.ModifiedOn;
}
else
{
isExtenral = true;
bool editable;
_thirdPartyApp = true;
file = app.GetFile(RequestFileId, out editable);
file = DocumentServiceHelper.GetParams(file, true, true, true, editable, editable, editable, out _docParams);
_docParams.FileUri = app.GetFileStreamUrl(file);
_docParams.FolderUrl = string.Empty;
}
}
else
{
isExtenral = true;
fileUri = RequestFileUrl;
var fileTitle = Request[FilesLinkUtility.FileTitle];
if (string.IsNullOrEmpty(fileTitle))
fileTitle = Path.GetFileName(HttpUtility.UrlDecode(fileUri)) ?? "";
if (CoreContext.Configuration.Standalone)
{
try
{
var webRequest = WebRequest.Create(RequestFileUrl);
using (var response = webRequest.GetResponse())
using (var responseStream = new ResponseStream(response))
{
var externalFileKey = DocumentServiceConnector.GenerateRevisionId(RequestFileUrl);
fileUri = DocumentServiceConnector.GetExternalUri(responseStream, MimeMapping.GetMimeMapping(fileTitle), externalFileKey);
}
}
catch (Exception error)
{
Global.Logger.Error("Cannot receive external url for \"" + RequestFileUrl + "\"", error);
}
}
file = new File
{
ID = RequestFileUrl,
Title = Global.ReplaceInvalidCharsAndTruncate(fileTitle)
};
file = DocumentServiceHelper.GetParams(file, true, true, true, false, false, false, out _docParams);
_docParams.CanEdit = editPossible && !CoreContext.Configuration.Standalone;
_editByUrl = true;
_docParams.FileUri = fileUri;
}
}
catch (Exception ex)
{
_errorMessage = ex.Message;
return;
}
if (_docParams.ModeWrite && FileConverter.MustConvert(file))
{
try
{
file = FileConverter.ExecDuplicate(file, RequestShareLinkKey);
}
catch (Exception e)
{
_docParams = null;
_errorMessage = e.Message;
return;
}
var comment = "#message/" + HttpUtility.UrlEncode(FilesCommonResource.CopyForEdit);
Response.Redirect(FilesLinkUtility.GetFileWebEditorUrl(file.ID) + comment);
return;
}
Title = file.Title;
if (string.IsNullOrEmpty(_docParams.FolderUrl))
{
_docParams.FolderUrl = Request[FilesLinkUtility.FolderUrl] ?? "";
}
if (MobileDetector.IsRequestMatchesMobile(true))
{
_docParams.FolderUrl = string.Empty;
}
if (RequestEmbedded)
{
_docParams.Type = DocumentServiceParams.EditorType.Embedded;
var shareLinkParam = "&" + FilesLinkUtility.DocShareKey + "=" + RequestShareLinkKey;
_docParams.ViewerUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.FilesBaseAbsolutePath + FilesLinkUtility.EditorPage + "?" + FilesLinkUtility.Action + "=view" + shareLinkParam);
_docParams.DownloadUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.FileHandlerPath + "?" + FilesLinkUtility.Action + "=download" + shareLinkParam);
_docParams.EmbeddedUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.FilesBaseAbsolutePath + FilesLinkUtility.EditorPage + "?" + FilesLinkUtility.Action + "=embedded" + shareLinkParam);
}
else
{
_docParams.Type = IsMobile ? DocumentServiceParams.EditorType.Mobile : DocumentServiceParams.EditorType.Desktop;
if (FileSharing.CanSetAccess(file))
{
_docParams.SharingSettingsUrl = CommonLinkUtility.GetFullAbsolutePath(Share.Location + "?" + FilesLinkUtility.FileId + "=" + file.ID);
}
}
if (!isExtenral)
{
_docKeyForTrack = DocumentServiceHelper.GetDocKey(file.ID, -1, DateTime.MinValue);
FileMarker.RemoveMarkAsNew(file);
}
if (_docParams.ModeWrite)
{
_tabId = FileTracker.Add(file.ID, _fileNew);
_fixedVersion = FileTracker.FixedVersion(file.ID);
_docParams.FileChoiceUrl = CommonLinkUtility.GetFullAbsolutePath(FileChoice.Location) + "?" + FileChoice.DocumentTypeParam + "=" + FilterType.SpreadsheetsOnly;
}
else
{
_docParams.LinkToEdit = _editByUrl
? CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebEditorExternalUrl(fileUri, file.Title))
: CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebEditorUrl(file.ID));
if (FileConverter.MustConvert(_docParams.File)) _editByUrl = true;
}
}
private static void StoringFileAfterError(string fileId, string userId, string downloadUri)
{
try
{
var fileName = fileId + FileUtility.GetFileExtension(downloadUri);
var path = string.Format(@"save_crash\{0}\{1}_{2}",
DateTime.UtcNow.ToString("yyyy_MM_dd"),
userId,
fileName);
var store = Global.GetStore();
var req = (HttpWebRequest)WebRequest.Create(downloadUri);
using (var fileStream = new ResponseStream(req.GetResponse()))
{
store.Save(FileConstant.StorageDomainTmp, path, fileStream);
}
Global.Logger.DebugFormat("DocService storing to {0}", path);
}
catch (Exception ex)
{
Global.Logger.Error("DocService Error on save file to temp store", ex);
}
}
public Response(CancellationToken clientToken, Action flush)
{
_clientToken = clientToken;
_stream = new ResponseStream();
_flush = flush;
}
internal void Close(bool force)
{
if (_socket != null) {
if (_outputStream != null) {
_outputStream.Close ();
_outputStream = null;
}
force |= !_context.Request.KeepAlive;
if (!force)
force = _context.Response.Headers ["Connection"] == "close";
if (!force && _context.Request.FlushInput ()) {
if (_chunked && !_context.Response.ForceCloseChunked) {
// Don't close. Keep working.
_reuses++;
Unbind ();
Init ();
BeginReadRequest ();
return;
}
// _reuses++;
// Unbind ();
// Init ();
// BeginReadRequest ();
//
// return;
}
var socket = _socket;
_socket = null;
try {
if (socket != null)
socket.Shutdown (SocketShutdown.Both);
} catch {
} finally {
if (socket != null)
socket.Close ();
}
Unbind ();
RemoveConnection ();
return;
}
}
private void disposeStream ()
{
if (_stream == null)
return;
_inputStream = null;
_outputStream = null;
_stream.Dispose ();
_stream = null;
}
internal void Close (bool force)
{
if (_socket != null) {
if (_outputStream != null) {
_outputStream.Close ();
_outputStream = null;
}
var req = _context.Request;
var res = _context.Response;
force |= !req.KeepAlive;
if (!force)
force = res.Headers ["Connection"] == "close";
if (!force &&
req.FlushInput () &&
(!_chunked || (_chunked && !res.ForceCloseChunked))) {
// Don't close. Keep working.
_reuses++;
unbind ();
init ();
BeginReadRequest ();
return;
}
var socket = _socket;
_socket = null;
try {
socket.Shutdown (SocketShutdown.Both);
}
catch {
}
finally {
if (socket != null)
socket.Close ();
}
unbind ();
removeConnection ();
return;
}
}
public ResponseStream GetResponseStream ()
{
// TODO: Can we get this stream before reading the input?
if (_outputStream != null || _socket == null)
return _outputStream;
lock (_sync) {
if (_socket == null)
return _outputStream;
var lsnr = _context.Listener;
var ignore = lsnr != null ? lsnr.IgnoreWriteExceptions : true;
_outputStream = new ResponseStream (_stream, _context.Response, ignore);
return _outputStream;
}
}
internal void SendHeaders (bool closing, MemoryStream ms)
{
//TODO: When do we send KeepAlive?
Encoding encoding = content_encoding;
if (encoding == null)
encoding = Encoding.Default;
if (content_type != null) {
if (content_encoding != null && content_type.IndexOf ("charset=") == -1) {
string enc_name = content_encoding.WebName;
headers.SetInternal ("Content-Type", content_type + "; charset=" + enc_name);
} else {
headers.SetInternal ("Content-Type", content_type);
}
}
if (headers ["Server"] == null)
headers.SetInternal ("Server", "Mono-HTTPAPI/1.0");
CultureInfo inv = CultureInfo.InvariantCulture;
if (headers ["Date"] == null)
headers.SetInternal ("Date", DateTime.UtcNow.ToString ("r", inv));
if (!chunked) {
if (!cl_set && closing) {
cl_set = true;
content_length = 0;
}
if (cl_set)
headers.SetInternal ("Content-Length", content_length.ToString (inv));
}
Version v = context.Request.ProtocolVersion;
if (!cl_set && !chunked && v >= HttpVersion.Version11)
chunked = true;
/* Apache forces closing the connection for these status codes:
* HttpStatusCode.BadRequest 400
* HttpStatusCode.RequestTimeout 408
* HttpStatusCode.LengthRequired 411
* HttpStatusCode.RequestEntityTooLarge 413
* HttpStatusCode.RequestUriTooLong 414
* HttpStatusCode.InternalServerError 500
* HttpStatusCode.ServiceUnavailable 503
*/
bool conn_close = (status_code == 400 || status_code == 408 || status_code == 411 ||
status_code == 413 || status_code == 414 || status_code == 500 ||
status_code == 503);
if (conn_close == false) {
conn_close = (context.Request.Headers ["connection"] == "close");
conn_close |= (v <= HttpVersion.Version10);
}
// They sent both KeepAlive: true and Connection: close!?
if (!keep_alive || conn_close)
headers.SetInternal ("Connection", "close");
if (chunked)
headers.SetInternal ("Transfer-Encoding", "chunked");
int chunked_uses = context.Connection.ChunkedUses;
if (chunked_uses >= 100) {
force_close_chunked = true;
if (!conn_close)
headers.SetInternal ("Connection", "close");
}
if (location != null)
headers.SetInternal ("Location", location);
if (cookies != null) {
bool firstDone = false;
StringBuilder cookieSB = new StringBuilder ();
foreach (Cookie cookie in cookies) {
if (firstDone)
cookieSB.Append (",");
firstDone = true;
cookieSB.Append (MonoHttp.Utility.ToClientString (cookie));
}
headers.SetInternal("Set-Cookie2", cookieSB.ToString ());
}
StreamWriter writer = new StreamWriter (ms, encoding);
writer.Write ("HTTP/{0} {1} {2}\r\n", version, status_code, status_description);
string headers_str = headers.ToString ();
writer.Write (headers_str);
writer.Flush ();
int preamble = encoding.GetPreamble ().Length;
if (output_stream == null)
output_stream = context.Connection.GetResponseStream ();
/* Assumes that the ms was at position 0 */
ms.Position = preamble;
HeadersSent = true;
}
void Init()
{
context_bound = false;
i_stream = null;
o_stream = null;
prefix = null;
chunked = false;
ms = new MemoryStream ();
position = 0;
input_state = InputState.RequestLine;
line_state = LineState.None;
context = new HttpListenerContext (this);
s_timeout = 90000; // 90k ms for first request, 15k ms from then on
}
public ResponseStream GetResponseStream()
{
// TODO: Can we get this stream before reading the input?
if (_outputStream == null) {
var listener = _context.Listener;
var ignore = listener == null ? true : listener.IgnoreWriteExceptions;
_outputStream = new ResponseStream (_stream, _context.Response, ignore);
}
return _outputStream;
}
