/// <summary>
/// Handles the actual writing of the submitted data to the file system.
/// </summary>
/// <param name="transfer">The processed transfer.</param>
/// <param name="dataBlock">A data block that contains a chunk of data
/// which should be written to the file system.</param>
protected override void WriteBufferedDataBlockImpl(TTransfer transfer, BufferedDataBlock dataBlock)
{
TempStream stream = GetCachedTempData(transfer, dataBlock.Offset);
byte[] data = dataBlock.Data;
stream.Write(data, 0, data.Length);
}
private bool parseImage()
{
_image = ImageIO.read(_is);
_width = _image.getWidth();
_height = _image.getHeight();
TempStream ts = new TempStream();
WriteStream os = new WriteStream(ts);
try {
ImageIO.write(_image, "jpeg", os);
} finally {
os.close();
}
/*
* os = Vfs.openWrite("file:/tmp/caucho/qa/test.jpg");
* try {
* ImageIO.write(_image, "jpeg", os);
* } finally {
* os.close();
* }
*
* os = Vfs.openWrite("file:/tmp/caucho/qa/test.png");
* try {
* ImageIO.write(_image, "png", os);
* } finally {
* os.close();
* }
*/
return(parseImageJpeg(ts.openRead()));
}
public Stream GetFileStream(object id, int offset = 0)
{
var file = GetFileById(id);
if (file is SharePointFileErrorEntry)
{
return(null);
}
var fileInfo = File.OpenBinaryDirect(clientContext, (string)id);
clientContext.ExecuteQuery();
var tempBuffer = TempStream.Create();
using (var str = fileInfo.Stream)
{
if (str != null)
{
str.CopyTo(tempBuffer);
tempBuffer.Flush();
tempBuffer.Seek(offset, SeekOrigin.Begin);
}
}
return(tempBuffer);
}
/// <summary>
/// Handles the actual writing of the submitted data to the file system.
/// </summary>
/// <param name="transfer">The processed transfer.</param>
/// <param name="dataBlock">A data block that provides a data stream that
/// is written to the file system.</param>
protected override void WriteStreamedDataBlockImpl(TTransfer transfer, StreamedDataBlock dataBlock)
{
TempStream stream = GetCachedTempData(transfer, dataBlock.Offset);
//when it comes to reading from the source stream, make sure no limits (block or whole file size)
//are exceeded
if (!transfer.Token.MaxResourceSize.HasValue)
{
if (!transfer.Token.MaxBlockSize.HasValue)
{
//just write the stream - there is no limit
dataBlock.WriteTo(stream);
}
else
{
//the limit is the maximum block size
dataBlock.WriteTo(stream, transfer.Token.MaxBlockSize.Value);
}
}
else
{
//first we need to make sure we won't go over the max resource size
long maxSize = transfer.Token.MaxResourceSize.Value - dataBlock.Offset;
if (transfer.Token.MaxBlockSize.HasValue)
{
//the other limit is the block size - take whatever is smaller
maxSize = Math.Min(maxSize, transfer.Token.MaxBlockSize.Value);
}
//the limit is the maximum block size
dataBlock.WriteTo(stream, maxSize);
}
}
public override string SavePrivate(string domain, string path, System.IO.Stream stream, DateTime expires)
{
using var storage = GetStorage();
var objectKey = MakePath(domain, path);
var buffered = TempStream.GetBuffered(stream);
var uploadObjectOptions = new UploadObjectOptions
{
PredefinedAcl = PredefinedObjectAcl.BucketOwnerFullControl
};
buffered.Position = 0;
var uploaded = storage.UploadObject(_bucket, MakePath(domain, path), "application/octet-stream", buffered, uploadObjectOptions, null);
uploaded.CacheControl = string.Format("public, maxage={0}", (int)TimeSpan.FromDays(5).TotalSeconds);
uploaded.ContentDisposition = "attachment";
if (uploaded.Metadata == null)
{
uploaded.Metadata = new Dictionary <string, string>();
}
uploaded.Metadata["Expires"] = DateTime.UtcNow.Add(TimeSpan.FromDays(5)).ToString("R");
uploaded.Metadata.Add("private-expire", expires.ToFileTimeUtc().ToString(CultureInfo.InvariantCulture));
storage.UpdateObject(uploaded);
using var mStream = new MemoryStream(Encoding.UTF8.GetBytes(_json ?? ""));
var preSignedURL = FromServiceAccountData(mStream).Sign(RequestTemplate.FromBucket(_bucket).WithObjectName(MakePath(domain, path)), UrlSigner.Options.FromExpiration(expires));
//TODO: CNAME!
return(preSignedURL);
}
public Stream DownloadStream(BoxFile file, int offset = 0)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if (offset > 0 && file.Size.HasValue)
{
return(_boxClient.FilesManager.DownloadAsync(file.Id, startOffsetInBytes: offset, endOffsetInBytes: (int)file.Size - 1).Result);
}
var str = _boxClient.FilesManager.DownloadAsync(file.Id).Result;
if (offset == 0)
{
return(str);
}
var tempBuffer = TempStream.Create();
if (str != null)
{
str.CopyTo(tempBuffer);
tempBuffer.Flush();
tempBuffer.Seek(offset, SeekOrigin.Begin);
str.Dispose();
}
return(tempBuffer);
}
public Stream GetFileStream(File file, long offset)
{
var fileToDownload = GetFileById(file.ID);
if (fileToDownload == null)
{
throw new ArgumentNullException("file", FilesCommonResource.ErrorMassage_FileNotFound);
}
if (fileToDownload is ErrorEntry)
{
throw new Exception(((ErrorEntry)fileToDownload).Error);
}
var fileStream = fileToDownload.GetDataTransferAccessor().GetDownloadStream();
if (fileStream != null && offset > 0)
{
if (!fileStream.CanSeek)
{
var tempBuffer = TempStream.Create();
fileStream.CopyTo(tempBuffer);
tempBuffer.Flush();
tempBuffer.Seek(offset, SeekOrigin.Begin);
fileStream.Dispose();
return(tempBuffer);
}
fileStream.Seek(offset, SeekOrigin.Begin);
}
return(fileStream);
}
public ZipWriteOperator(TempStream tempStream, string targetFile)
{
file = new FileStream(targetFile, FileMode.Create);
gZipOutputStream = new GZipOutputStream(file);
tarOutputStream = new TarOutputStream(gZipOutputStream, Encoding.UTF8);
TempStream = tempStream;
}
private bool parseImageJpeg(ReadStream is)
{
int ch = @is.read();
if (ch != 0xff)
{
return(false);
}
if (@is.read() != 0xd8)
{
return(false);
}
TempStream ts = new TempStream();
WriteStream ws = new WriteStream(ts);
ws.write(0xff);
ws.write(0xd8);
@is.writeToStream(ws);
ws.close();
// XXX: issues with _jpegHead vs ts.openReadAndSaveBuffer()
_jpegHead = ts.getHead();
@is.close();
_is = new ReadStream();
ts.openRead(_is);
parseJPEG();
return(true);
}
/**
* Closes the output buffer.
*/
public void close()
{
_state |= OutputModule.PHP_OUTPUT_HANDLER_END;
if (!callCallback())
{
// all data that has and ever will be written has now been processed
_state = 0;
doFlush();
}
WriteStream @out = _out;
_out = null;
TempStream tempStream = _tempStream;
_tempStream = null;
try {
if (@out != null)
{
@out.close();
}
} catch (IOException e) {
log.log(Level.FINER, e.ToString(), e);
}
if (tempStream != null)
{
tempStream.destroy();
}
}
public override void RunJob(DistributedTask _, CancellationToken cancellationToken)
{
base.RunJob(_, cancellationToken);
using var scope = ThirdPartyOperation.CreateScope();
var globalStore = scope.ServiceProvider.GetService <GlobalStore>();
var filesLinkUtility = scope.ServiceProvider.GetService <FilesLinkUtility>();
using var stream = TempStream.Create();
using (var zip = new ZipOutputStream(stream, true)
{
CompressionLevel = Ionic.Zlib.CompressionLevel.Level3,
AlternateEncodingUsage = ZipOption.AsNecessary,
AlternateEncoding = Encoding.UTF8,
})
{
(ThirdPartyOperation as FileDownloadOperation <string>).CompressToZip(zip, stream, scope);
(DaoOperation as FileDownloadOperation <int>).CompressToZip(zip, stream, scope);
}
if (stream != null)
{
stream.Position = 0;
const string fileName = FileConstant.DownloadTitle + ".zip";
var store = globalStore.GetStore();
store.Save(
FileConstant.StorageDomainTmp,
string.Format(@"{0}\{1}", ((IAccount)Thread.CurrentPrincipal.Identity).ID, fileName),
stream,
"application/zip",
"attachment; filename=\"" + fileName + "\"");
Status = string.Format("{0}?{1}=bulk", filesLinkUtility.FileHandlerPath, FilesLinkUtility.Action);
}
}
/// <summary>
/// Performs housekeeping code once a transfer is paused. This implementation
/// closes an open file stream on the temporary file.
/// </summary>
/// <param name="transfer">The paused transfer.</param>
protected override void PauseTransferImpl(TTransfer transfer)
{
if (fileCache.ContainsKey(transfer.TransferId))
{
TempStream tempStream = GetCachedTempData(transfer, null);
tempStream.Pause();
}
}
public static byte[] IronRead(this IDataStore store, string domain, string path, int tryCount)
{
using (var ms = TempStream.Create())
{
IronReadToStream(store, domain, path, tryCount, ms);
return(ms.GetStreamBuffer());
}
}
private const int BufferSize = 2048;//NOTE: set to 2048 to fit in minimum tcp window
public static Stream IronReadStream(this IDataStore store, string domain, string path, int tryCount)
{
var ms = TempStream.Create();
IronReadToStream(store, domain, path, tryCount, ms);
ms.Seek(0, SeekOrigin.Begin);
return(ms);
}
public GoogleCloudStorage(
TempStream tempStream,
TenantManager tenantManager,
PathUtils pathUtils,
EmailValidationKeyProvider emailValidationKeyProvider,
IHttpContextAccessor httpContextAccessor,
IOptionsMonitor <ILog> options) : base(tempStream, tenantManager, pathUtils, emailValidationKeyProvider, httpContextAccessor, options)
{
}
private List <XElement> BackupDatabase(int tenant, ConnectionStringSettings connectionString, IDataWriteOperator writer)
{
var xml = new List <XElement>();
var errors = 0;
var timeout = TimeSpan.FromSeconds(1);
using (var dbHelper = new DbHelper(connectionString))
{
var tables = dbHelper.GetTables();
for (int i = 0; i < tables.Count; i++)
{
var table = tables[i];
OnProgressChanged(table, (int)(i / (double)tables.Count * 100));
if (processedTables.Contains(table, StringComparer.InvariantCultureIgnoreCase))
{
continue;
}
xml.Add(new XElement(table));
DataTable dataTable = null;
while (true)
{
try
{
dataTable = dbHelper.GetTable(table, tenant);
break;
}
catch
{
errors++;
if (20 < errors)
{
throw;
}
Thread.Sleep(timeout);
}
}
foreach (DataColumn c in dataTable.Columns)
{
if (c.DataType == typeof(DateTime))
{
c.DateTimeMode = DataSetDateTime.Unspecified;
}
}
using (var file = TempStream.Create())
{
dataTable.WriteXml(file, XmlWriteMode.WriteSchema);
writer.WriteEntry(string.Format("{0}\\{1}\\{2}", Name, connectionString.Name, table).ToLower(), file);
}
processedTables.Add(table);
}
}
return(xml);
}
protected void CopyFileOnFileSystem2(ZipFileItem sourceFile, ZipFileItem targetFile)
{
using (TempStream tempStream = Configuration.TempStreamFactory.CreateTempStream()) {
sourceFile.Node.FileEntry.Extract(tempStream);
tempStream.Position = 0;
var zip = NodeRepository.ZipFile;
NodeRepository.PerformWriteAction(() => zip.AddEntry(targetFile.QualifiedIdentifier, tempStream));
}
}
public GoogleDriveStorage(
ConsumerFactory consumerFactory,
FileUtility fileUtility,
IOptionsMonitor <ILog> monitor,
TempStream tempStream)
{
ConsumerFactory = consumerFactory;
FileUtility = fileUtility;
Log = monitor.Get("ASC.Files");
TempStream = tempStream;
}
public File <string> SaveFile(File <string> file, Stream fileStream)
{
if (fileStream == null)
{
throw new ArgumentNullException("fileStream");
}
ICloudFileSystemEntry entry = null;
if (file.ID != null)
{
entry = ProviderInfo.Storage.GetFile(MakePath(file.ID), null);
}
else if (file.FolderID != null)
{
var folder = GetFolderById(file.FolderID);
file.Title = GetAvailableTitle(file.Title, folder, IsExist);
entry = ProviderInfo.Storage.CreateFile(folder, file.Title);
}
if (entry == null)
{
return(null);
}
try
{
entry.GetDataTransferAccessor().Transfer(TempStream.GetBuffered(fileStream), nTransferDirection.nUpload);
}
catch (SharpBoxException e)
{
var webException = (WebException)e.InnerException;
if (webException != null)
{
var response = ((HttpWebResponse)webException.Response);
if (response != null)
{
if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden)
{
throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_Create);
}
}
throw;
}
}
if (file.ID != null && !entry.Name.Equals(file.Title))
{
file.Title = GetAvailableTitle(file.Title, entry.Parent, IsExist);
ProviderInfo.Storage.RenameFileSystemEntry(entry, file.Title);
}
return(ToFile(entry));
}
OutputBuffer(OutputBuffer next, Env env, Callable callback,
int chunkSize, bool erase)
{
_next = next;
if (_next != null)
{
_level = _next._level + 1;
}
else
{
_level = 1;
}
_erase = erase;
_chunkSize = chunkSize;
_env = env;
_callback = callback;
_tempStream = new TempStream();
_out = new WriteStream(_tempStream);
_out.setNewlineString("\n");
string encoding = env.getOutputEncoding();
if (encoding != null)
{
try {
_out.setEncoding(encoding);
}
catch (UnsupportedEncodingException e) {
if (log.isLoggable(Level.WARNING))
{
log.log(Level.WARNING, e.ToString(), e);
}
try {
_out.setEncoding("UTF-8");
}
catch (UnsupportedEncodingException e2) {
if (log.isLoggable(Level.WARNING))
{
log.log(Level.WARNING, e.ToString(), e2);
}
}
}
}
_state = OutputModule.PHP_OUTPUT_HANDLER_START;
_haveFlushed = false;
}
public Uri Save(string domain, string path, Stream stream, string contentType,
string contentDisposition, ACL acl, string contentEncoding = null, int cacheDays = 5)
{
var buffered = TempStream.GetBuffered(stream);
if (QuotaController != null)
{
QuotaController.QuotaUsedCheck(buffered.Length);
}
var mime = string.IsNullOrEmpty(contentType)
? MimeMapping.GetMimeMapping(Path.GetFileName(path))
: contentType;
using var storage = GetStorage();
var uploadObjectOptions = new UploadObjectOptions
{
PredefinedAcl = acl == ACL.Auto ? GetDomainACL(domain) : GetGoogleCloudAcl(acl)
};
buffered.Position = 0;
var uploaded = storage.UploadObject(_bucket, MakePath(domain, path), mime, buffered, uploadObjectOptions, null);
uploaded.ContentEncoding = contentEncoding;
uploaded.CacheControl = string.Format("public, maxage={0}", (int)TimeSpan.FromDays(cacheDays).TotalSeconds);
if (uploaded.Metadata == null)
{
uploaded.Metadata = new Dictionary <string, string>();
}
uploaded.Metadata["Expires"] = DateTime.UtcNow.Add(TimeSpan.FromDays(cacheDays)).ToString("R");
if (!string.IsNullOrEmpty(contentDisposition))
{
uploaded.ContentDisposition = contentDisposition;
}
else if (mime == "application/octet-stream")
{
uploaded.ContentDisposition = "attachment";
}
storage.UpdateObject(uploaded);
// InvalidateCloudFront(MakePath(domain, path));
QuotaUsedAdd(domain, buffered.Length);
return(GetUri(domain, path));
}
public SharePointProviderInfo(
IOptionsMonitor <ILog> options,
IServiceProvider serviceProvider,
TenantUtil tenantUtil,
SharePointProviderInfoHelper sharePointProviderInfoHelper,
TempStream tempStream)
{
Log = options.CurrentValue;
ServiceProvider = serviceProvider;
TenantUtil = tenantUtil;
SharePointProviderInfoHelper = sharePointProviderInfoHelper;
TempStream = tempStream;
}
public ILiteRepository GetRepository()
{
if (_tempStream == null)
{
_tempStream = new TempStream("abremir.postcrossing.engine.tests.litedb");
}
var liteRepository = new LiteRepository(_tempStream);
RepositoryService.SetupIndexes(liteRepository.Database);
return(liteRepository);
}
public ILiteRepository GetRepository()
{
if (_tempStream is null)
{
_tempStream = new TempStream("abremir.AllMyBricks.Data.Tests.litedb");
}
var liteRepository = new LiteRepository(_tempStream);
RepositoryService.RunMigrationsAndSetupIndexes(liteRepository.Database);
return(liteRepository);
}
public RackspaceCloudStorage(
TempPath tempPath,
TempStream tempStream,
TenantManager tenantManager,
PathUtils pathUtils,
EmailValidationKeyProvider emailValidationKeyProvider,
IHttpContextAccessor httpContextAccessor,
IOptionsMonitor <ILog> options)
: base(tempStream, tenantManager, pathUtils, emailValidationKeyProvider, httpContextAccessor, options)
{
_logger = options.Get("ASC.Data.Storage.Rackspace.RackspaceCloudStorage");
TempPath = tempPath;
}
public override Uri Save(string domain, string path, Stream stream)
{
Log.Debug("Save " + path);
var buffered = TempStream.GetBuffered(stream);
if (QuotaController != null)
{
QuotaController.QuotaUsedCheck(buffered.Length);
}
if (path == null)
{
throw new ArgumentNullException("path");
}
if (buffered == null)
{
throw new ArgumentNullException("stream");
}
//Try seek to start
if (buffered.CanSeek)
{
buffered.Seek(0, SeekOrigin.Begin);
}
//Lookup domain
var target = GetTarget(domain, path);
CreateDirectory(target);
//Copy stream
//optimaze disk file copy
long fslen;
if (buffered is FileStream fileStream)
{
File.Copy(fileStream.Name, target, true);
fslen = fileStream.Length;
}
else
{
using var fs = File.Open(target, FileMode.Create);
buffered.CopyTo(fs);
fslen = fs.Length;
}
QuotaUsedAdd(domain, fslen);
Crypt.EncryptFile(target);
return(GetUri(domain, path));
}
public static void Site(string URL, long Size, string Word, long Amount)
{
CJ = new CookieContainer();
HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(new Uri(URL));
Request.ContentType = "application/x-www-form-urlencoded";
Request.Referer = URL;
Request.UserAgent = GenerateRandomUserAgent();
Request.CookieContainer = CJ;
HttpWebResponse Response = (HttpWebResponse)Request.GetResponse();
Thread.Sleep(1 * 1000);
List <HttpWebRequest> ConnectionList = new List <HttpWebRequest>();
Stream TempStream;
Random RandomLength = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < Amount; i++)
{
HttpWebRequest TempRequest = (HttpWebRequest)WebRequest.Create(new Uri(URL));
TempRequest.ContentType = "application/x-www-form-urlencoded";
TempRequest.UserAgent = GenerateRandomUserAgent();
TempRequest.CookieContainer = CJ;
TempRequest.Method = WebRequestMethods.Http.Post;
TempRequest.KeepAlive = true;
TempRequest.ContentLength = RandomLength.Next(20000000, 100000000);
TempRequest.ServicePoint.ConnectionLimit = 10000;
ConnectionList.Add(TempRequest);
}
while (true)
{
for (int i = 0; i < Amount; i++)
{
for (long j = 0; j < Size; j++)
{
TempStream = ConnectionList[i].GetRequestStream();
TempStream.Write(Encoding.Default.GetBytes(Word), 0, Encoding.Default.GetBytes(Word).Length);
Console.WriteLine((enUS.get(Global.Messages.WEB_SENDED)).Replace("[word]", Word).Replace("[url]", URL).Replace("[size]", "" + Size));
}
}
GC.Collect();
}
}
public DiscDataStore(
TempStream tempStream,
TenantManager tenantManager,
PathUtils pathUtils,
EmailValidationKeyProvider emailValidationKeyProvider,
IHttpContextAccessor httpContextAccessor,
IOptionsMonitor <ILog> options,
EncryptionSettingsHelper encryptionSettingsHelper,
EncryptionFactory encryptionFactory)
: base(tempStream, tenantManager, pathUtils, emailValidationKeyProvider, httpContextAccessor, options)
{
EncryptionSettingsHelper = encryptionSettingsHelper;
EncryptionFactory = encryptionFactory;
}
private const int BufferSize = 2048; //NOTE: set to 2048 to fit in minimum tcp window
public static Stream GetBuffered(this Stream srcStream)
{
if (srcStream == null)
{
throw new ArgumentNullException("srcStream");
}
if (!srcStream.CanSeek || srcStream.CanTimeout)
{
//Buffer it
var memStream = TempStream.Create();
srcStream.StreamCopyTo(memStream);
memStream.Position = 0;
return(memStream);
}
return(srcStream);
}
public Stream DownloadStream(DriveFile file, int offset = 0)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
var downloadArg = string.Format("{0}?alt=media", file.Id);
var ext = MimeMapping.GetExtention(file.MimeType);
if (GoogleLoginProvider.GoogleDriveExt.Contains(ext))
{
var internalExt = FileUtility.GetGoogleDownloadableExtension(ext);
var requiredMimeType = MimeMapping.GetMimeMapping(internalExt);
downloadArg = string.Format("{0}/export?mimeType={1}",
file.Id,
HttpUtility.UrlEncode(requiredMimeType));
}
var request = WebRequest.Create(GoogleLoginProvider.GoogleUrlFile + downloadArg);
request.Method = "GET";
request.Headers.Add("Authorization", "Bearer " + AccessToken);
var response = (HttpWebResponse)request.GetResponse();
if (offset == 0 && file.Size.HasValue && file.Size > 0)
{
return(new ResponseStream(response.GetResponseStream(), file.Size.Value));
}
var tempBuffer = TempStream.Create();
using (var str = response.GetResponseStream())
{
if (str != null)
{
str.CopyTo(tempBuffer);
tempBuffer.Flush();
tempBuffer.Seek(offset, SeekOrigin.Begin);
}
}
return(tempBuffer);
}
