private static void Update(OnSuccessCallback onSuccess, String[] args) { try { string updateFilePath = Config.GamePath + "\\update.zip"; client = new WebClient(); client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(delegate(object sender, DownloadProgressChangedEventArgs e) { progress = (float)e.ProgressPercentage / 100; }); client.DownloadFileCompleted += new AsyncCompletedEventHandler(delegate(object sender, AsyncCompletedEventArgs e) { if (e.Error != null) { Error("Could not download update", e.Error); return; } try { client.Dispose(); client = null; ZipFile zip = new ZipFile(updateFilePath); zip.ExtractAll(Config.GamePath, ExtractExistingFileAction.OverwriteSilently); zip.Dispose(); File.Delete(updateFilePath); onSuccess(); } catch (Exception ex) { Error("Could not install update", ex); } status = StartGame(args) ? Status.SUCCESS : Status.ERROR; }); client.DownloadFileAsync(new Uri(Config.UpdateUrl), updateFilePath); } catch (Exception ex) { Error("Could not download update", ex); } }
private void UploadFile(string bucket, string fileKey, string filePath, OnProgressCallback progressCb, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { COSXMLUploadTask uploadTask = new COSXMLUploadTask(bucket, null, fileKey) { progressCallback = progressCb, successCallback = successCb, failCallback = failedCb }; uploadTask.SetSrcPath(filePath); transferManager.Upload(uploadTask); }
private IEnumerator fetch(string _bucket, string _channel, OnSuccessCallback _onSuccess, OnErrorCallback _onError) { ReqParams reqParams = new ReqParams(); reqParams.bucket = _bucket; reqParams.channel = _channel; string url = string.Format("{0}/fetch", config.domain); string json = JsonMapper.ToJson(reqParams); Dictionary <string, string> header = new Dictionary <string, string>(); header.Add("Content-Type", "application/json"); WWW www = new WWW(url, Encoding.UTF8.GetBytes(json), header); yield return(www); if (null != www.error) { _onError(www.error); yield break; } string manifest = www.text; try { Parser parser = new Parser(); Task[] tasks = parser.ParseJSON(manifest); List <Task> taskList = new List <Task>(); foreach (Task task in tasks) { if (null == task) { continue; } if (!compareMD5(task)) { taskList.Add(task); } } _onSuccess(taskList); } catch (System.Exception e) { _onError(e.Message); } }
private void syncDownloadFile(string bucket, string fileKey, string localDir, string localFileName, OnProgressCallback progressCb, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { try { GetObjectRequest request = new GetObjectRequest(bucket, fileKey, localDir, localFileName); request.SetSign(TimeUtils.GetCurrentTime(TimeUnit.SECONDS), 600); request.SetCosProgressCallback(progressCb); GetObjectResult result = cosXml.GetObject(request); } catch (CosClientException clientEx) { failedCb(clientEx, null); } catch (CosServerException serverEx) { failedCb(null, serverEx); } }
public void GetUcbPatchResult(string fileHash, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { var status = ucbFacade.GetPatchStatus(fileHash); if (UCB_PATCH_STATUS.COMPLETED.Equals(status)) { successCb(CreateTaskResult(COS_STATUS.OK, COS_MSG.INFO_UPLOAD_SUCCESS)); return; } if (UCB_PATCH_STATUS.FAILED.Equals(status)) { failedCb( new CosClientException(COS_STATUS.SERVER_ERR, COS_MSG.ERR_SERVER), new CosServerException(COS_STATUS.SERVER_ERR, COS_MSG.ERR_SERVER_PATCH_FAIL) ); } }
void CosXml.SelectObjectAsync(SelectObjectRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { Schedue(request, new Model.Object.SelectObjectResult(), successCallback, failCallback); }
public void PutBucketDomainAsync(PutBucketDomainRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { Schedue(request, new Model.Bucket.PutBucketDomainResult(), successCallback, failCallback); }
public void deleteInventoryAsync(DeleteBucketInventoryRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { schedue(request, new Model.Bucket.DeleteBucketInventoryResult(), successCallback, failCallback); }
public void Fetch(string _bucket, string _channel, OnSuccessCallback _onSuccess, OnErrorCallback _onError) { config.mono.StartCoroutine(fetch(_bucket, _channel, _onSuccess, _onError)); }
public void GetBucketLoggingAsync(GetBucketLoggingRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { Schedue(request, new Model.Bucket.GetBucketLoggingResult(), successCallback, failCallback); }
private void _DeltaUpdateProject(string filePath, string projectId, OnProgressCallback progressCb, OnMessageCallback messageCb, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { var localDir = Path.GetDirectoryName(filePath); var fileName = Path.GetFileName(filePath); var fileKey = $"{projectId}/{fileName}"; var baseMetaKey = $"{projectId}/{BASE_META}"; var baseMetaPath = $"{localDir}/{BASE_META}"; var deltaKey = $"{projectId}/{fileName}{DELTA_SUFFIX}"; var deltaPath = $"{filePath}{DELTA_SUFFIX}"; var baseSignature = $"{fileName}{SIG_SUFFIX}"; var baseSignaturePath = $"{localDir}/{baseSignature}"; string hashPattern = @"(?<=" + projectId + @"/)(.*)(?=\.zip$)"; string projectHash = new Regex(hashPattern).Match(fileKey).Value; clearOldFiles(baseMetaPath, baseSignaturePath, deltaPath); messageCb(COS_MSG.TITLE_DOWNLOADING_META_FILE, string.Format(COS_MSG.INFO_DOWNLOADING_META_FILE, baseMetaKey, $"{localDir}/{BASE_META}")); syncDownloadFile(deltaBucket, baseMetaKey, localDir, BASE_META, progressCb, DoNothing, failedCb); var metaInfo = JsonConvert.DeserializeObject <MetaInfo>(File.ReadAllText(baseMetaPath)); if ((float)new FileInfo(filePath).Length / metaInfo.baseFileSize > 1 + DELTA_THRESHOLD) { clearOldFiles(baseMetaPath); _InitProject(filePath, projectId, progressCb, messageCb, successCb, failedCb); return; } ucbFacade.InitDeltaUpload(new DeltaInfo { baseFileKey = metaInfo.baseFileName, deltaFileKey = $"{fileKey}{DELTA_SUFFIX}", newFileKey = fileKey, projectId = projectId, fileHash = projectHash }); messageCb(COS_MSG.TITLE_DOWNLOADING_SIG_FILE, string.Format(COS_MSG.INFO_DOWNLOADING_SIG_FILE, metaInfo.signatureKey, $"{localDir}/{baseSignature}")); syncDownloadFile(deltaBucket, metaInfo.signatureKey, localDir, baseSignature, progressCb, DoNothing, failedCb); messageCb(COS_MSG.TITLE_CREATING_DELTA_FILE, string.Format(COS_MSG.INFO_CREATING_DELTA_FILE, deltaPath, filePath, baseSignaturePath)); CreateDelta(filePath, baseSignaturePath, deltaPath); if ((float)new FileInfo(deltaPath).Length / metaInfo.baseFileSize > DELTA_THRESHOLD) { clearOldFiles(baseMetaPath, baseSignaturePath, deltaPath); _InitProject(filePath, projectId, progressCb, messageCb, successCb, failedCb); return; } messageCb(COS_MSG.TITLE_UPLOADING_DELTA_FILE, string.Format(COS_MSG.INFO_UPLOADING_DELTA_FILE, deltaKey)); UploadFile(deltaBucket, deltaKey, deltaPath, progressCb, delegate(CosResult uploadResult) { deltaPatch(metaInfo.baseFileName, fileKey, projectId, projectHash); clearOldFiles(baseMetaPath, baseSignaturePath, deltaPath); messageCb(COS_MSG.TITLE_PATCHING_DELTA_FILE, COS_MSG.INFO_PATCHING_DELTA_FILE); }, failedCb); }
private void _InitProject(string filePath, string projectId, OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { var localDir = Path.GetDirectoryName(filePath); var fileKey = $"{projectId}/{Path.GetFileName(filePath)}"; var signatureKey = $"{fileKey}{SIG_SUFFIX}"; var signaturePath = $"{filePath}{SIG_SUFFIX}"; var baseMetaKey = $"{projectId}/{BASE_META}"; var baseMetaPath = $"{localDir}/{BASE_META}"; clearOldFiles(baseMetaPath, signaturePath); AutoResetEvent signatureEvent = new AutoResetEvent(false); AutoResetEvent baseMetaEvent = new AutoResetEvent(false); messageCallback(COS_MSG.TITLE_UPLOADING_PROJECT, string.Format(COS_MSG.INFO_UPLOADING_PROJECT, fileKey)); UploadFile(sourceBucket, fileKey, filePath, progressCb, delegate(CosResult result1) { signatureEvent.WaitOne(); messageCallback(COS_MSG.TITLE_UPLOADING_SIG_FILE, string.Format(COS_MSG.INFO_UPLOADING_SIG_FILE, signatureKey)); UploadFile(deltaBucket, signatureKey, signaturePath, progressCb, delegate(CosResult result) { baseMetaEvent.WaitOne(); messageCallback(COS_MSG.TITLE_UPLOADING_META_FILE, string.Format(COS_MSG.INFO_UPLOADING_META_FILE, baseMetaKey)); UploadFile(deltaBucket, baseMetaKey, baseMetaPath, progressCb, delegate(CosResult cosResult) { clearOldFiles(baseMetaPath, signaturePath); successCb( CreateTaskResult(COS_STATUS.OK, string.Format(COS_MSG.INFO_INIT_SUCCESS, filePath, projectId))); }, failedCb); }, failedCb); }, failedCb); AsyncCreateSignature(filePath, signaturePath, () => { signatureEvent.Set(); }); AsyncCreateBaseMeta(filePath, fileKey, signatureKey, projectId, baseMetaPath, () => { baseMetaEvent.Set(); }); }
public void AsyncUploadProject(string fileName, string projectId, OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { Func <string, string, OnProgressCallback, OnMessageCallback, OnSuccessCallback <CosResult>, OnFailedCallback, Exception> fun = DeltaUploadProject; fun.BeginInvoke(fileName, projectId, progressCb, messageCallback, successCb, failedCb, ar => { Console.WriteLine(ar.AsyncState); }, fun); }
public Exception DeltaUploadProject(string fileName, string projectId, OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { var filePath = Path.GetFullPath(fileName); if (!File.Exists(filePath)) { failedCb( new CosClientException(COS_STATUS.CLIENT_ERR, string.Format(COS_MSG.ERR_CLIENT_TARGET_NOT_EXIST, fileName)), new CosServerException(COS_STATUS.CLIENT_ERR, COS_MSG.ERR_CLIENT) ); } var fileKey = $"{projectId}/{Path.GetFileName(fileName)}"; if (CheckFileExists(sourceBucket, fileKey)) { successCb(CreateTaskResult(COS_STATUS.SKIP, string.Format(COS_MSG.INFO_TARGET_EXIST_ON_SERVER, fileName))); return(null); } if (CheckFileExists(deltaBucket, $"{projectId}/{BASE_META}")) { _DeltaUpdateProject(filePath, projectId, progressCb, messageCallback, successCb, failedCb); } else { _InitProject(filePath, projectId, progressCb, messageCallback, successCb, failedCb); } return(new Exception()); }
public void UploadProject(string fileName, string projectId, OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb, OnFailedCallback failedCb) { var filePath = Path.GetFullPath(fileName); var fileKey = $"{projectId}/{Path.GetFileName(fileName)}"; if (CheckFileExists(sourceBucket, fileKey)) { successCb(CreateTaskResult(COS_STATUS.SKIP, string.Format(COS_MSG.INFO_TARGET_EXIST_ON_SERVER, fileName))); return; } _InitProject(filePath, projectId, progressCb, messageCallback, successCb, failedCb); }
public void GetObject(GetObjectBytesRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { Schedue(request, new GetObjectBytesResult(), successCallback, failCallback); }
public void DeleteBucketWebsiteAsync(DeleteBucketWebsiteRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { Schedue(request, new Model.Bucket.DeleteBucketWebsiteResult(), successCallback, failCallback); }
public virtual void Delete(IList <T> itemsToDelete, OnErrorCallback <T> onErrorCallback, OnSuccessCallback <T> onSuccessCallback) { foreach (T itemToDelete in itemsToDelete) { Delete(itemToDelete, onErrorCallback, onSuccessCallback); } }
public void ListBucketInventoryAsync(ListBucketInventoryRequest request, OnSuccessCallback <CosResult> successCallback, OnFailedCallback failCallback) { Schedue(request, new Model.Bucket.ListBucketInventoryResult(), successCallback, failCallback); }
public virtual void Delete(T itemToDelete, OnErrorCallback <T> onErrorCallback, OnSuccessCallback <T> onSuccessCallback) { throw new NotImplementedException(); }