public void AppendContentStreamTest( string canonical_name, string localPath, string remoteFolderPath, string url, string user, string password, string repositoryId) { // var watch = Stopwatch.StartNew(); ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId); // watch.Stop(); // Console.WriteLine(String.Format("Created Session in {0} msec",watch.ElapsedMilliseconds)); // watch.Restart(); IFolder folder = (IFolder)session.GetObjectByPath(remoteFolderPath); // watch.Stop(); // Console.WriteLine(String.Format("Requested folder in {0} msec", watch.ElapsedMilliseconds)); string filename = "testfile.txt"; Dictionary <string, object> properties = new Dictionary <string, object>(); properties.Add(PropertyIds.Name, filename); properties.Add(PropertyIds.ObjectTypeId, "cmis:document"); try { IDocument doc = session.GetObjectByPath(remoteFolderPath + "/" + filename) as IDocument; if (doc != null) { doc.Delete(true); } } catch (Exception) { } // watch.Restart(); IDocument emptyDoc = folder.CreateDocument(properties, null, null); // watch.Stop(); // Console.WriteLine(String.Format("Created empty doc in {0} msec", watch.ElapsedMilliseconds)); Assert.That(emptyDoc.ContentStreamLength == 0 || emptyDoc.ContentStreamLength == null, "returned document shouldn't got any content"); string content = "test"; for (int i = 0; i < 10; i++) { ContentStream contentStream = new ContentStream(); contentStream.FileName = filename; contentStream.MimeType = MimeType.GetMIMEType(filename); contentStream.Length = content.Length; using (var memstream = new MemoryStream(Encoding.UTF8.GetBytes(content))) { contentStream.Stream = memstream; emptyDoc.AppendContentStream(contentStream, i == 9, true); } Assert.AreEqual(content.Length * (i + 1), emptyDoc.ContentStreamLength); } emptyDoc.DeleteAllVersions(); }
public static IDocument AppendContent(this IDocument doc, string content, bool lastChunk = true) { ContentStream contentStream = new ContentStream(); contentStream.FileName = doc.Name; contentStream.MimeType = MimeType.GetMIMEType(doc.Name); byte[] c = Encoding.UTF8.GetBytes(content); contentStream.Length = c.LongLength; using (var stream = new MemoryStream(c)) { contentStream.Stream = stream; return(doc.AppendContentStream(contentStream, lastChunk)); } }
/// <summary> /// Appends the localFileStream to the remoteDocument. /// </summary> /// <returns> /// The new CMIS document. /// </returns> /// <param name='remoteDocument'> /// Remote document where the local content should be appended to. /// </param> /// <param name='localFileStream'> /// Local file stream. /// </param> /// <param name='status'> /// Transmission status where the uploader should report its appending status. /// </param> /// <param name='hashAlg'> /// Hash alg which should be used to calculate a checksum over the appended content. /// </param> /// <exception cref="CmisSync.Lib.Tasks.UploadFailedException">If Upload fails</exception> public virtual IDocument AppendFile(IDocument remoteDocument, Stream localFileStream, Transmission transmission, HashAlgorithm hashAlg) { using (var transmissionStream = transmission.CreateStream(localFileStream)) using (var hashstream = new CryptoStream(transmissionStream, hashAlg, CryptoStreamMode.Read)) { ContentStream contentStream = new ContentStream(); contentStream.FileName = remoteDocument.Name; contentStream.MimeType = Cmis.MimeType.GetMIMEType(contentStream.FileName); contentStream.Stream = hashstream; try { return(remoteDocument.AppendContentStream(contentStream, true)); } catch (Exception e) { throw new UploadFailedException(e, remoteDocument); } } }
/// <summary> /// Appends the localFileStream to the remoteDocument. /// </summary> /// <returns> /// The new CMIS document. /// </returns> /// <param name='remoteDocument'> /// Remote document where the local content should be appended to. /// </param> /// <param name='localFileStream'> /// Local file stream. /// </param> /// <param name='status'> /// Transmission status where the uploader should report its appending status. /// </param> /// <param name='hashAlg'> /// Hash alg which should be used to calculate a checksum over the appended content. /// </param> /// <exception cref="CmisSync.Lib.Tasks.UploadFailedException">If Upload fails</exception> public virtual IDocument AppendFile(IDocument remoteDocument, Stream localFileStream, FileTransmissionEvent status, HashAlgorithm hashAlg) { using (ProgressStream progressstream = new ProgressStream(localFileStream, status)) using (CryptoStream hashstream = new CryptoStream(progressstream, hashAlg, CryptoStreamMode.Read)) { ContentStream contentStream = new ContentStream(); contentStream.FileName = remoteDocument.Name; contentStream.MimeType = Cmis.MimeType.GetMIMEType(contentStream.FileName); contentStream.Stream = hashstream; try { return(remoteDocument.AppendContentStream(contentStream, true)); } catch (Exception e) { throw new UploadFailedException(e, remoteDocument); } } }
/// <summary> /// Uploads the file. /// Resumes an upload if the given localFileStream.Position is larger than zero. /// </summary> /// <returns> /// The new CMIS document. /// </returns> /// <param name='remoteDocument'> /// Remote document where the local content should be uploaded to. /// </param> /// <param name='localFileStream'> /// Local file stream. /// </param> /// <param name='status'> /// Transmission status where the uploader should report its uploading status. /// </param> /// <param name='hashAlg'> /// Hash alg which should be used to calculate a checksum over the uploaded content. /// </param> /// <param name='overwrite'> /// If true, the local content will overwrite the existing content. /// </param> /// <exception cref="CmisSync.Lib.Tasks.UploadFailedException"> /// Contains the last successful remote document state. This is needed for continue a failed upload. /// </exception> public override IDocument UploadFile(IDocument remoteDocument, Stream localFileStream, FileTransmissionEvent status, HashAlgorithm hashAlg, bool overwrite = true) { IDocument result = remoteDocument; for (long offset = localFileStream.Position; offset < localFileStream.Length; offset += this.ChunkSize) { bool isFirstChunk = offset == 0; bool isLastChunk = (offset + this.ChunkSize) >= localFileStream.Length; using (NonClosingHashStream hashstream = new NonClosingHashStream(localFileStream, hashAlg, CryptoStreamMode.Read)) using (ChunkedStream chunkstream = new ChunkedStream(hashstream, this.ChunkSize)) using (OffsetStream offsetstream = new OffsetStream(chunkstream, offset)) using (ProgressStream progressstream = new ProgressStream(offsetstream, status)) { status.Status.Length = localFileStream.Length; status.Status.ActualPosition = offset; chunkstream.ChunkPosition = offset; ContentStream contentStream = new ContentStream(); contentStream.FileName = remoteDocument.Name; contentStream.MimeType = Cmis.MimeType.GetMIMEType(remoteDocument.Name); if (isLastChunk) { contentStream.Length = localFileStream.Length - offset; } else { contentStream.Length = this.ChunkSize; } contentStream.Stream = progressstream; try { if (isFirstChunk && result.ContentStreamId != null && overwrite) { result.DeleteContentStream(true); } result.AppendContentStream(contentStream, isLastChunk, true); } catch (Exception e) { throw new UploadFailedException(e, result); } } } hashAlg.TransformFinalBlock(new byte[0], 0, 0); return(result); }
private bool UploadStreamInTrunk(string filePath, Stream fileStream, IDocument remoteDocument) { if (repoinfo.ChunkSize <= 0) { return false; } string fileName = remoteDocument.Name; for (long offset = fileStream.Position; offset < fileStream.Length; offset += repoinfo.ChunkSize) { bool isLastTrunk = false; if (offset + repoinfo.ChunkSize >= fileStream.Length) { isLastTrunk = true; } Logger.Debug(String.Format("Uploading next chunk (size={1}) of {0}: {2} of {3} finished({4}%)", fileName, repoinfo.ChunkSize, offset, fileStream.Length, 100 * offset / fileStream.Length)); using (ChunkedStream chunkstream = new ChunkedStream(fileStream, repoinfo.ChunkSize)) { chunkstream.ChunkPosition = offset; ContentStream contentStream = new ContentStream(); contentStream.FileName = fileName; contentStream.MimeType = MimeType.GetMIMEType(fileName); contentStream.Length = repoinfo.ChunkSize; if (isLastTrunk) { contentStream.Length = fileStream.Length - offset; } contentStream.Stream = chunkstream; lock (disposeLock) { if (disposed) { throw new ObjectDisposedException("Uploading"); } try { remoteDocument.AppendContentStream(contentStream, isLastTrunk); Logger.Debug("Response of the server: " + offset.ToString()); database.SetFileServerSideModificationDate(filePath, remoteDocument.LastModificationDate); } catch (Exception ex) { Logger.Fatal("Upload failed: " + ex); return false; } } } } return true; }
public void CheckinTest( string canonical_name, string localPath, string remoteFolderPath, string url, string user, string password, string repositoryId, string binding) { string subFolderName = "subFolder"; string fileName = "testFile.bin"; string subFolderPath = remoteFolderPath.TrimEnd('/') + "/" + subFolderName; string filePath = subFolderPath + "/" + fileName; ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId, binding); if (!session.ArePrivateWorkingCopySupported()) { Assert.Ignore("PWCs are not supported"); } try { IFolder dir = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + subFolderName) as IFolder; if (dir != null) { dir.DeleteTree(true, null, true); } } catch (CmisObjectNotFoundException) { } IFolder folder = (IFolder)session.GetObjectByPath(remoteFolderPath); IFolder subFolder = folder.CreateFolder(subFolderName); string content = "testContent"; IDocument doc = subFolder.CreateDocument(fileName, "testContent", checkedOut: true); IObjectId checkoutId = doc.CheckOut(); IDocument docCheckout = session.GetObject(checkoutId) as IDocument; Assert.AreEqual(doc.ContentStreamLength, docCheckout.ContentStreamLength); ContentStream contentStream = new ContentStream(); contentStream.FileName = fileName; contentStream.MimeType = MimeType.GetMIMEType(fileName); contentStream.Length = content.Length; for (int i = 0; i < 10; ++i) { using (var memstream = new MemoryStream(Encoding.UTF8.GetBytes(content))) { contentStream.Stream = memstream; docCheckout.AppendContentStream(contentStream, i == 9); } Assert.That(docCheckout.ContentStreamLength, Is.EqualTo(content.Length * (i + 2))); } IObjectId checkinId = docCheckout.CheckIn(true, null, null, "checkin"); IDocument docCheckin = session.GetObject(checkinId) as IDocument; docCheckin.Refresh(); // refresh is required, or DotCMIS will re-use the cached properties if checinId is the same as doc.Id Assert.That(docCheckin.ContentStreamLength, Is.EqualTo(content.Length * (9 + 2))); }
public void AppendContentStreamTest( string canonical_name, string localPath, string remoteFolderPath, string url, string user, string password, string repositoryId) { ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId); IFolder folder = (IFolder)session.GetObjectByPath(remoteFolderPath); string filename = "testfile.txt"; Dictionary <string, object> properties = new Dictionary <string, object>(); properties.Add(PropertyIds.Name, filename); properties.Add(PropertyIds.ObjectTypeId, "cmis:document"); IDocument doc = null; try { doc = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + filename) as IDocument; if (doc != null) { doc.Delete(true); } } catch (Exception) { } string content = "test"; doc = folder.CreateDocument(filename, content); Assert.That(doc.ContentStreamLength == content.Length, "returned document should have got content"); for (int i = 0; i < 10; i++) { ContentStream contentStream = new ContentStream(); contentStream.FileName = filename; contentStream.MimeType = MimeType.GetMIMEType(filename); contentStream.Length = content.Length; using (var memstream = new MemoryStream(Encoding.UTF8.GetBytes(content))) { contentStream.Stream = memstream; doc.AppendContentStream(contentStream, i == 9, true); } Assert.AreEqual(content.Length * (i + 2), doc.ContentStreamLength); } for (int i = 0; i < 10; i++) { ContentStream contentStream = new ContentStream(); contentStream.FileName = filename; contentStream.MimeType = MimeType.GetMIMEType(filename); contentStream.Length = content.Length; using (var memstream = new MemoryStream(Encoding.UTF8.GetBytes(content))) { contentStream.Stream = memstream; doc.AppendContentStream(contentStream, true, true); } Assert.AreEqual(content.Length * (i + 2 + 10), doc.ContentStreamLength); } doc.DeleteAllVersions(); }
/// <summary> /// Uploads the file. /// Resumes an upload if the given localFileStream.Position is larger than zero. /// </summary> /// <returns> /// The new CMIS document. /// </returns> /// <param name='remoteDocument'> /// Remote document where the local content should be uploaded to. /// </param> /// <param name='localFileStream'> /// Local file stream. /// </param> /// <param name='transmission'> /// Transmission status where the uploader should report its uploading status. /// </param> /// <param name='hashAlg'> /// Hash alg which should be used to calculate a checksum over the uploaded content. /// </param> /// <param name='overwrite'> /// If true, the local content will overwrite the existing content. /// </param> /// <param name="update">Is called on every new chunk, if not <c>null</c>.</param> /// <exception cref="CmisSync.Lib.Tasks.UploadFailedException"> /// Contains the last successful remote document state. This is needed for continue a failed upload. /// </exception> public override IDocument UploadFile( IDocument remoteDocument, Stream localFileStream, Transmission transmission, HashAlgorithm hashAlg, bool overwrite = true, UpdateChecksum update = null) { IDocument result = remoteDocument; for (long offset = localFileStream.Position; offset < localFileStream.Length; offset += this.ChunkSize) { bool isFirstChunk = offset == 0; bool isLastChunk = (offset + this.ChunkSize) >= localFileStream.Length; using (var hashstream = new NonClosingHashStream(localFileStream, hashAlg, CryptoStreamMode.Read)) using (var chunkstream = new ChunkedStream(hashstream, this.ChunkSize)) using (var offsetstream = new OffsetStream(chunkstream, offset)) using (var transmissionStream = transmission.CreateStream(offsetstream)) { transmission.Length = localFileStream.Length; transmission.Position = offset; chunkstream.ChunkPosition = offset; ContentStream contentStream = new ContentStream(); contentStream.FileName = remoteDocument.Name; contentStream.MimeType = Cmis.MimeType.GetMIMEType(remoteDocument.Name); if (isLastChunk) { contentStream.Length = localFileStream.Length - offset; } else { contentStream.Length = this.ChunkSize; } contentStream.Stream = transmissionStream; try { if (isFirstChunk && result.ContentStreamId != null && overwrite) { result.DeleteContentStream(true); } result.AppendContentStream(contentStream, isLastChunk, true); HashAlgorithmReuse reuse = hashAlg as HashAlgorithmReuse; if (reuse != null && update != null) { using (HashAlgorithm hash = (HashAlgorithm)reuse.Clone()) { hash.TransformFinalBlock(new byte[0], 0, 0); update(hash.Hash, result.ContentStreamLength.GetValueOrDefault()); } } } catch (Exception e) { if (e is FileTransmission.AbortException) { throw; } if (e.InnerException is FileTransmission.AbortException) { throw e.InnerException; } throw new UploadFailedException(e, result); } } } hashAlg.TransformFinalBlock(new byte[0], 0, 0); return(result); }
/// <summary> /// Appends the localFileStream to the remoteDocument. /// </summary> /// <returns> /// The new CMIS document. /// </returns> /// <param name='remoteDocument'> /// Remote document where the local content should be appended to. /// </param> /// <param name='localFileStream'> /// Local file stream. /// </param> /// <param name='status'> /// Transmission status where the uploader should report its appending status. /// </param> /// <param name='hashAlg'> /// Hash alg which should be used to calculate a checksum over the appended content. /// </param> /// <exception cref="CmisSync.Lib.Tasks.UploadFailedException">If Upload fails</exception> public virtual IDocument AppendFile(IDocument remoteDocument, Stream localFileStream, Transmission transmission, HashAlgorithm hashAlg) { using (var transmissionStream = transmission.CreateStream(localFileStream)) using (var hashstream = new CryptoStream(transmissionStream, hashAlg, CryptoStreamMode.Read)) { ContentStream contentStream = new ContentStream(); contentStream.FileName = remoteDocument.Name; contentStream.MimeType = Cmis.MimeType.GetMIMEType(contentStream.FileName); contentStream.Stream = hashstream; try { return remoteDocument.AppendContentStream(contentStream, true); } catch(Exception e) { throw new UploadFailedException(e, remoteDocument); } } }