NCNetworkingChunkedUpload.swift 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302
  1. //
  2. // NCNetworkingUploadChunk.swift
  3. // Nextcloud
  4. //
  5. // Created by Marino Faggiana on 05/04/21.
  6. // Copyright © 2021 Marino Faggiana. All rights reserved.
  7. //
  8. // Author Marino Faggiana <marino.faggiana@nextcloud.com>
  9. //
  10. // This program is free software: you can redistribute it and/or modify
  11. // it under the terms of the GNU General Public License as published by
  12. // the Free Software Foundation, either version 3 of the License, or
  13. // (at your option) any later version.
  14. //
  15. // This program is distributed in the hope that it will be useful,
  16. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. // GNU General Public License for more details.
  19. //
  20. // You should have received a copy of the GNU General Public License
  21. // along with this program. If not, see <http://www.gnu.org/licenses/>.
  22. //
  23. import UIKit
  24. import NCCommunication
  25. import Queuer
  26. extension NCNetworking {
  27. internal func uploadChunkedFile(metadata: tableMetadata, start: @escaping () -> Void, completion: @escaping (_ errorCode: Int, _ errorDescription: String)->()) {
  28. let directoryProviderStorageOcId = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId)!
  29. let chunkFolder = NCManageDatabase.shared.getChunkFolder(account: metadata.account, ocId: metadata.ocId)
  30. let chunkFolderPath = metadata.urlBase + "/" + NCUtilityFileSystem.shared.getWebDAV(account: metadata.account) + "/uploads/" + metadata.userId + "/" + chunkFolder
  31. let fileNameLocalPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: metadata.fileNameView)!
  32. let chunkSize = CCUtility.getChunkSize()
  33. var uploadErrorCode: Int = 0
  34. var uploadErrorDescription: String = ""
  35. var filesNames = NCManageDatabase.shared.getChunks(account: metadata.account, ocId: metadata.ocId)
  36. if filesNames.count == 0 {
  37. filesNames = NCCommunicationCommon.shared.chunkedFile(inputDirectory: directoryProviderStorageOcId, outputDirectory: directoryProviderStorageOcId, fileName: metadata.fileName, chunkSizeMB: chunkSize)
  38. if filesNames.count > 0 {
  39. NCManageDatabase.shared.addChunks(account: metadata.account, ocId: metadata.ocId, chunkFolder: chunkFolder, fileNames: filesNames)
  40. } else {
  41. NCContentPresenter.shared.messageNotification("_error_", description: "_err_file_not_found_", delay: NCGlobal.shared.dismissAfterSecond, type: NCContentPresenter.messageType.error, errorCode:NCGlobal.shared.errorReadFile, forced: true)
  42. NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
  43. return completion(uploadErrorCode, uploadErrorDescription)
  44. }
  45. } else {
  46. NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl":metadata.serverUrl])
  47. }
  48. NCContentPresenter.shared.noteTop(text: NSLocalizedString("_upload_chunk_", comment: ""), image: nil, type: NCContentPresenter.messageType.info, delay: NCGlobal.shared.dismissAfterSecond, name: nil)
  49. createChunkedFolder(chunkFolderPath: chunkFolderPath, account: metadata.account) { (errorCode, errorDescription) in
  50. start()
  51. if errorCode == 0 {
  52. NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadStartFile, userInfo: ["ocId": metadata.ocId])
  53. DispatchQueue.global(qos: .background).async {
  54. for fileName in filesNames {
  55. let serverUrlFileName = chunkFolderPath + "/" + fileName
  56. let fileNameChunkLocalPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: fileName)!
  57. var size: Int64?
  58. if let tableChunk = NCManageDatabase.shared.getChunk(account: metadata.account, fileName: fileName) {
  59. size = tableChunk.size - NCUtilityFileSystem.shared.getFileSize(filePath: fileNameChunkLocalPath)
  60. }
  61. let semaphore = Semaphore()
  62. NCCommunication.shared.upload(serverUrlFileName: serverUrlFileName, fileNameLocalPath: fileNameChunkLocalPath, requestHandler: { (request) in
  63. self.uploadRequest[fileNameLocalPath] = request
  64. }, taskHandler: { (task) in
  65. NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, sessionError: "", sessionTaskIdentifier: task.taskIdentifier, status: NCGlobal.shared.metadataStatusUploading)
  66. }, progressHandler: { (progress) in
  67. if let size = size {
  68. let totalBytesExpected = size + progress.completedUnitCount
  69. let totalBytes = metadata.size
  70. let fractionCompleted = Float(totalBytesExpected) / Float(totalBytes)
  71. NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterProgressTask, object: nil, userInfo: ["account":metadata.account, "ocId":metadata.ocId, "fileName":metadata.fileName, "serverUrl":metadata.serverUrl, "status":NSNumber(value: NCGlobal.shared.metadataStatusInUpload), "progress":NSNumber(value: fractionCompleted), "totalBytes":NSNumber(value: totalBytes), "totalBytesExpected":NSNumber(value: totalBytesExpected)])
  72. }
  73. }) { (_, _, _, _, _, _, _, errorCode, errorDescription) in
  74. self.uploadRequest[fileNameLocalPath] = nil
  75. uploadErrorCode = errorCode
  76. uploadErrorDescription = errorDescription
  77. semaphore.continue()
  78. }
  79. semaphore.wait()
  80. if uploadErrorCode == 0 {
  81. NCManageDatabase.shared.deleteChunk(account: metadata.account, ocId: metadata.ocId, fileName: fileName)
  82. } else {
  83. break
  84. }
  85. }
  86. if uploadErrorCode == 0 {
  87. // Assembling the chunks
  88. let serverUrlFileNameSource = chunkFolderPath + "/.file"
  89. let pathServerUrl = CCUtility.returnPathfromServerUrl(metadata.serverUrl, urlBase: metadata.urlBase, account: metadata.account)!
  90. let serverUrlFileNameDestination = metadata.urlBase + "/" + NCUtilityFileSystem.shared.getWebDAV(account: metadata.account) + "/files/" + metadata.userId + pathServerUrl + "/" + metadata.fileName
  91. var addCustomHeaders: [String:String] = [:]
  92. let creationDate = "\(metadata.creationDate.timeIntervalSince1970)"
  93. let modificationDate = "\(metadata.date.timeIntervalSince1970)"
  94. addCustomHeaders["X-OC-CTime"] = creationDate
  95. addCustomHeaders["X-OC-MTime"] = modificationDate
  96. NCCommunication.shared.moveFileOrFolder(serverUrlFileNameSource: serverUrlFileNameSource, serverUrlFileNameDestination: serverUrlFileNameDestination, overwrite: true, addCustomHeaders: addCustomHeaders) { (_, errorCode, errorDescription) in
  97. if errorCode == 0 {
  98. let serverUrl = metadata.serverUrl
  99. NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
  100. NCManageDatabase.shared.deleteChunks(account: metadata.account, ocId: metadata.ocId)
  101. NCUtilityFileSystem.shared.deleteFile(filePath: directoryProviderStorageOcId)
  102. self.readFile(serverUrlFileName: serverUrlFileNameDestination, account: metadata.account) { (_, metadata, _, _) in
  103. if errorCode == 0, let metadata = metadata {
  104. NCManageDatabase.shared.addMetadata(metadata)
  105. NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl":serverUrl])
  106. } else {
  107. NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSourceNetworkForced, userInfo: ["serverUrl": serverUrl])
  108. }
  109. completion(errorCode, errorDescription)
  110. }
  111. } else {
  112. self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: errorCode, errorDescription: errorDescription)
  113. completion(errorCode, errorDescription)
  114. }
  115. }
  116. } else {
  117. self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: uploadErrorCode, errorDescription: uploadErrorDescription)
  118. completion(errorCode, errorDescription)
  119. }
  120. }
  121. } else {
  122. self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: errorCode, errorDescription: errorDescription)
  123. completion(errorCode, errorDescription)
  124. }
  125. }
  126. }
  127. private func createChunkedFolder(chunkFolderPath: String, account: String, completion: @escaping (_ errorCode: Int, _ errorDescription: String)->()) {
  128. NCCommunication.shared.readFileOrFolder(serverUrlFileName: chunkFolderPath, depth: "0", showHiddenFiles: CCUtility.getShowHiddenFiles()) { (_, _, _, errorCode, errorDescription) in
  129. if errorCode == 0 {
  130. completion(0, "")
  131. } else if errorCode == NCGlobal.shared.errorResourceNotFound {
  132. NCCommunication.shared.createFolder(chunkFolderPath) { (_, _, _, errorCode, errorDescription) in
  133. completion(errorCode, errorDescription)
  134. }
  135. } else {
  136. completion(errorCode, errorDescription)
  137. }
  138. }
  139. }
  140. private func uploadChunkFileError(metadata: tableMetadata, chunkFolderPath: String, directoryProviderStorageOcId: String, errorCode: Int, errorDescription: String) {
  141. var errorDescription = errorDescription
  142. if errorCode == NSURLErrorCancelled || errorCode == NCGlobal.shared.errorRequestExplicityCancelled {
  143. // Delete chunk folder
  144. NCCommunication.shared.deleteFileOrFolder(chunkFolderPath) { (_, _, _) in }
  145. NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
  146. NCManageDatabase.shared.deleteChunks(account: metadata.account, ocId: metadata.ocId)
  147. NCUtilityFileSystem.shared.deleteFile(filePath: directoryProviderStorageOcId)
  148. NCCommunication.shared.deleteFileOrFolder(chunkFolderPath) { (_, _, _) in }
  149. } else {
  150. // NO report for the connection lost
  151. if errorCode == NCGlobal.shared.errorConnectionLost {
  152. errorDescription = ""
  153. } else {
  154. let description = errorDescription + " code: \(errorCode)"
  155. NCContentPresenter.shared.messageNotification("_error_", description: description, delay: NCGlobal.shared.dismissAfterSecond, type: NCContentPresenter.messageType.error, errorCode: NCGlobal.shared.errorInternalError, forced: true)
  156. }
  157. NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, session: nil, sessionError: errorDescription, sessionTaskIdentifier: NCGlobal.shared.metadataStatusNormal, status: NCGlobal.shared.metadataStatusUploadError)
  158. }
  159. NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl":metadata.serverUrl])
  160. }
  161. /*
  162. @objc func chunkedFile(inputDirectory: String, outputDirectory: String, fileName: String, chunkSizeMB:Int, bufferSize: Int = 1000000) -> [String] {
  163. let fileManager: FileManager = .default
  164. var isDirectory: ObjCBool = false
  165. let chunkSize = chunkSizeMB * 1000000
  166. var outputFilesName: [String] = []
  167. var reader: FileHandle?
  168. var writer: FileHandle?
  169. var chunk: Int = 0
  170. var counter: Int = 0
  171. if !fileManager.fileExists(atPath:outputDirectory, isDirectory:&isDirectory) {
  172. do {
  173. try fileManager.createDirectory(atPath: outputDirectory, withIntermediateDirectories: true, attributes: nil)
  174. } catch {
  175. return []
  176. }
  177. }
  178. do {
  179. reader = try .init(forReadingFrom: URL(fileURLWithPath: inputDirectory + "/" + fileName))
  180. } catch {
  181. return []
  182. }
  183. repeat {
  184. let bufferCounter = autoreleasepool { () -> Int in
  185. if chunk >= chunkSize {
  186. writer?.closeFile()
  187. writer = nil
  188. chunk = 0
  189. counter += 1
  190. print("Counter: \(counter)")
  191. }
  192. let chunkRemaining: Int = chunkSize - chunk
  193. let buffer = reader?.readData(ofLength: min(bufferSize, chunkRemaining))
  194. if writer == nil {
  195. let fileNameChunk = fileName + String(format: "%010d", counter)
  196. let outputFileName = outputDirectory + "/" + fileNameChunk
  197. fileManager.createFile(atPath: outputFileName, contents: nil, attributes: nil)
  198. do {
  199. writer = try .init(forWritingTo: URL(fileURLWithPath: outputFileName))
  200. } catch { }
  201. outputFilesName.append(fileNameChunk)
  202. }
  203. if let buffer = buffer {
  204. writer?.write(buffer)
  205. chunk = chunk + buffer.count
  206. return buffer.count
  207. }
  208. return 0
  209. }
  210. if bufferCounter == 0 {
  211. break
  212. }
  213. } while true
  214. writer?.closeFile()
  215. reader?.closeFile()
  216. return outputFilesName
  217. }
  218. */
  219. }