예제 #1
0
func TestAll(t *testing.T) {

	testPut(t, key1)
	k1 := testPutWithoutKey(t)
	testPutFile(t, localFile, key2)
	k2 := testPutFileWithoutKey(t, localFile)

	//clear all keys
	rs.New(nil).Delete(nil, bucket, key1)
	rs.New(nil).Delete(nil, bucket, key2)
	rs.New(nil).Delete(nil, bucket, k1)
	rs.New(nil).Delete(nil, bucket, k2)
}
예제 #2
0
func testXVar(t *testing.T, token string, extra *PutExtra) {

	type Ret struct {
		PutRet
		X1 string `json:"x:1"`
	}
	var ret Ret
	f, err := os.Open(testFile)
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()

	fi, err := f.Stat()
	if err != nil {
		t.Fatal(err)
	}

	err = Put(nil, &ret, token, testKey, f, fi.Size(), extra)
	if err != nil {
		t.Fatal(err)
	}
	defer rs.New(nil).Delete(nil, bucket, ret.Key)

	if ret.X1 != "1" {
		t.Fatal("test xVar failed:", ret.X1)
	}
}
예제 #3
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func Copy(cmd string, params ...string) {
	if len(params) == 3 || len(params) == 4 {
		srcBucket := params[0]
		srcKey := params[1]
		destBucket := params[2]
		destKey := srcKey
		if len(params) == 4 {
			destKey = params[3]
		}
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		err := client.Copy(nil, srcBucket, srcKey, destBucket, destKey)
		if err != nil {
			log.Error("Copy error,", err)
		} else {
			fmt.Println("Done!")
		}
	} else {
		CmdHelp(cmd)
	}
}
예제 #4
0
파일: qiniu.go 프로젝트: sugeladi/goWeb
func copy(keySrc, keyDest string) {
	client := rs.New(mac)
	err := client.Copy(nil, Bucket, keySrc, Bucket_Copy, keyDest)
	if err != nil {
		//产生错误
		log.Println("rs.Copy failed:", err)
		return
	}
}
예제 #5
0
파일: demo.go 프로젝트: needkane/qiniu
//6.3 copy file
func copyFile(bucketSrc string, keySrc string, bucketDest string, keyDest string) {
	var rsCli = rs.New(nil)
	err := rsCli.Copy(nil, bucketSrc, keySrc, bucketDest, keyDest)
	if err != nil {
		log.Println("rs.Copy failed :", err)
		return
	} else {
		log.Println("copy success to:", bucketDest)
	}
}
예제 #6
0
func qiniuDeleteImage(fileName string) error {
	var client rs.Client
	client = rs.New(nil)

	err := client.Delete(nil, models.QiniuScope, fileName)
	if err != nil {
		revel.ERROR.Println("rs.Delete failed:", err)
	}

	return err
}
예제 #7
0
파일: qiniu.go 프로젝트: sugeladi/goWeb
func getInfo(key string) {
	var ret rs.Entry
	client := rs.New(mac)
	ret, err := client.Stat(nil, Bucket, key)
	if err != nil {
		//产生错误
		log.Println("rs.Stat failed:", err)
		return
	}
	//处理返回值
	log.Printf("ret:%+v", ret)
}
예제 #8
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func Fetch(mac *digest.Mac, remoteResUrl, bucket, key string) (fetchResult FetchResult, err error) {
	client := rs.New(mac)
	entry := bucket
	if key != "" {
		entry += ":" + key
	}
	fetchUri := fmt.Sprintf("/fetch/%s/to/%s",
		base64.URLEncoding.EncodeToString([]byte(remoteResUrl)),
		base64.URLEncoding.EncodeToString([]byte(entry)))
	err = client.Conn.Call(nil, &fetchResult, conf.IO_HOST+fetchUri)
	return
}
예제 #9
0
func init() {

	ACCESS_KEY = os.Getenv("QINIU_ACCESS_KEY")
	SECRET_KEY = os.Getenv("QINIU_SECRET_KEY")
	if ACCESS_KEY == "" || SECRET_KEY == "" {
		panic("require ACCESS_KEY & SECRET_KEY")
	}
	bucket = os.Getenv("QINIU_TEST_BUCKET")
	if bucket == "" {
		panic("require QINIU_TEST_BUCKET")
	}
	rs.New(nil).Delete(nil, bucket, testKey)
}
예제 #10
0
파일: demo.go 프로젝트: needkane/qiniu
//5.2delete file
func delFile2() {
	bucket := "need10"
	key := "132"
	var rsCli = rs.New(nil)
	err := rsCli.Delete(nil, bucket, key)
	if err != nil {
		//generate error
		log.Println("rs.Copy failed:", err)
		return
	} else {
		log.Println("success delete:", key)
	}

}
예제 #11
0
파일: qiniu.go 프로젝트: sugeladi/goWeb
func batchDel(keys []string) {

	entryPaths := []rs.EntryPath{}

	for _, key := range keys {
		ep := rs.EntryPath{
			Bucket: Bucket,
			Key:    key,
		}
		entryPaths = append(entryPaths, ep)
	}

	client := rs.New(mac)
	client.BatchDelete(nil, entryPaths)
}
예제 #12
0
func testPutFile(t *testing.T, token string, extra *PutExtra) {

	var ret PutRet
	f, err := os.Open(testFile)
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()

	err = PutFile(nil, &ret, token, testKey, testFile, extra)
	if err != nil {
		t.Fatal(err)
	}
	defer rs.New(nil).Delete(nil, bucket, ret.Key)
}
예제 #13
0
파일: qiniu.go 프로젝트: tzq668766/avatar
// 批量删除文件
func (this *QiniuController) DeleteFiles(bucketSrc string, keySrc []string) bool {
	entryPathes := make([]rs.EntryPath, len(keySrc))

	// 赋值
	for k, _ := range entryPathes {
		entryPathes[k].Bucket = bucketSrc
		entryPathes[k].Key = keySrc[k]
	}

	rsCli := rs.New(nil)

	_, err := rsCli.BatchDelete(nil, entryPathes)

	return err == nil
}
예제 #14
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func BatchCopy(cmd string, params ...string) {
	if len(params) == 3 {
		srcBucket := params[0]
		destBucket := params[1]
		srcDestKeyMapFile := params[2]
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		fp, err := os.Open(srcDestKeyMapFile)
		if err != nil {
			log.Error("Open src dest key map file error")
			return
		}
		defer fp.Close()
		scanner := bufio.NewScanner(fp)
		scanner.Split(bufio.ScanLines)
		entries := make([]qshell.CopyEntryPath, 0)
		for scanner.Scan() {
			line := strings.TrimSpace(scanner.Text())
			items := strings.Split(line, "\t")
			if len(items) == 1 || len(items) == 2 {
				srcKey := items[0]
				destKey := srcKey
				if len(items) == 2 {
					destKey = items[1]
				}
				if srcKey != "" && destKey != "" {
					entry := qshell.CopyEntryPath{srcBucket, destBucket, srcKey, destKey}
					entries = append(entries, entry)
				}
			}
			if len(entries) == BATCH_ALLOW_MAX {
				batchCopy(client, entries)
				entries = make([]qshell.CopyEntryPath, 0)
			}
		}
		if len(entries) > 0 {
			batchCopy(client, entries)
		}
		fmt.Println("All Copyed!")
	} else {
		CmdHelp(cmd)
	}
}
예제 #15
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func BatchDelete(cmd string, params ...string) {
	if len(params) == 2 {
		bucket := params[0]
		keyListFile := params[1]
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		fp, err := os.Open(keyListFile)
		if err != nil {
			log.Error("Open key list file error", err)
			return
		}
		defer fp.Close()
		scanner := bufio.NewScanner(fp)
		scanner.Split(bufio.ScanLines)
		entries := make([]rs.EntryPath, 0)
		for scanner.Scan() {
			line := strings.TrimSpace(scanner.Text())
			items := strings.Split(line, "\t")
			if len(items) > 0 {
				key := items[0]
				if key != "" {
					entry := rs.EntryPath{
						bucket, key,
					}
					entries = append(entries, entry)
				}
			}
			//check 1000 limit
			if len(entries) == BATCH_ALLOW_MAX {
				batchDelete(client, entries)
				//reset slice
				entries = make([]rs.EntryPath, 0)
			}
		}
		//delete the last batch
		if len(entries) > 0 {
			batchDelete(client, entries)
		}
		fmt.Println("All deleted!")
	} else {
		CmdHelp(cmd)
	}
}
예제 #16
0
파일: rs.go 프로젝트: HYQMartin/star
func rsDemo(bucket, key, bucketSrc, keySrc, bucketDest, keyDest string) {

	// @gist rsPre
	//此操作前 请确保 accesskey和secretkey 已被正确赋值
	var rsCli = rs.New(nil)
	var err error
	// @endgist

	// @gist rsStat
	var ret rs.Entry
	ret, err = rsCli.Stat(nil, bucket, key)
	if err != nil {
		// 产生错误
		log.Println("rs.Stat failed:", err)
		return
	}
	// 处理返回值
	log.Println(ret)
	// @endgist

	// @gist rsCopy
	err = rsCli.Copy(nil, bucketSrc, keySrc, bucketDest, keyDest)
	if err != nil {
		// 产生错误
		log.Println("rs.Copy failed:", err)
		return
	}
	// @endgist

	// @gist rsMove
	err = rsCli.Move(nil, bucketSrc, keySrc, bucketDest, keyDest)
	if err != nil {
		//产生错误
		log.Println("rs.Copy failed:", err)
		return
	}
	// @endgist

	// @gist rsDelete
	err = rsCli.Delete(nil, bucket, key)
	if err != nil {
		// 产生错误
		log.Println("rs.Copy failed:", err)
		return
	}
	// @endgist
}
예제 #17
0
파일: demo.go 프로젝트: needkane/qiniu
//高级批处理功能
func highBatch() {
	ops := []string{
		rs.URIStat("needkane", "need"),
		rs.URICopy("needkane", "kane3.jpg", "needcrystal", "kane"),
		rs.URIDelete("needkane", "kane3.jpg"),
	}
	rets := new([]rs.BatchItemRet)
	var rsCli = rs.New(nil)
	err := rsCli.Batch(nil, rets, ops)
	if err != nil {
		log.Println("rs.Batch failed:", err)
		return
	}
	for time, ret := range *rets {
		log.Println(time, "::", ret.Code, ret.Error)
	}
}
예제 #18
0
파일: fetch.go 프로젝트: rwifeng/qiniutools
func (t *Task) Run() {
	urls, err := UrlsToSync(t.SyncSrc)
	if err != nil {
		log.Error("Read Urls Failed:", err)
		return
	}

	cl, base, err := t.Synced()
	if err != nil {
		log.Error("Read Log Failed", err)
		return
	}
	left := namediff.Diff(urls, base)
	mac := digest.Mac{
		AccessKey: t.Ak,
		SecretKey: []byte(t.Sk),
	}
	log.Info("Entry Fetched:", len(base))
	log.Info("Entry ALL:", len(urls))
	log.Info("Entry TO Fetch:", len(left))
	c := rs.New(&mac)

	failed := 0
	for i := 0; i < len(left); i++ {
		urlSrc := t.srcUrl(left[i])
		key := destKey(left[i])
		err := c.Fetch(nil, urlSrc, t.Bucket, key)
		if err != nil {
			log.Error("Fetch Url Failed:", err, urlSrc)
			failed++
			continue
		}
		cl.Put(left[i])
		log.Info(urlSrc, "==>", t.Bucket, key)
	}

	if failed == 0 {
		log.Info("Fetch Success")
	} else {
		log.Info(failed, "Files Failed")
	}

	return
}
예제 #19
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func BatchRename(cmd string, params ...string) {
	if len(params) == 2 {
		bucket := params[0]
		oldNewKeyMapFile := params[1]
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		fp, err := os.Open(oldNewKeyMapFile)
		if err != nil {
			log.Error("Open old new key map file error")
			return
		}
		defer fp.Close()
		scanner := bufio.NewScanner(fp)
		scanner.Split(bufio.ScanLines)
		entries := make([]qshell.RenameEntryPath, 0)
		for scanner.Scan() {
			line := strings.TrimSpace(scanner.Text())
			items := strings.Split(line, "\t")
			if len(items) == 2 {
				oldKey := items[0]
				newKey := items[1]
				if oldKey != "" && newKey != "" {
					entry := qshell.RenameEntryPath{bucket, oldKey, newKey}
					entries = append(entries, entry)
				}
			}
			if len(entries) == BATCH_ALLOW_MAX {
				batchRename(client, entries)
				entries = make([]qshell.RenameEntryPath, 0)
			}
		}
		if len(entries) > 0 {
			batchRename(client, entries)
		}
		fmt.Println("All Renamed!")
	} else {
		CmdHelp(cmd)
	}
}
예제 #20
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func M3u8Delete(cmd string, params ...string) {
	if len(params) == 2 || len(params) == 3 {
		bucket := params[0]
		m3u8Key := params[1]
		isPrivate := false
		if len(params) == 3 {
			isPrivate, _ = strconv.ParseBool(params[2])
		}
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		m3u8FileList, err := qshell.M3u8FileList(&mac, bucket, m3u8Key, isPrivate)
		if err != nil {
			log.Error(err)
			return
		}
		client := rs.New(&mac)
		entryCnt := len(m3u8FileList)
		if entryCnt == 0 {
			log.Error("no m3u8 slices found")
			return
		}
		if entryCnt <= BATCH_ALLOW_MAX {
			batchDelete(client, m3u8FileList)
		} else {
			batchCnt := entryCnt / BATCH_ALLOW_MAX
			for i := 0; i < batchCnt; i++ {
				end := (i + 1) * BATCH_ALLOW_MAX
				if end > entryCnt {
					end = entryCnt
				}
				entriesToDelete := m3u8FileList[i*BATCH_ALLOW_MAX : end]
				batchDelete(client, entriesToDelete)
			}
		}
		fmt.Println("All deleted!")
	} else {
		CmdHelp(cmd)
	}
}
예제 #21
0
func TestAll(t *testing.T) {

	//先上传文件到空间做初始化准备
	for i := 0; i < 10; i++ {
		key := "rsf_test_put_" + strconv.Itoa(i)
		err := upFile("rsf_api.go", bucketName, key)
		if err != nil {
			t.Fatal(err)
		}
		keys = append(keys, key)
	}
	defer func() {
		for _, k := range keys {
			rs.New(nil).Delete(nil, bucketName, k)
		}
	}()

	testList(t)
	testEof(t)
}
예제 #22
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func Stat(cmd string, params ...string) {
	if len(params) == 2 {
		bucket := params[0]
		key := params[1]
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		entry, err := client.Stat(nil, bucket, key)
		if err != nil {
			log.Error("Stat error,", err)
		} else {
			printStat(bucket, key, entry)
		}
	} else {
		CmdHelp(cmd)
	}
}
예제 #23
0
func testPutWithoutKey(t *testing.T, token string, extra *PutExtra) {

	var ret PutRet
	f, err := os.Open(testFile)
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()

	fi, err := f.Stat()
	if err != nil {
		t.Fatal(err)
	}

	err = PutWithoutKey(nil, &ret, token, f, fi.Size(), extra)
	if err != nil {
		t.Fatal(err)
	}
	defer rs.New(nil).Delete(nil, bucket, ret.Key)
}
예제 #24
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func Delete(cmd string, params ...string) {
	if len(params) == 2 {
		bucket := params[0]
		key := params[1]
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		err := client.Delete(nil, bucket, key)
		if err != nil {
			log.Error("Delete error,", err)
		} else {
			fmt.Println("Done!")
		}
	} else {
		CmdHelp(cmd)
	}
}
예제 #25
0
파일: qiniu.go 프로젝트: wxaxiaoyao/linux
func QiniuInit() error {
	c := common.MongoCollection(FILE_DB, FILE_QINIU_FILE_TABLE)

	index := mgo.Index{
		Key:      []string{"filename"},
		Unique:   true,
		DropDups: true,
	}

	g_file_mgr = &FileMgr{
		fileCh:       make(chan *File, 100),
		expiredTimer: time.Tick(time.Hour),
		waitGroup:    sync.NewWaitGroup(),
		rsClient:     rs.New(&digest.Mac{AccessKey: g_access_key, SecretKey: []byte(g_secret_key)}),
	}

	go g_file_mgr.run()

	return errors.As(c.EnsureIndex(index))
}
예제 #26
0
파일: qiniu.go 프로젝트: tzq668766/avatar
// 批量移动文件
func (this *QiniuController) MoveFiles(bucketSrc string, keySrc []string, bucketDest string, keyDest []string) []rs.BatchItemRet {
	// 每个复制操作都含有源文件和目标文件
	entryPairs := make([]rs.EntryPathPair, len(keySrc))

	for k, _ := range entryPairs {
		entryPairs[k].Src.Bucket = bucketSrc
		entryPairs[k].Src.Key = keySrc[k]
		entryPairs[k].Dest.Bucket = bucketDest
		entryPairs[k].Dest.Key = keyDest[k]
	}

	rsCli := rs.New(nil)

	batchCopyRets, err := rsCli.BatchMove(nil, entryPairs)

	if err != nil {
		return nil
	}

	return batchCopyRets
}
예제 #27
0
파일: qiniu.go 프로젝트: tzq668766/avatar
// 批量获取图片信息
func (this *QiniuController) GetInfos(bucketSrc string, keySrc []string) []rs.BatchStatItemRet {
	entryPathes := make([]rs.EntryPath, len(keySrc))

	// 赋值
	for k, _ := range entryPathes {
		entryPathes[k].Bucket = bucketSrc
		entryPathes[k].Key = keySrc[k]
	}

	var batchStatRets []rs.BatchStatItemRet

	rsCli := rs.New(nil)

	batchStatRets, err := rsCli.BatchStat(nil, entryPathes)

	if err != nil {
		return nil
	}

	return batchStatRets
}
예제 #28
0
파일: rs.go 프로젝트: joozo-gexia/qshell
func Chgm(cmd string, params ...string) {
	if len(params) == 3 {
		bucket := params[0]
		key := params[1]
		newMimeType := params[2]
		accountS.Get()
		mac := digest.Mac{
			accountS.AccessKey,
			[]byte(accountS.SecretKey),
		}
		client := rs.New(&mac)
		err := client.ChangeMime(nil, bucket, key, newMimeType)
		if err != nil {
			log.Error("Change mimeType error,", err)
		} else {
			fmt.Println("Done!")
		}
	} else {
		CmdHelp(cmd)
	}
}
예제 #29
0
파일: qiniu.go 프로젝트: sugeladi/goWeb
func batchCopyBucketQiniu(keys []string, srcBucket, descBucket string) error {

	entryPairs := []rs.EntryPathPair{}

	for _, key := range keys {
		epp := rs.EntryPathPair{
			Src: rs.EntryPath{
				Bucket: srcBucket,
				Key:    key,
			},
			Dest: rs.EntryPath{
				Bucket: descBucket,
				Key:    key,
			},
		}
		entryPairs = append(entryPairs, epp)
	}

	client := rs.New(mac)
	_, err := client.BatchCopy(nil, entryPairs)
	return err
}
예제 #30
0
파일: demo.go 프로젝트: needkane/qiniu
func getBatchInfo() {
	entryPathes := []rs.EntryPath{
		rs.EntryPath{
			Bucket: "needkane",
			Key:    "kane3.jpg",
		},
		rs.EntryPath{
			Bucket: "needcrystal",
			Key:    "needtoo",
		},
	}
	var batchStatRests []rs.BatchStatItemRet
	var rsCli = rs.New(nil)

	batchStatRests, err := rsCli.BatchStat(nil, entryPathes)
	if err != nil {
		log.Println("rs.BatchStat failed", err)
		return
	}
	for time, item := range batchStatRests {
		log.Println(time, ";;;;", item)
	}

}