def __init__(self,window):
conf.ACCESS_KEY="BbDU4MoFrx2YaF6tqBFmnKHFuDlq1EO-mm2ldlBm"
conf.SECRET_KEY="WWdwgm4oRmOh_L9yKbyWplcUFaIGAZXk8e_UOtDs"
self.policy=rs.PutPolicy(ZONENAME)
self.token=self.policy.token()
self.window=window
self.filename=os.path.basename(Db).strip()
def test_block(self):
if is_travis:
return
policy = rs.PutPolicy(bucket)
uptoken = policy.token()
client = up.Client(uptoken)
# rets = [0, 0]
data_slice_2 = "\nbye!"
ret, err = resumable_io.mkblock(client, len(data_slice_2),
data_slice_2)
assert err is None, err
self.assertEqual(ret["crc32"], binascii.crc32(data_slice_2))
extra = resumable_io.PutExtra(bucket)
extra.mimetype = "text/plain"
extra.progresses = [ret]
lens = 0
for i in xrange(0, len(extra.progresses)):
lens += extra.progresses[i]["offset"]
key = u"sdk_py_resumable_block_4_%s" % r(9)
ret, err = resumable_io.mkfile(client, key, lens, extra)
assert err is None, err
self.assertEqual(ret["hash"], "FtCFo0mQugW98uaPYgr54Vb1QsO0",
"hash not match")
rs.Client().delete(bucket, key)
def put(self, img_url, key=None, rename=None):
"""
put your data to qiniu. If key is None, the server will generate one.
Note: img_url is web url.
"""
r = None
if img_url is None:
raise ValueError('upload img path to qiniu error!')
for i in range(5):
r = requests.get(img_url, timeout=10.0)
if r is not None:
break
policy = rs.PutPolicy(bucket_name)
policy.saveKey = rename
up_token = policy.token()
ret, err = io.put(up_token, key, StringIO(r.content))
if err is not None:
sys.stderr.write('error: %s ' % err)
return ret['key']
else:
# print 'upload img ok.'
pass
return ret
def test_put(self):
if is_travis:
return
src = urllib.urlopen("http://cheneya.qiniudn.com/hello_jpg")
ostype = platform.system()
if ostype.lower().find("windows") != -1:
tmpf = "".join([os.getcwd(), os.tmpnam()])
else:
tmpf = os.tmpnam()
dst = open(tmpf, 'wb')
shutil.copyfileobj(src, dst)
src.close()
policy = rs.PutPolicy(bucket)
extra = resumable_io.PutExtra(bucket)
extra.bucket = bucket
extra.params = {"x:foo": "test"}
key = "sdk_py_resumable_block_5_%s" % r(9)
localfile = dst.name
ret, err = resumable_io.put_file(policy.token(), key, localfile, extra)
assert ret.get("x:foo") == "test", "return data not contains 'x:foo'"
dst.close()
os.remove(tmpf)
assert err is None, err
self.assertEqual(ret["hash"], "FnyTMUqPNRTdk1Wou7oLqDHkBm_p",
"hash not match")
rs.Client().delete(bucket, key)
def test_put_4m(self):
if is_travis:
return
ostype = platform.system()
if ostype.lower().find("windows") != -1:
tmpf = "".join([os.getcwd(), os.tmpnam()])
else:
tmpf = os.tmpnam()
dst = open(tmpf, 'wb')
dst.write("abcd" * 1024 * 1024)
dst.flush()
policy = rs.PutPolicy(bucket)
extra = resumable_io.PutExtra(bucket)
extra.bucket = bucket
extra.params = {"x:foo": "test"}
key = "sdk_py_resumable_block_6_%s" % r(9)
localfile = dst.name
ret, err = resumable_io.put_file(policy.token(), key, localfile, extra)
assert ret.get("x:foo") == "test", "return data not contains 'x:foo'"
dst.close()
os.remove(tmpf)
assert err is None, err
self.assertEqual(ret["hash"], "FnIVmMd_oaUV3MLDM6F9in4RMz2U",
"hash not match")
rs.Client().delete(bucket, key)
def __init__(self):
os.chdir(PATH)
self.prefix = time.strftime("%Y%m%d", time.localtime())
conf.ACCESS_KEY = "BbDU4MoFrx2YaF6tqBFmnKHFuDlq1EO-mm2ldlBm"
conf.SECRET_KEY = "WWdwgm4oRmOh_L9yKbyWplcUFaIGAZXk8e_UOtDs"
policy = rs.PutPolicy("ljdpython")
self.token = policy.token()
def put_file(self, name, content):
bucket = BUCKET_KEY
policy = rs.PutPolicy(bucket)
token = policy.token()
ret, err = io.put(token, name, content)
if err is not None:
raise IOError("QiniuStorageError: %s", err)
return self.img_url(name)
def save_file_qiniu(binary, filename, mime="application/octet-stream"):
policy = rs.PutPolicy(QiniuConf.BUCKET_NAME)
uptoken = policy.token()
extra = io.PutExtra()
extra.mime_type = mime
res, err = io.put(uptoken, filename, binary, extra)
if err is not None:
return 'none'
url = rs.make_base_url(QiniuConf.BUCKET_DOMAIN, filename)
return url
def _put_file(self, name, content):
if self.encrypt_func:
content = self.encrypt_func(content)
policy = rs.PutPolicy(self.bucket)
uptoken = policy.token()
ret, err = io.put(uptoken, name, content)
if err is not None:
raise IOError("QiniuStorageError: %s", err)
def test_put_policy(self):
policy = rs.PutPolicy(bucket_name)
policy.endUser = "******"
tokens = policy.token().split(':')
self.assertEqual(conf.ACCESS_KEY, tokens[0])
data = json.loads(decode(tokens[2]))
self.assertEqual(data["scope"], bucket_name)
self.assertEqual(data["endUser"], policy.endUser)
new_hmac = encode(hmac.new(conf.SECRET_KEY, tokens[2], sha1).digest())
self.assertEqual(new_hmac, tokens[1])
def upload_by_rawdata(rawdata, length):
policy = qiniu_rs.PutPolicy(qiniu_bucket)
uptoken = policy.token()
extra = rio.PutExtra(qiniu_bucket)
ret, err = rio.put(uptoken, None, rawdata, length, extra)
if err is not None:
log.error('rio put raw file return ret:%s, err:%s' % (str(ret), err))
return None
else:
log.info('rio put raw file return ret:%s, err:%s' % (str(ret), err))
return ret['key']
def get(self):
conf.ACCESS_KEY = ACCESS_KEY
conf.SECRET_KEY = SECRET_KEY
policy = rs.PutPolicy(BUCKET)
policy.returnUrl = ''
policy.returnBody = 'etag=$(etag)&pid=$(persistentId)'
#policy.callbackUrl = ''
#policy.callbackBody = ''
policy.persistentOps = 'avthumb/mp3/ar/44100/ab/32k;avthumb/mp3/aq/6/ar/16000'
policy.persistentNotifyUrl = ''
uploadToken = policy.token()
self.render('upload.html', token=uploadToken)
return
def get(self):
jsonp = self.get_argument('jsonp', 'callback')
self.set_header('Content-Type', 'application/json')
conf.ACCESS_KEY = ACCESS_KEY
conf.SECRET_KEY = SECRET_KEY
policy = rs.PutPolicy(BUCKET)
policy.callbackUrl = 'http://dev-api.tuktalk.com/apis/cb'
policy.callbackBody = 'key=$(etag)'
#policy.persistentOps = 'avthumb/mp3/ar/44100/ab/32k;avthumb/mp3/aq/6/ar/16000'
#policy.persistentNotifyUrl = ''
uploadToken = policy.token()
self.write('%s(%s)' % (jsonp, json.dumps(uploadToken)))
return
def get(self):
globalConf = self.settings['globalConfig']
accessKey = globalConf.get('qiniu', 'accesskey')
secretKey = globalConf.get('qiniu', 'secretkey')
bucket = globalConf.get('qiniu', 'bucket')
selfHost = globalConf.get('website', 'host')
qConf.ACCESS_KEY = accessKey
qConf.SECRET_KEY = secretKey
policy = qRs.PutPolicy(bucket)
policy.callbackUrl = '%s/api/q_callback' % (selfHost, )
policy.callbackBody = 'etag=$(etag)'
uploadToken = policy.token()
self.ajax_result(0, 0, data=uploadToken)
return
def post(self):
mimeType = 'application/json'
if self.request.headers.get('Content-Type', '') == mimeType:
data = self.request.body
dataObj = json.loads(data)
pid = dataObj.get('id', 'default')
conf.ACCESS_KEY = STORAGE_ACCESS_KEY
conf.SECRET_KEY = STORAGE_SECRET_KEY
storagePolicy = rs.PutPolicy(STORAGE_BUCKET)
storageToken = storagePolicy.token()
extra = io.PutExtra()
extra.mime_type = mimeType
io.put(storageToken, str(pid), data, extra)
return
def get(self):
globalConf = self.settings['globalConfig']
accessKey = globalConf.get('qiniu', 'accesskey')
secretKey = globalConf.get('qiniu', 'secretkey')
bucket = globalConf.get('qiniu', 'bucket')
selfHost = globalConf.get('website', 'host')
qConf.ACCESS_KEY = accessKey
qConf.SECRET_KEY = secretKey
policy = qRs.PutPolicy(bucket)
policy.callbackUrl = '%s/api/q_callback' % (selfHost, )
policy.callbackBody = 'etag=$(etag)&opsId=$(persistentId)&file_name=$(x:file_name)&file_size=$(fsize)'
policy.persistentOps = 'avthumb/m3u8/preset/video_240k;avthumb/android'
policy.persistentNotifyUrl = '%s/api/q_notify' % (selfHost, )
uploadToken = policy.token()
self.ajax_result(0, 0, data=uploadToken)
return
def test_put_0(self):
if is_travis:
return
f = StringIO.StringIO('')
policy = rs.PutPolicy(bucket)
extra = resumable_io.PutExtra(bucket)
extra.bucket = bucket
extra.params = {"x:foo": "test"}
key = "sdk_py_resumable_block_7_%s" % r(9)
ret, err = resumable_io.put(policy.token(), key, f, 0, extra)
assert err is None, err
assert ret.get("x:foo") == "test", "return data not contains 'x:foo'"
self.assertEqual(ret["hash"], "Fg==", "hash not match")
rs.Client().delete(bucket, key)
def qvttUpload(self, key):
domain = self.conf.get('qiniu', 'domain')
accessKey = self.conf.get('qiniu', 'accesskey')
secretKey = self.conf.get('qiniu', 'secretkey')
bucket = self.conf.get('qiniu', 'bucket')
qConf.ACCESS_KEY = accessKey
qConf.SECRET_KEY = secretKey
policy = qRs.PutPolicy(bucket)
uploadToken = policy.token()
url = '%s/%s' % (domain, key)
key = '%s.vtt' % (key, )
data = makeContent(url)
qIo.put(uploadToken, key, data)
return
def put_files(self, key=None, local_file=None, rename=None):
"""
put local file to qiniu. If key is None, the server will generate one.
Note: local_file if local file path.
"""
if local_file is None:
raise NameError('upload file to qiniu error!')
policy = rs.PutPolicy(bucket_name)
policy.saveKey = rename
up_token = policy.token()
ret, err = io.put_file(up_token, key, local_file)
if err is not None:
sys.stderr.write('error: %s ' % err)
return ret['key']
else:
# print 'upload local: %s file ok.' % local_file
pass
return ret
def update(orgin_bucket, target_bucket, returnUrl, user_id, oops, pipeline):
conf.ACCESS_KEY = config.QINIU_ACCESS_KEY
conf.SECRET_KEY = config.QINIU_SECRET_KEY
key = str(datetime.now())[:19] + str(user_id)
print key
policy = rs.PutPolicy("%s:%s" % (orgin_bucket, key))
policy.returnUrl = returnUrl
policy.returnBody = '{"hash": $(etag), "key": "%s", "persistentId":"$(persistentId)"}' % key
policy.mimeLimit = "image/*"
policy.fsizeLimit = 12000000
# 本地压缩后上传和原图直传，上传策略不一样 add by lee @14.9.21 21:28
if oops != '':
entry = target_bucket + ':' + key
EncodeEntryURI = base64.urlsafe_b64encode(entry)
# oops 举例：'imageView2/1/w/100/h/100/q/100|saveas/'
Ops = oops + EncodeEntryURI
policy.persistentOps = Ops
policy.persistentPipeline = pipeline # 为空表示使用公用队列，否则使用私用队列
uptoken = policy.token()
return uptoken, key
def post(self):
bucket = str(self.get_argument('bucket', ''))
aKey = str(self.get_argument('access_key', ''))
sKey = str(self.get_argument('secret_key', ''))
persistentOps = filter(lambda x: x, self.get_arguments('ops'))
persistentNotifyUrl = '%s/notify_cb' % (HOST, )
returnUrl = '%s/result' % (HOST, )
#returnBody = 'etag=$(etag)&pid=$(persistentId)'
if bucket and aKey and sKey and persistentOps and persistentNotifyUrl:
conf.ACCESS_KEY = aKey
conf.SECRET_KEY = sKey
policy = rs.PutPolicy(bucket)
policy.returnUrl = returnUrl
#policy.returnBody = returnBody
policy.persistentOps = str(';'.join(persistentOps))
policy.persistentNotifyUrl = persistentNotifyUrl
uploadToken = policy.token()
self.set_cookie('token', uploadToken)
else:
self.set_cookie('token', '')
self.redirect('/token')
return
def test_put_policy(self):
policy = rs.PutPolicy(bucket_name)
policy.endUser = "******"
policy.returnUrl = "http://localhost:1234/path?query=hello"
policy.returnBody = "$(sha1)"
# Do not specify the returnUrl and callbackUrl at the same time
policy.callbackUrl = "http://1.2.3.4/callback"
policy.callbackBody = "$(bucket)"
policy.saveKey = "$(sha1)"
policy.insertOnly = 1
policy.detectMime = 1
policy.fsizeLimit = 1024
policy.persistentNotifyUrl = "http://4.3.2.1/persistentNotifyUrl"
policy.persistentOps = "avthumb/flash"
tokens = policy.token().split(':')
# chcek first part of token
self.assertEqual(conf.ACCESS_KEY, tokens[0])
data = json.loads(decode(tokens[2]))
# check if same
self.assertEqual(data["scope"], bucket_name)
self.assertEqual(data["endUser"], policy.endUser)
self.assertEqual(data["returnUrl"], policy.returnUrl)
self.assertEqual(data["returnBody"], policy.returnBody)
self.assertEqual(data["callbackUrl"], policy.callbackUrl)
self.assertEqual(data["callbackBody"], policy.callbackBody)
self.assertEqual(data["saveKey"], policy.saveKey)
self.assertEqual(data["exclusive"], policy.insertOnly)
self.assertEqual(data["detectMime"], policy.detectMime)
self.assertEqual(data["fsizeLimit"], policy.fsizeLimit)
self.assertEqual(data["persistentNotifyUrl"],
policy.persistentNotifyUrl)
self.assertEqual(data["persistentOps"], policy.persistentOps)
new_hmac = encode(hmac.new(conf.SECRET_KEY, tokens[2], sha1).digest())
self.assertEqual(new_hmac, tokens[1])
def save_file_qiniu(binary, filename, mime="application/octet-stream"):
today = datetime.now().strftime("%Y/%m/%d/")
filename = today + filename
policy = rs.PutPolicy(QINIU_SETTINGS.BUCKET_NAME)
uptoken = policy.token()
extra = io.PutExtra()
extra.mime_type = mime
res, err = io.put(uptoken, filename, binary, extra)
if err is not None:
raise Exception("Qiniu save file [%s] error: %s res: %s" % (filename, err, res))
url = rs.make_base_url(QINIU_SETTINGS.BUCKET_DOMAIN, filename)
iv = fop.ImageView()
iv.mode = 2
iv.width = THUMB_SIZE[0]
url_thumb = iv.make_request(url)
return url, url_thumb
def uptoken():
policy = rs.PutPolicy(BUCKET_NAME)
uptoken = policy.token()
return '{"uptoken": "%s"}' % (uptoken)
import zlib
binascii = zlib
except ImportError:
zlib = None
import binascii
import cStringIO
from qiniu import conf
from qiniu import rs
from qiniu import io
conf.ACCESS_KEY = os.getenv("QINIU_ACCESS_KEY")
conf.SECRET_KEY = os.getenv("QINIU_SECRET_KEY")
bucket_name = os.getenv("QINIU_TEST_BUCKET")
policy = rs.PutPolicy(bucket_name)
extra = io.PutExtra()
extra.mime_type = "text/plain"
extra.params = {'x:a': 'a'}
def r(length):
lib = string.ascii_uppercase
return ''.join([random.choice(lib) for i in range(0, length)])
class TestUp(unittest.TestCase):
def test(self):
def test_put():
key = "test_%s" % r(9)
# params = "op=3"