class Qiniu(object): def init_app(self, app): access_key = app.config.get('QINIU_ACCESS_KEY') secret_key = app.config.get('QINIU_SECRET_KEY') self.app = app self.bucket = app.config.get('QINIU_BUCKET') self.auth = Auth(access_key, secret_key) def upload_file(self, filename, filepath): """上传本地文件""" token = self.auth.upload_token(self.bucket, filename) ret, info = put_file(token, filename, filepath) if info.exception is not None: raise UploadError(info) def upload_data(self, filename, data): """上传二进制数据""" token = self.auth.upload_token(self.bucket, filename) ret, info = put_data(token, filename, data) if info.exception is not None: raise UploadError(info) def generate_token(self, filename=None, policy=None): """生成上传凭证""" return self.auth.upload_token(self.bucket, filename, policy=policy)
class QiNiu(object): def __init__(self): self.authed = Auth(AccessKey, SecretKey) def upload(self, data): """ :param data: { "filename":"", "filepath":"", "policy":{} } :return: ret info """ filename = data["filename"] filepath = data["filepath"] policy = data.get("policy", {}) if policy: token = self.authed.upload_token(BucketName, filename, Expired, policy) else: token = self.authed.upload_token(BucketName, filename, Expired) ret, info = put_file(token, filename, filepath) return ret, info
class QiNiuProvider(object): def __init__(self, access_key, secret_key, bucket_name, imageServerUrl): self.access_key = access_key self.secret_key = secret_key self.bucket_name = bucket_name self.imageServerUrl = imageServerUrl self.credentials = Auth(self.access_key, self.secret_key) def token(self): return self.credentials.upload_token(self.bucket_name) def store(self, raw): key = hash(str(uuid.uuid1())) upload_token = self.credentials.upload_token(self.bucket_name, key) ret, err = put_data(upload_token, key, raw) if ret is not None: return "%s/%s" % (self.imageServerUrl, ret['key']) else: logging.error('upload error.') def store_file(self, file_path, file_name): upload_token = self.credentials.upload_token(self.bucket_name, file_name) ret, err = put_file(upload_token, file_name, file_path) if ret is not None: return "%s/%s" % (self.imageServerUrl, ret['key']) else: logging.error('upload: %s error.' % file_name)
def uploadsong(request): q = Auth('ToNLYIGLfHy5tpKSsRcBV2pw18b20LrYuBdvHaA_', 'rrD25c6RoHoMajmLR8lSz9wW4FcGEHvGMDL4l2zV') print q token = q.upload_token('outshineamazing', '') print token context = {'uptoken_url':token} return render(request,'comments/test.html',context)
def upload_file(localfile): # 需要填写你的 Access Key 和 Secret Key access_key = 'aRzVj18_VFA_p4EZ9z8ClWkVwYvAOWuoMStYnJhi' secret_key = 'bh_hBotfph77wcmHHIgCwExqKEvQN_eyT5m1r9_c' # 构建鉴权对象 q = Auth(access_key, secret_key) # 要上传的空间 bucket_name = 'myselfres' # 上传到七牛后保存的文件名 key = time.strftime("%Y-%m-%d-%H-%M-%S.png", time.localtime()) print key # 生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name, key, 3600) # 要上传文件的本地路径 ret, info = put_file(token, key, localfile) print (info) assert ret['key'] == key assert ret['hash'] == etag(localfile) pngOnlinePath = myselfres_dom + key + ')' setText(pngOnlinePath)
def upload(): # Get the name of the uploaded file file = request.files['file'] # Check if the file is one of the allowed types/extensions if file and allowed_file(file.filename): # Make the filename safe, remove unsupported chars filename = secure_filename(file.filename) # Move the file form the temporal folder to # the upload folder we setup file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) # Redirect the user to the uploaded_file route, which # will basicaly show on the browser the uploaded file path = os.path.join(app.config['UPLOAD_FOLDER'], filename) access_key = '' secret_key = '' bucket_name = '' q = Auth(access_key, secret_key) token = q.upload_token(bucket_name, None, 3600) ret, info = qiniu.put_file(token, filename, path) return redirect(url_for('uploaded_file', filename=filename))
def uploadToQiNiu(filePath,name): q = Auth(access_key, secret_key) localfile = filePath key = name mime_type = "image/jpeg" token = q.upload_token(bucket_name, key) ret, info = put_file(token, key, localfile, mime_type=mime_type, check_crc=True)
class Qiniu(object): def __init__(self, uri): assert uri.startswith('http://') self.qn = Auth(qnconf['access_key'], qnconf['secret_key']) self.token = self.qn.upload_token(qnconf['bucket_name']) self.bucket = BucketManager(self.qn) # def stat_image(self, key): # status, image_info = self.bucket.stat(qnconf['bucket_name'], key) # last_modified = int(status['putTime'] / 1000000) # return {'checksum': status['hash'], 'last_modified': last_modified} # def persist_image(self, key, image, buf, info): # buf.seek(0) # return threads.deferToThread(put_data, self.token, key, buf.getvalue()) def get_file_stat(self, key): stat, error = self.bucket.stat(qnconf['bucket_name'], key) return stat def stat_file(self, path, info): def _onsuccess(stat): if stat: checksum = stat['hash'] timestamp = stat['putTime'] / 10000000 return {'checksum': checksum, 'last_modified': timestamp} else: return {} return threads.deferToThread(self.get_file_stat, path).addCallback(_onsuccess) def persist_file(self, path, buf, info, meta=None, headers=None): buf.seek(0) return threads.deferToThread(put_data, self.token, path, buf.getvalue())
def test_upload(): q = Auth(access_key, secret_key) token = q.upload_token(bucket, mykey.encode('utf-8')) file = '/tmp/abc.txt' ret, info = put_file(token, mykey.encode('utf-8'), file, mime_type="text/plain", check_crc=True) print(info) print(ret)
def post(self): for i in request.forms.keys(): print i, request.forms[i], type(request.forms[i]) for i in request.files.keys(): print i, request.files[i], type(request.files[i]) print request.files[i].__dict__ image = request.files['image'] name = image.raw_filename data = image.file.read() key = md5('data').hexdigest() + '.' + name.split('.')[-1] auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY) token = auth.upload_token( QINIU_BUCKET_NAME, None, 7200, { 'returnBody': json.dumps({ 'key': '$(key)', 'hash': '$(etag)', 'format': '$(imageInfo.format)', 'width': '$(imageInfo.width)', 'height': '$(imageInfo.height)', }), 'save_key': '$(etag)', } ) ret, info = put_data(token, key, data)
def get_token(key): q = Auth(qiniu_access_key, qiniu_secret_key) # 上传策略仅指定空间名和上传后的文件名,其他参数仅为默认值 token = q.upload_token(qiniu_bucket_name, key) return token
def upload_token(): q = Auth(ACCESS_KEY, SECRET_KEY) # 上传策略仅指定空间名和上传后的文件名,其他参数仅为默认值 token = q.upload_token('wm-test', None, 7200, {'callbackUrl':"http://298074.cicp.net:59295/upload/callback/", 'callbackBody':"name=$(key)&fname=$(fname)&hash=$(etag)&size=$(imageInfo.width)x$(imageInfo.height)", \ 'saveKey':'aaa$(year)$(mon)$(day)$(hour)$(min)$(sec).jpg', 'mimeType':'image/jpg'}) return token
class Qiniu(object): def __init__(self, access_key = None, secret_key = None, bucket_name = None): self.access_key = access_key self.secret_key = secret_key self.bucket_name = bucket_name self.q = Auth(self.access_key, self.secret_key) def upload(self, key, localfile = None, expires = 3600, deleteAfterDays = 7): policy = {'deleteAfterDays': deleteAfterDays} print policy #token = self.q.upload_token(self.bucket_name, key, expires, policy, False) token = self.q.upload_token(self.bucket_name, key, expires, policy) ret, info = put_file(token, key, localfile) print(info) assert ret['key'] == key assert ret['hash'] == etag(localfile) def delete(self, key): bucket = BucketManager(self.q) ret, info = bucket.delete(self.bucket_name, key) print(info) assert ret == {} def stat(self, key): bucket = BucketManager(self.q) ret, info = bucket.stat(self.bucket_name, key) print(info) assert 'hash' in ret
def upload_file(file_name=None, data=None): if not file_name: file_name = hashlib.md5(data).hexdigest() q = Auth(settings.QINIU_KEY, settings.QINIU_TOKEN) token = q.upload_token(settings.QINIU_BUCKET) ret, info = put_data(token, file_name, data) return ret['key'] == file_name, file_name
def get(self, request): q = Auth(settings.QNACCESSKEY, settings.QNSECRETKEY) filename = str(uuid.uuid1()).replace("-", "") + ".jpg" print (filename) token = q.upload_token(settings.QNBUKET, filename) print (token) return Response({"key": filename, "token": token}, status=status.HTTP_202_ACCEPTED)
class QiniuLPic(LPic): def __init__(self, conf=None, **option): super(QiniuLPic, self).__init__(conf, **option) self.cloud_name = '七牛云' def auth(self): self.client = Auth(self.cloud['AccessKey'], self.cloud['SecretKey']) @property def web_url(self): return 'https://portal.qiniu.com/bucket/{}/resource'.format(self.cloud['Bucket']) def upload(self, file, prefix=''): _token = self.client.upload_token(self.cloud['Bucket'], os.path.basename(file), 600) _, ret = put_file(_token, prefix + os.path.basename(file), file) return ret.ok() def list(self, prefix): bucket = BucketManager(self.client) ret, _, _ = bucket.list(self.cloud['Bucket'], prefix=prefix, limit=self.MAX_KEYS) return [i['key'] for i in sorted([i for i in ret['items']], key=lambda x: -x['putTime'])] def delete(self, key): bucket = BucketManager(self.client) _, ret = bucket.delete(self.cloud['Bucket'], key) return ret.ok() def close(self): cache = '.qiniu_pythonsdk_hostscache.json' if os.path.isfile(cache): os.remove(cache)
def main(): q = Auth('FCFQs6B-thjgt30-HEmCS9ZUCGQBxx2Zsg_WO1k5', 'Z8LCTm4gxo_dfX7HT0EhFnXmsFTGwZ8MyCFXmSXF') # 上传策略仅指定空间名和上传后的文件名,其他参数仅为默认值 token = q.upload_token('qile') f = open('qiniu_auth_token.txt', 'w') f.write(str(token))
def tuchuang_index(): github_user = _get_user() if not github_user: flash(u'请正确完成牛逼参数设置后上传图片!', category='warning') return redirect(url_for('.info')) if request.method == 'POST': access_key = str(github_user.get('access_key')) secret_key = str(github_user.get('secret_key')) bucket_name = str(github_user.get('bucket_name')) domain_name = str(github_user.get('domain_name')) q = Auth(access_key, secret_key) token = q.upload_token(bucket_name) upload_files = request.files.getlist('file') for upload_file in upload_files: key = '%s_%s' % (datetime.now().isoformat(), upload_file.filename) ret, info = put_data(up_token=token, key=key, data=upload_file) url = '%s/%s' % (domain_name, key) f = File() f.set('url', url) f.set('user', github_user) f.save() flash(u'成功上传%s张照片!' % len(upload_files), category='success') return redirect(url_for('.tuchuang_index')) image_id = request.args.get('image_id') image = Query(File).get(image_id) if image_id else None return render_template('tuchuang.html', image=image)
def create(self): # TODO: 表单验证 image = request.files['image'] # TODO: 解包检查 origin_name, suffix = image.raw_filename.split('.') data = image.file.read() data_hash = md5(data).hexdigest() key = data_hash model = ImageModel.query.get(data_hash) if model: return model.as_dict() auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY) token = auth.upload_token( QINIU_BUCKET_NAME, None, 7200, { 'returnBody': json.dumps({ 'key': '$(key)', 'hash': '$(etag)', 'format': '$(imageInfo.format)', 'width': '$(imageInfo.width)', 'height': '$(imageInfo.height)', }), 'save_key': '$(etag)', } ) ret, info = put_data(token, key, data) model = ImageModel( hashkey=data_hash, suffix=ret['format'], width=ret['width'], height=ret['height']) db.session.add(model) db.session.commit() return model.as_dict()
def token(request): # wiicome服务器设置七牛上传token q = Auth(ACCESS_KEY, SECRET_KEY) # 上传策略仅指定空间名和上传后的文件名,其他参数仅为默认值 token = q.upload_token(BUCKET_KEY) data = {"uptoken": token} return JsonResponse(data)
def upload(filepath): qiniu_domain = 'http://7xtq0y.com1.z0.glb.clouddn.com/' #需要填写你的 Access Key 和 Secret Key access_key = 'NhxOewLDWpAs_THJNvtKN8kZHG3r0_tkWOaJSycc' secret_key = 'Cx7AJItEyNWaEG1eLvu85PpCGq0vAaX1xmvJC7c0' #构建鉴权对象 q = Auth(access_key, secret_key) #要上传的空间 bucket_name = 'images' #上传到七牛后保存的文件名 key = os.path.basename(filepath) qiniu_url = qiniu_domain + key #生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name, key, 3600) #要上传文件的本地路径 localfile = filepath ret, info = put_file(token, key, localfile) print(info) print('===============') print(qiniu_url) return qiniu_url
def get(self): access_key = 'YOUR_ACCESS_KEY' secret_key = 'YOUR_SECRET_KEY' q = Auth(access_key, secret_key) bucket_name = 'YOUR_BUCKET_NAME' # to set the uploaded file rename to YYYYMMDD_HHMMSS_filename # if the filename was "test.jpg", then the new filename will be "20160101_083054_test.jpg" # SEE MORE: http://developer.qiniu.com/article/kodo/kodo-developer/up/vars.html#magicvar policy = {"saveKey": "$(year)$(mon)$(day)_$(hour)$(min)$(sec)_$(fname)"} # in the source of qiniu/auth.py, the function upload_token takes 5 arguments: # bucket:your bucket_name # key: the filename you want to set, None means set as ths "saveKey" above # expires: expires time (second) # policy: the options to upload,see more: http://developer.qiniu.com/article/developer/security/put-policy.html # # def upload_token(self, bucket, key=None, expires=3600, policy=None, strict_policy=True): token = q.upload_token(bucket_name, None, 3600, policy) # return as json self.write(json.dumps({"uptoken":token}))
def generate_upload_token(prefix): ''' prefix: 'head' or 'content' return: (token, key) ''' # modify default upload zone qiniu.config.set_default(default_zone=qiniu.config.zone1) # access two keys access_key = current_app.config['QINIU_ACCESS_KEY'] secret_key = current_app.config['QINIU_SECRET_KEY'] # auth obj q = Auth(access_key, secret_key) # upload bucket name bucket_name = current_app.config['QINIU_BUCKET_NAME'] # achieve file ext name try: match = re.finditer(r'.([0-9a-zA-Z]+)$', localfile) ext = match[-1].group(1) except: ext = 'jpg' # cloud filename # key = generate_upload_filename(ext, prefix=prefix) # generate token token = q.upload_token(bucket_name, None, 3600) return token
def upload_qiniu_by_path(access_key, secret_key, bucket_name, key_prefix, pool_number, path, delete=False): q = Auth(access_key, secret_key) mime_type = "text/plain" params = {'x:a': 'a'} pool = Pool(pool_number) for dirpath, dirnames, filenames in os.walk(path): print(dirpath) if len(filenames) > 0: for filename in filenames: if filename.startswith('.'): continue localfile = os.path.join(dirpath, filename) key = os.path.join(key_prefix, localfile.replace(path, '')[1:]) token = q.upload_token(bucket_name, key) pool.spawn( down, token=token, key=key, localfile=localfile, mime_type=mime_type, delete=delete )
class Qiniu(BaseStorage): def __init__(self, bucket, access_key, secret_key, cdn_host, host=None, timeout=5): self.bucket = bucket self.access_key = access_key self.secret_key = secret_key self.host = host self.cdn_host = cdn_host self.timeout = timeout self.auth = Auth(self.access_key, self.secret_key) set_default(connection_timeout=self.timeout, connection_retries=0) @property def token(self): return self.auth.upload_token(self.bucket) def set(self, k, v, mimetype=None, **kwargs): ret, info = put_data(self.token, k, v, mime_type=mimetype) return bool(ret) def get(self, k): url = 'http://%s/%s' % (self.host, k) resp = requests.get(url, timeout=5) if resp.status_code == requests.codes.ok: return resp.content, resp.headers['content-type'] return (None, None) def cdn_url(self, ident): return 'http://{}/{}'.format(self.cdn_host, ident)
def upload_photo(): """上传照片到七牛,并返回私有链接地址""" from qiniu import Auth from qiniu import put_file global config progress_handler = lambda progress, total: progress photo_path = http_get("http://127.0.0.1:9876/photo/shot").content # Upload to qiniu mime_type = "image/jpeg" auth = Auth(str(config["qiniu"]["api_key"]), str(config["qiniu"]["secret"])) print auth filename = os.path.basename(photo_path) print "filename: ", filename, type(filename) token = auth.upload_token(str(config["qiniu"]["bucket"])) print token ret, info = put_file(token, filename, photo_path, {}, mime_type, progress_handler=progress_handler) print "uploaded: ", ret, info try: os.remove(photo_path) except Exception: pass # Return URL base_url = "{}/{}".format(str(config["qiniu"]["domain"]), filename) return auth.private_download_url(base_url, expires=3600)
def upload(origin_file_path): # 构建鉴权对象 q = Auth(config.access_key, config.secret_key) # 要上传的空间 bucket_name = 'md-doc' localfile = conwebp.convert(origin_file_path) # 上传到七牛后保存的文件名 dest_prefix = time.strftime("%Y%m%d%H%M%S", time.localtime()) dest_name = dest_prefix + "_" + os.path.basename(localfile) # 上传文件到七牛后, 七牛将文件名和文件大小回调给业务服务器。 policy = { 'callbackBody': 'filename=$(fname)&filesize=$(fsize)' } token = q.upload_token(bucket_name, dest_name, 3600, policy) ret, info = put_file(token, dest_name, localfile) if ret is not None: print("Upload Success,url=", config.domin + dest_name) else: print("info=", info) print("ret=", ret) assert ret['key'] == dest_name assert ret['hash'] == etag(localfile)
def upload_to_qiniu(AK, SK, BUCKET_NAME,FILE_OBJ,FILE_NAME,): ''' 上传文件到七牛云,并返回 文件hash BUCKET_NAME 七牛资源空间名 FILE_OBJ 文件二进制流 FILE_NAME 文件保存到七牛云上的文件名 ''' q = Auth(AK, SK) token = q.upload_token(BUCKET_NAME, FILE_NAME, 3600) # ret # 一个dict变量,类似 {"hash": "<Hash string>", "key": "<Key string>"} # info """七牛HTTP请求返回信息类 该类主要是用于获取和解析对七牛发起各种请求后的响应包的header和body。 Attributes: status_code: 整数变量,响应状态码 text_body: 字符串变量,响应的body req_id: 字符串变量,七牛HTTP扩展字段,参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html x_log: 字符串变量,七牛HTTP扩展字段,参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html error: 字符串变量,响应的错误内容 """ ret, info = put_data(token, FILE_NAME, FILE_OBJ) if info.status_code: if ret['hash'] == etag_stream(FILE_OBJ): return ret['hash'] return None return None
def storage(file_data): try: #构建鉴权对象 q = Auth(access_key, secret_key) #要上传的空间 bucket_name = 'ihome' #上传到七牛后保存的文件名 # key = 'my-python-logo.png'; #生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name) #要上传文件的本地路径 # localfile = './sync/bbb.jpg' # ret, info = put_file(token, key, localfile) ret, info = put_data(token, None, file_data) except Exception as e: logging.error(e) raise e print(ret) print("*"*16) print(info) # assert ret['key'] == key # assert ret['hash'] == etag(localfile) print(type(info)) print(info.status_code) if 200 == info.status_code: return ret["key"] else: raise Exception("上传失败")
def loop_qiniu(): while True: for f in os.listdir(UPLOAD_FOLDER): if 'tmp' not in f.split('_')[-1]: os.remove(os.path.join(UPLOAD_FOLDER, f)) # print 'jump out and for one more time' elif 'tmp0' == f.split('_')[-1]: continue elif 'tmp' == f.split('_')[-1]: print 'start handle %s' % f f_path = os.path.join(UPLOAD_FOLDER, f) f_path_new = os.path.join(UPLOAD_FOLDER, f[:-4]) key = f[:-4] q = Auth(access_key, secret_key) token = q.upload_token(Bucket, key, 3600) local_file = f_path ret, _ = put_file(token, key, local_file) try: assert ret['key'] == key except TypeError: print 'ret has error' continue os.rename(f_path, f_path_new) print 'end handle %s' % key print time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time())) else: print '<----' print u'为考虑到的情况' print time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time())) print '---->' print 'pass this time while error', time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))
def upload(local_file_path, upload_path): """ 上传操作 :param local_file_path: 本地图片地址 :param upload_path: 上传地址 :return: image_url: 返回外部链接 """ # 构建鉴权对象 q = Auth(ACCESS_KEY, SECRET_KEY) # 生成上传Token, 可以制定过期时间等 token = q.upload_token(BUCKET_NAME, upload_path, 3600) put_file(token, upload_path, local_file_path) image_url = BUCKET_URL + upload_path return image_url
def sendToken(request): if request.method == 'GET': access_key = 'uFy_2nTo_c-fCDvigBum8ZnwvFZPwRceTAbw7zVS' secret_key = '6rGh9INqH0vQWj4BXc0yEfPsz1dLyvUk0H8JtNPe' # 构建鉴权对象 q = Auth(access_key, secret_key) # 要上传的空间 bucket_name = 'studyapp' # 上传到七牛后保存的文件名 key = str(uuid.uuid4()) + '.' + str( request.GET.get('key')).split('.')[-1] # 生成上传 Token,可以指定过期时间等 一天 token = q.upload_token(bucket_name, key, 3600) return JsonResponse({"token": token, "filename": key})
class QiniuAttaDriver(BaseAttaDriver): TOKEN = None TOKEN_CREATE = None EXPIRE_TIME = 3600 def __init__(self, ak, sk, bucket_domain): self.ak = ak self.sk = sk self.auth = Auth(self.ak, self.sk) self.bucket_domain = bucket_domain def _get_auth_token(self, bucket_name): expired = False if self.TOKEN: if (datetime.now() - self.TOKEN_CREATE).total_seconds() >= 3600: expired = True else: expired = True if expired: self.TOKEN_CREATE = datetime.now() self.TOKEN = self.auth.upload_token( bucket_name, expires=self.EXPIRE_TIME ) return self.TOKEN def _get_atta_name(self, atta): note, atta = atta.split('/')[-2:] return '%s:%s' % (note, atta) def get_atta_by_path(self, atta, bucket_name): url = 'http://%s/%s' % ( self.bucket_domain, self._get_atta_name(atta)) private_url = self.auth.private_download_url(url, expires=3600) r = requests.get(private_url) return r.raw def get_atta_url_by_path(self, atta, bucket_name): url = 'http://%s/%s' % ( self.bucket_domain, self._get_atta_name(atta)) private_url = self.auth.private_download_url(url, expires=3600) return private_url def save_atta_by_path(self, atta, bucket_name): token = self._get_auth_token(bucket_name) ret, info = put_file(token, self._get_atta_name(atta), atta) print(ret, info) return (ret, info)
def upload_to_qiniu(filename, filepath): """上传到七牛云""" # 构建鉴权对象 qn_auth = Auth(config.QN_AK, config.QN_SK) # 生成上传 Token,可以指定过期时间等 token = qn_auth.upload_token(config.QN_BUCKET_NAME, filename, 3600) # 要上传文件的本地路径 put_file(token, filename, filepath) url = '%s/%s' % (config.QN_BASE_URL, filename) return url
class BackupTool(object): __LOCAL_FILE_DIRECTORY = configs.DATABASE_BACKUP_FILE_DIRECTORY __KEY = 'celerysoft-science-%s.sql' __DATETIME_FORMAT = '%Y%m%d' __qiniu_instance = None def __init__(self): self.__qiniu_instance = Auth(configs.QINIU_ACCESS_KEY, configs.QINIU_SECRET_KEY) self.__qiniu_bucket_name = configs.QINIU_BUCKET_NAME_FOR_BACKUP_DATABASE def execute(self): self.__upload() self.__delete_backup_30days_ago() def __upload(self): # 上传后保存的文件名 # celerysoft-science-20190227.sql key = self.__KEY % datetime.now().strftime(self.__DATETIME_FORMAT) # 生成上传 Token,可以指定过期时间等 token = self.__qiniu_instance.upload_token(self.__qiniu_bucket_name, key, 3600) # 要上传文件的本地路径 local_file = os.path.join(self.__LOCAL_FILE_DIRECTORY, key) ret, info = put_file(token, key, local_file) try: assert ret['key'] == key assert ret['hash'] == etag(local_file) print('数据库备份上传到七牛成功') except AssertionError: print('数据库备份上传到七牛失败,请手动进行处理!!!') def __delete_backup_30days_ago(self): _30days_ago = datetime.now() - timedelta(days=20) key = self.__KEY % _30days_ago.strftime(self.__DATETIME_FORMAT) bucket = BucketManager(self.__qiniu_instance) ret, info = bucket.stat(configs.QINIU_BUCKET_NAME_FOR_BACKUP_DATABASE, key) if ret is None or 'hash' not in ret: print('30天前的备份不存在,不需要删除') else: ret, info = bucket.delete(self.__qiniu_bucket_name, key) try: assert ret == {} except AssertionError: print('删除30天前的备份文件失败,请手动删除')
def save_data(self, stream, filename=None): # 构建鉴权对象 auth = Auth(self._access_key, self._secret_key) # 上传到七牛后保存的文件名 key = filename # 生成上传 Token,可以指定过期时间等 token = auth.upload_token(self._bucket_name) ret, info = put_data(token, key, stream) print(info) try: assert ret['key'] == key except Exception as e: current_app.logger.info(e) return False return True
def uploadimg(img_name): from qiniu import Auth, put_file, etag import qiniu.config access_key = 'hf_OTa2nV0Taho84tpokRzn6Gm58mrjwu5QOPHGw' secret_key = '-uwYx2tXAsUpSssc5YRH026F8qlzt_h5qCpC3OFK' q = Auth(access_key, secret_key) bucket_name = 'idup' key = 'math-problem-proj/' + img_name.split('/')[-1] # 2592000s refers to 30d token = q.upload_token(bucket_name, key, 2592000) localfile = img_name ret, info = put_file(token, key, localfile) print(info) assert ret['key'] == key assert ret['hash'] == etag(localfile)
def upload(local_file, remote_name, ttl=3600): print(local_file, remote_name, ttl) #构建鉴权对象 q = Auth(ACCESS_KEY, SECRET_KEY) #生成上传 Token,可以指定过期时间等 token = q.upload_token(BUCKET_NAME, remote_name, ttl) ret, info = put_file(token, remote_name, local_file, progress_handler=progress_handler) print(info) assert ret['key'] == remote_name assert ret['hash'] == etag(local_file)
def qiniuToken(request): data = request.data filename = data.get('filename', None) result = {} access_key = '8Z2OZ-sHyK5W22Nm-nUlsLgonJnOE9iKWue4i3CX' secret_key = 'LnWzZ7HFosZAOH6VMbCjEgyRHFP4tgZctftC5eXM' # 构建鉴权对象 q = Auth(access_key, secret_key) # 要上传的空间 bucket_name = 'piggancat' token = q.upload_token(bucket_name, filename, 3600) result['token'] = token result['file'] = filename return Response(data=result, status=status.HTTP_200_OK)
def upload_cdn(filepath): access_key = config['access_key'] secret_key = config['secret_key'] bucket_name = config['bucket_name'] if not access_key or not secret_key or not bucket_name: print('cdn配置不全,请执行 upm config set access_key [mykey]') exit(0) return q = Auth(access_key, secret_key) filename = path.basename(filepath) token = q.upload_token(bucket_name, filename, 3600) ret, info = put_file(token, filename, filepath) assert ret['key'] == filename assert ret['hash'] == etag(filepath)
def upload(local_file, key, flag=True): # 构建鉴权对象 q = Auth(access_key, secret_key) # 生成上传 Token,可以指定过期时间等,上传空间、文件名 token = q.upload_token(bucket_name, key, 3600) ret, info = put_file(token, key, local_file) # print(info) # print(ret) assert ret['key'] == key assert ret['hash'] == etag(local_file) print('![' + key + '](' + link_prefix + ret['key'] + ')') if flag: add_to_clipboard('![' + key + '](' + link_prefix + ret['key'] + ')')
def upload_storage(file_name, data, bucket_name=None): bucket = get_bucket(bucket_name) ak = app.config['qiniu.storage.access_key'] sk = app.config['qiniu.storage.secert_key'] domain = app.config['qiniu.storage.domain_name'] q = Auth(ak, sk) token = q.upload_token(bucket, file_name) ret, info = put_data(token, file_name, data) logging.info("ret:%s,info:%s", ret, info) return '%s/%s' % (domain, file_name)
class Qiniu: def __init__(self, access_key, secret_key, bucket_name: str): self._access_key = access_key self._secret_key = secret_key self._auth = Auth(access_key, secret_key) self._bucket = bucket_name @retry(tries=5, delay=0.5, jitter=0.1, logger=logging) def upload_file(self, key, localfile): token = self._auth.upload_token(self._bucket, key) ret, info = put_file(token, key, localfile) if ret: # ret possibly is None assert ret['key'] == key assert ret['hash'] == etag(localfile) return info
def upload_pic(pic): # 需要填写你的 Access Key 和 Secret Key access_key = 'yV4GmNBLOgQK-1Sn3o4jktGLFdFSrlywR2C-hvsW' secret_key = 'bixMURPL6tHjrb8QKVg2tm7n9k8C7vaOeQ4MEoeW' # 构建鉴权对象 q = Auth(access_key, secret_key) # 要上传的空间 bucket_name = 'ihome' token = q.upload_token(bucket_name) ret, info = put_data(token, None, pic) if info and info.status_code != 200: raise Exception("上传文件到七牛失败") return ret.get('key')
def upload_qiniu(uid): # 构建鉴权对象 q = Auth(access_key, secret_key) # 上传后保存的文件名 filename = keys.AVATAR_KEY % uid # 生成上传 Token, 可以指定过期时间 token = q.upload_token(bucket_name, filename, 3600) # 要上传文件的本地路径 filepath = os.path.join(settings.BASE_DIR, settings.MEDIAS_ROOT, filename) ret, info = put_file(token, filename, filepath) if info.status_code == 200: return True return False
def get(self, request, *args, **kwargs): #需要填写你的 Access Key 和 Secret Key access_key = settings.QINIU_ACCESS_KEY secret_key = settings.QINIU_SECRET_KEY #构建鉴权对象 q = Auth(access_key, secret_key) #要上传的空间 bucket_name = 'bs_angel' key = None # 生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name, key, 3600) res = {'code': 200, 'msg': 'success', 'data': {'token': token}} return Response(res)
def upload_pic(f1): # f1表示接收的浏览器传递的文件对象 为啥要用get access_key = current_app.config.get('QINIU_AK') secret_key = current_app.config.get('QINIU_SK') # 空间名称 bucket_name = current_app.config.get('QINIU_BUCKET') # 构建鉴权对象 ---> 其实就是身份认证 q = Auth(access_key, secret_key) # 生成上传 Token token = q.upload_token(bucket_name) # 上传文件数据,ret是字典,键为hash、key,值为新文件名,info是response对象 ret, info = put_data(token, None, f1.read()) # 返回七牛云给出的文件名 return ret.get('key')
def storage_by_file(): """通过文件上传""" # #构建鉴权对象 q = Auth(ACCESS_KEY, SECRET_KEY) #上传到七牛后保存的文件名 key = 'my-flask-logo.png' #生成上传 Token,可以指定过期时间等 token = q.upload_token(BUCKET_NAME, key, 3600) #要上传文件的本地路径 localfile = TEST_IAMGE_FILE ret, info = put_file(token, key, localfile) print(ret) print(info.status_code) return ret['key']
def storage(file_data): # 构建鉴权对象 q = Auth(access_key, secret_key) # 要上传的空间 bucket_name = 'home-image-flask' # 上传后保存的文件名 # key = 'my-python-logo.png' # 生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name, None, 3600) ret, info = put_data(token, None, file_data) if info.status_code == 200: return ret.get('key') else: raise Exception('上传图片失败')
class Qiniu: def __init__(self, bucket_name, base_url): self.bucket_name = bucket_name self.base_url = base_url self.q = Auth(settings.QINIU_AK, settings.QINIU_SK) def put(self, name, path): token = self.q.upload_token(self.bucket_name, name) ret, info = put_file(token, name, path) print('ret:', ret) print('info:', info) if 'key' in ret: remote_url = '/'.join([self.base_url, ret['key']]) return remote_url
def upload(file, qiniu): access_key = qiniu.access_key secret_key = qiniu.secret_key q = Auth(access_key, secret_key) # bucket_name = 'testbast' bucket_name = qiniu.bucket_name key = file.split('\\')[-1] # 生成token token = q.upload_token(bucket_name, key, 3600) ret, info = put_file(token, key, file) print("文件上传成功") return key
def updateFile(filePath, uri): q = Auth(access_key, secret_key) bucket_name = defaultBucketName bucket = BucketManager(q) key = getKeyFromUri(uri) # delete ret, info = bucket.delete(bucket_name, key) # upload token = q.upload_token(bucket_name, key) ret, info = put_file(token, key, filePath) if 'key' not in ret: return None retFileUri = ('%s/%s') % (defaultBucketUriBase, key) logging.debug('upload qiniu file uri:[%r]' % (retFileUri)) return retFileUri
def upload(cls, file): q = Auth(current_app.config['QINIU_ACCESS_KEY'], current_app.config['QINIU_SECRET_KEY']) token = q.upload_token(current_app.config['QINIU_BUCKET']) # 如果需要对上传的图片命名,就把第二个参数改为需要的名字 # 如果需要对上传的图片命名,就把第二个参数改为需要的名字 ret1, ret2 = put_data(token, None, data=file) print('ret1:', ret1) print('ret2:', ret2) # 判断是否上传成功 if ret2.status_code != 200: raise Exception('文件上传失败') return ret1.get('key')
def upload_file_online(self, mime_type, data, suffix): ''' 上传文件到七牛 :param file_path:本地服务器的文件路径 :return: 上传后的uri ''' access_key = config.QINIU_ACCESS_KEY secret_key = config.QINIU_SECRET_KEY q = Auth(access_key, secret_key) bucket_name = config.QINIU_BUCKET_NAME # 空间名 key = self.get_file_name_online(data, suffix) mime_type = mime_type token = q.upload_token(bucket_name, key) put_data(token, key, data, mime_type=mime_type, check_crc=True) return key
def upload_img(screenshotpath, img_name): q = Auth(access_key, secret_key) bucket_name = ConfigInit.qiniu_house # 上传后保存的文件名 key = img_name # 生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name, key, 3600) # 要上传文件的本地路径 localfile = screenshotpath try: put_file(token, key, localfile) logger.info('上传图片成功') return ConfigInit.qiniu_domain + img_name except Exception as e: logger.info('上传图片失败', e)
def storage_image(data): """用于将图片上传到七牛用""" if not data: return None q = Auth(access_key, secret_key) # 指定的储存名字 token = q.upload_token(bucket_name) ret, info = put_data(token, None, data) if info.status_code != 200: raise Exception('七牛上传文件失败') return ret.get('key')
def get_upload_token(self, key, bucket='aizou'): """ 获得七牛的上传凭证 :param key: :param bucket: """ from qiniu import Auth if not self.ak or not self.sk: # 获得上传权限 section = conf.global_conf.get('qiniu', {}) self.ak = section['ak'] self.sk = section['sk'] q = Auth(self.ak, self.sk) return q.upload_token(bucket, key)
def storage(file_data): q= Auth(access_key, secret_key) # 要上传的空间 bucket_name ="" token = q.upload_token(bucket_name, key, 360) localfile = './sync/bbb.jpg' ret, info = put_data(token, None, localfile) if info.status_code == 200: # 表示上传成功,返回文件名 return ret.get("key") else: # 上传失败 raise Exception("上传七牛失败")
def storage_image(data): # 将图片上传到七牛云 if not data: return None q = Auth(access_key,secret_key) #指定的存储名字 token = q.upload_token(bucket_name) ret, info = put_data(token, None, data) # print ret,info if info.status_code != 200: raise Exception("七牛上传文件失败") return ret.get("key")
def storage(file_data): #构建鉴权对象 q = Auth(access_key, secret_key) #要上传的空间 bucket_name = 'yashe' #生成上传 Token,可以指定过期时间等 token = q.upload_token(bucket_name, None, 3600) #要上传文件的本地路径 ret, info = put_data(token, None, file_data) if info.status_code == 200: return ret.get('key') else: raise Exception('上传七牛失败')