public void ResumeUploadFileTest()
        {
            Mac    mac  = new Mac(AccessKey, SecretKey);
            Random rand = new Random();
            string key  = string.Format("UploadFileTest_{0}.dat", rand.Next());

            string filePath = LocalFile;

            System.IO.Stream fs = System.IO.File.OpenRead(filePath);

            PutPolicy putPolicy = new PutPolicy();

            putPolicy.Scope = Bucket + ":" + key;
            putPolicy.SetExpires(3600);
            putPolicy.DeleteAfterDays = 1;
            string token = Auth.CreateUploadToken(mac, putPolicy.ToJsonString());

            Config config = new Config();

            config.UseHttps      = true;
            config.Zone          = Zone.ZONE_CN_East;
            config.UseCdnDomains = true;
            config.ChunkSize     = ChunkUnit.U512K;
            ResumableUploader target = new ResumableUploader(config);
            PutExtra          extra  = new PutExtra();

            //设置断点续传进度记录文件
            extra.ResumeRecordFile = ResumeHelper.GetDefaultRecordKey(filePath, key);
            Console.WriteLine("record file:" + extra.ResumeRecordFile);
            extra.ResumeRecordFile = "test.progress";
            HttpResult result = target.UploadStream(fs, key, token, extra);

            Console.WriteLine("resume upload: " + result.ToString());
            Assert.AreEqual((int)HttpCode.OK, result.Code);
        }
Beispiel #2
0
        /// <summary>
        /// [异步async]上传文件
        /// </summary>
        /// <param name="localFile">本地待上传的文件名</param>
        /// <param name="saveKey">要保存的文件名称</param>
        /// <param name="token">上传凭证</param>
        /// <returns>上传文件后的返回结果</returns>
        public async Task <HttpResult> UploadFileAsync(StorageFile localFile, string saveKey, string token)
        {
            HttpResult result = new HttpResult();

            var fi = await localFile.GetBasicPropertiesAsync();

            if (fi.Size > (ulong)PUT_THRESHOLD)
            {
                if (recordFile == null)
                {
                    string recordKey = ResumeHelper.GetDefaultRecordKey(localFile.Path, saveKey);
                    recordFile = await(await UserEnv.GetHomeFolderAsync()).CreateFileAsync(recordKey, CreationCollisionOption.OpenIfExists);
                }
                if (upph == null)
                {
                    upph = new UploadProgressHandler(ResumableUploader.DefaultUploadProgressHandler);
                }

                if (upctl == null)
                {
                    upctl = new UploadController(ResumableUploader.DefaultUploadController);
                }

                ResumableUploader ru = new ResumableUploader(UPLOAD_FROM_CDN, CHUNK_UNIT);
                result = await ru.UploadFileAsync(localFile, saveKey, token, recordFile, upph, upctl);
            }
            else
            {
                FormUploader fu = new FormUploader(UPLOAD_FROM_CDN);
                result = await fu.UploadFileAsync(localFile, saveKey, token);
            }

            return(result);
        }
Beispiel #3
0
        /// <summary>
        /// [异步async]上传文件
        /// </summary>
        /// <param name="localFile">本地待上传的文件名</param>
        /// <param name="saveKey">要保存的文件名称</param>
        /// <param name="token">上传凭证</param>
        /// <returns>上传文件后的返回结果</returns>
        public async Task <HttpResult> UploadFileAsync(string localFile, string saveKey, string token)
        {
            HttpResult result = new HttpResult();

            var fi = new FileInfo(localFile);

            if (fi.Length > PUT_THRESHOLD)
            {
                if (recordFile == null)
                {
                    string recordKey = ResumeHelper.GetDefaultRecordKey(localFile, saveKey);
                    recordFile = Path.Combine(UserEnv.GetHomeFolder(), recordKey);
                }
                if (upph == null)
                {
                    upph = new UploadProgressHandler(ResumableUploader.DefaultUploadProgressHandler);
                }

                if (upctl == null)
                {
                    upctl = new UploadController(ResumableUploader.DefaultUploadController);
                }

                ResumableUploader ru = new ResumableUploader(UPLOAD_FROM_CDN, CHUNK_UNIT);
                result = await ru.UploadFileAsync(localFile, saveKey, token, recordFile, upph, upctl);
            }
            else
            {
                FormUploader fu = new FormUploader(UPLOAD_FROM_CDN);
                result = await fu.UploadFileAsync(localFile, saveKey, token);
            }

            return(result);
        }
Beispiel #4
0
        public string UploadImage(string filePath)
        {
            Mac mac = new Mac("TYb8ZurNoN-xrUOhnNom_q3ZdPl1OLJqUsvoP0xB", "d7ajdjoitbUiJZQY7ANw5bSf3p6K3nQA8KkGxIDq");
            // 上传文件名
            string key = "putty2.gif";
            // 本地文件路径
            //string filePath = @"E:\MY\FastDevStu\Mvc\Models\微信图片_20190508193805.gif";
            // 空间名
            string Bucket = "cjj81pic";
            // 设置上传策略,详见:https://developer.qiniu.com/kodo/manual/1206/put-policy
            PutPolicy putPolicy = new PutPolicy();

            putPolicy.Scope = Bucket + ":" + key;
            putPolicy.SetExpires(3600);
            string token = Auth.CreateUploadToken(mac, putPolicy.ToJsonString());

            Qiniu.Storage.Config config = new Qiniu.Storage.Config();
            // 设置上传区域
            config.Zone = Zone.ZONE_CN_South;
            // 设置 http 或者 https 上传
            config.UseHttps      = true;
            config.UseCdnDomains = true;
            config.ChunkSize     = ChunkUnit.U512K;
            ResumableUploader target = new ResumableUploader(config);
            PutExtra          extra  = new PutExtra();

            //设置断点续传进度记录文件
            extra.ResumeRecordFile = ResumeHelper.GetDefaultRecordKey(filePath, key);
            Console.WriteLine("record file:" + extra.ResumeRecordFile);
            extra.ResumeRecordFile = "test.progress";
            HttpResult result = target.UploadFile(filePath, key, token, extra);

            Console.WriteLine("resume upload: " + result.ToString());
            return(result.ToString());
        }
Beispiel #5
0
        private bool UploadFileOverlay(string file, bool overLay = false)
        {
            //  string filePath = LocalFile;
            if (uploadResult == null)
            {
                uploadResult = new StringBuilder();
            }
            if (putPolicy != null)
            {
                string           key = Path.GetFileName(file);
                System.IO.Stream fs  = System.IO.File.OpenRead(file);
                if (overLay)
                {
                    putPolicy.Scope = bucket + ":" + key;
                }
                else
                {
                    putPolicy.Scope = bucket;
                }
                putPolicy.SetExpires(3600);

                putPolicy.DeleteAfterDays = qiNiuClientCfg.DeleteAfterDays;


                string token = Auth.CreateUploadToken(mac, putPolicy.ToJsonString());

                ResumableUploader target = new ResumableUploader(config);
                PutExtra          extra  = new PutExtra {
                    ResumeRecordFile = ResumeHelper.GetDefaultRecordKey(file, key)
                };
                //设置断点续传进度记录文件

                uploadResult.AppendLine("record file:" + extra.ResumeRecordFile);
                // extra.ResumeRecordFile = "test.progress";
                //todo:未实现上传进度
                HttpResult result = target.UploadStream(fs, key, token, extra);

                if (result.Code == 200)
                {
                    uploadResult.AppendLine("上传成功! ");
                    return(true);
                }
                else
                {
                    string s = $"Code={result.Code},Text={result.Text}";
                    uploadResult.AppendLine("uploadResult:" + s);
                    return(false);
                }
            }
            uploadResult.AppendLine("成员变量putPolicy为空!");
            return(false);
        }
Beispiel #6
0
        /// <summary>
        /// 分片上传(断点续传)
        /// </summary>
        /// <param name="key"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        public string ChunkUpload(string key, string path)
        {
            ResumableUploader resumableUploader = new ResumableUploader(ConfigUtil);

            PutExtra putExtra = new PutExtra
            {
                ResumeRecordFile = ResumeHelper.GetDefaultRecordKey(path, key)
            };

            HttpResult httpResult = resumableUploader.UploadFile(path, key, TokenUtil, putExtra);

            return(httpResult.Text);
        }
Beispiel #7
0
 public void FileUpload()
 {
     try
     {
         int fileid = 0;
         var files  = Request.Form.Files;
         if (files.Count > 0)
         {
             var file = files.First();
             if (file.Length > (200 * 1024 * 1024))
             {
                 //return Json("文件过大,不能大于200M");
             }
             PutExtra putExtra = new PutExtra();// { ProgressHandler = UploadProgressHandler,  ResumeRecordFile  };
             putExtra.ProgressHandler  = UploadProgressHandler;
             putExtra.UploadController = DefaultUploadController;
             putExtra.ResumeRecordFile = ResumeHelper.GetDefaultRecordKey($"{Environment.CurrentDirectory}\\{file.FileName}", file.FileName);
             var aa = putExtra.ResumeRecordFile;
             putExtra.ResumeRecordFile = file.FileName + ".progress";
             HttpResult result = new HttpResult();
             Stream     stream = file.OpenReadStream();
             result = qiniu.UploadStream(file.FileName, stream, putExtra);
             if (result.Code == (int)HttpCode.OK)
             {
                 //todo 入库文件信息
                 var     rj            = JObject.Parse(result.Text);
                 string  hash          = rj["hash"].ToString();
                 string  key           = rj["key"].ToString();
                 var     hashentity    = ossfile.GetList(t => t.FileHash == hash);
                 OssFile ossFileEntity = new OssFile
                 {
                     FileKey    = key,
                     FileHash   = hash,
                     FileDomain = ""
                 };
                 ossfile.Insert_Return_Id(ossFileEntity, out fileid);
             }
             //检查删除文件
             if (System.IO.File.Exists($"{Environment.CurrentDirectory}\\{file.FileName}"))
             {
                 System.IO.File.Delete($"{Environment.CurrentDirectory}\\{file.FileName}");
             }
         }
     }
     catch (Exception ex)
     {
         // return Json(ex.Message);
     }
 }
Beispiel #8
0
        /// <summary>
        /// 断点续传
        /// </summary>
        /// <param name="localFile"></param>
        /// <returns></returns>
        public string ResumeUploadFile(string localFile)
        {
            if (!File.Exists(localFile))
            {
                return("文件不存在");
            }
            var    filename  = Path.GetFileName(localFile);  //文件名
            var    extension = Path.GetExtension(localFile); //扩展名
            var    mac       = new Mac(AccessKey, SecretKey);
            var    rand      = new Random();
            string key       = $"jnkj_{rand.Next()}{extension}";
            Stream fs        = File.OpenRead(localFile);
            var    putPolicy = new PutPolicy {
                Scope = Bucket + ":" + key
            };

            putPolicy.SetExpires(3600);
            putPolicy.DeleteAfterDays = 1;
            var token  = Auth.CreateUploadToken(mac, putPolicy.ToJsonString());
            var config = new Config
            {
                UseHttps      = true,
                Zone          = Zone.ZONE_CN_East,
                UseCdnDomains = true,
                ChunkSize     = ChunkUnit.U512K
            };
            var target = new ResumableUploader(config);
            var extra  = new PutExtra {
                ResumeRecordFile = ResumeHelper.GetDefaultRecordKey(localFile, key)
            };

            //设置断点续传进度记录文件
            Console.WriteLine("record file:" + extra.ResumeRecordFile);
            extra.ResumeRecordFile = "test.progress";
            var result = target.UploadStream(fs, key, token, extra);

            Console.WriteLine("resume upload: " + result);
            return(result.ToString());
        }
Beispiel #9
0
        public async Task ResumeUploadFileTest()
        {
            var mac  = new Mac(AccessKey, SecretKey);
            var rand = new Random();
            var key  = $"UploadFileTest_{rand.Next()}.dat";

            var    filePath = LocalFile;
            Stream fs       = File.OpenRead(filePath);

            var putPolicy = new PutPolicy
            {
                Scope           = Bucket + ":" + key,
                DeleteAfterDays = 1
            };

            putPolicy.SetExpires(3600);
            var token = Auth.CreateUploadToken(mac, putPolicy.ToJsonString());

            var config = new Config
            {
                UseHttps      = true,
                Zone          = Zone.ZoneCnEast,
                UseCdnDomains = true,
                ChunkSize     = ChunkUnit.U512K
            };
            var target = new ResumableUploader(config);
            //设置断点续传进度记录文件
            var extra = new PutExtra {
                ResumeRecordFile = ResumeHelper.GetDefaultRecordKey(filePath, key)
            };

            Console.WriteLine("record file:" + extra.ResumeRecordFile);
            extra.ResumeRecordFile = "test.progress";
            var result = await target.UploadStream(fs, key, token, extra);

            Console.WriteLine("resume upload: " + result);
            Assert.Equal((int)HttpCode.OK, result.Code);
        }