def test_ingress(pc):
client = pc.client
ns = client.create_namespace(name=random_str())
wl = client.create_workload(namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
}])
name = random_str()
client.create_ingress(name=name,
namespaceId=ns.id,
rules=[
{
'paths': {
'/': {
'targetPort': 80,
'workloadIds': [wl.id],
}
}
},
])
# assert ingress.rules[0]['paths']['/'] == {
# 'targetPort': 80,
# 'workloadIds': [wl.id]
# }
client.delete(ns)
def test_ingress_rules_same_hostPortPath(admin_pc, admin_cc_client):
client = admin_pc.client
ns = admin_cc_client.create_namespace(name=random_str(),
projectId=admin_pc.project.id)
name = random_str()
workload1 = client.create_workload(name=name,
namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
}])
name = random_str()
workload2 = client.create_workload(name=name,
namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
}])
name = random_str()
ingress = client.create_ingress(name=name,
namespaceId=ns.id,
rules=[
{
'host': "foo.com",
'paths': {
'/': {
'targetPort': 80,
'workloadIds':
[workload1.id],
}
}
},
{
'host': "foo.com",
'paths': {
'/': {
'targetPort': 80,
'workloadIds':
[workload2.id],
}
}
},
])
assert len(ingress.rules) == 1
assert ingress.rules[0]['host'] == "foo.com"
path = ingress.rules[0]['paths']['/']
assert path['targetPort'] == 80
assert len(path['workloadIds']) == 2
assert set(path['workloadIds']) == set([workload1.id, workload2.id])
assert path['serviceId'] is None
client.delete(ns)
def test_namespaced_docker_credential(pc):
client = pc.client
ns = pc.cluster.client.create_namespace(name=random_str(),
projectId=pc.project.id)
name = random_str()
registries = {'index.docker.io': {
'username': '******',
'password': '******',
}}
cert = client.create_namespaced_docker_credential(name=name,
namespaceId=ns.id,
registries=registries)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedDockerCredential'
assert cert.name == name
assert cert.registries['index.docker.io']['username'] == 'foo'
assert 'password' in cert.registries['index.docker.io']
assert cert.namespaceId == ns.id
assert cert.projectId == pc.project.id
registries['two'] = {
'username': '******'
}
cert = client.update(cert, registries=registries)
cert = client.reload(cert)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedDockerCredential'
assert cert.name == name
assert cert.registries['index.docker.io']['username'] == 'foo'
assert cert.registries['two']['username'] == 'blah'
assert 'password' not in cert.registries['index.docker.io']
assert cert.namespaceId == ns.id
assert 'namespace' not in cert
assert cert.projectId == pc.project.id
found = False
for i in client.list_namespaced_docker_credential():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_namespaced_docker_credential(cert.id)
assert cert is not None
client.delete(cert)
def test_workload_ports_change(admin_pc):
client = admin_pc.client
ns = admin_pc.cluster.client.create_namespace(name=random_str(),
projectId=admin_pc.
project.id)
# create workload with no ports assigned
# and verify headless service is created
name = random_str()
workload = client.create_workload(
name=name,
namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
}])
svc = wait_for_service_create(client, name)
assert svc.clusterIp is None
assert svc.name == workload.name
assert svc.kind == "ClusterIP"
# update workload wiht port, and validate cluster ip is set
ports = [{
'sourcePort': '0',
'containerPort': '80',
'kind': 'ClusterIP',
'protocol': 'TCP', }]
client.update(workload,
namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
'ports': ports,
}]),
svc = wait_for_service_cluserip_set(client, name)
assert svc.clusterIp is not None
# update workload wiht no ports, and validate cluster ip is reset
client.update(workload,
namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
'ports': [],
}]),
svc = wait_for_service_cluserip_reset(client, name)
assert svc.clusterIp is None
def init():
app.secret_key = C.random_str(size=30)
app.context_processor(C.inject_user)
app.before_request(C.db_connect)
app.after_request(C.db_close)
# Add custom filters
app.add_template_filter(C.jinja2_filter_datefmt, "datefmt")
# Initialize uploads folder
uploads = os.path.join(app.root_path, "uploads")
app.config['UPLOAD_FOLDER'] = uploads
Path(uploads).mkdir(parents=True, exist_ok=True)
# Register views
# V.vbp.add_url_rule('/login', view_func=V.login, methods=['POST'])
# V.vbp.add_url_rule('/logout', view_func=V.logout, methods=['GET','POST'])
# V.vbp.add_url_rule('/current_user', view_func=V.current_user, methods=['GET'])
# V.vbp.add_url_rule('/users_upload', view_func=V.users_upload, methods=['POST'])
# V.vbp.add_url_rule('/kface_bulk_add', view_func=V.kface_bulk_add, methods=['POST'])
# V.vbp.add_url_rule('/kface', view_func=V.kface_find, methods=['POST'])
# V.vbp.add_url_rule('/kface/<int:id>', view_func=V.kface_view, methods=['GET'])
# V.vbp.add_url_rule('/kface_save', view_func=V.kface_save, methods=['POST'])
# V.vbp.add_url_rule('/kface_delete', view_func=V.kface_delete, methods=['POST'])
# V.vbp.add_url_rule('/mark_attendance', view_func=V.mark_attendance, methods=['POST'])
# V.vbp.add_url_rule('/all_attendance', view_func=V.all_attendance, methods=['GET'])
app.register_blueprint(V.vbp, url_prefix='/fras/app')
def register():
register_form = RegisterForm()
data = {
'title': 'Register',
'form': register_form,
}
if register_form.validate_on_submit():
# get data from form
username = register_form.username.data
password = register_form.password.data
confirm_password = register_form.confirmPassword.data
email = register_form.email.data
# check data
if len(username) < 2:
flash(u'用户名长度不能小于2！', 'danger')
return redirect(url_for('register'))
if password != confirm_password:
flash(u'两次密码不匹配！', 'danger')
return redirect(url_for('register'))
if len(password) < 6:
flash(u'密码长度不能小于6！', 'danger')
return redirect(url_for('register'))
if not re.match(r'\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*', email):
flash(u'Email地址不规范！', 'danger')
return redirect(url_for('register'))
# Check Username is already register
user = Users.query.filter_by(username=username).first()
if user is not None or user:
flash(u'用户名已存在！', 'danger')
return redirect(url_for('register'))
# Insert into database
user = Users(id="", username=username, email=email, password=password)
db.session.add(user)
db.session.commit()
user = Users.query.filter_by(username=username).first_or_404()
tid = user.id
users_info = UsersInfo(id="", user_id=tid,
register_time="", last_login_time="", last_login_ip=request.remote_addr,
token=random_str(32), is_active=0, qiniu_have_account=0, qiniu_access_key=None,
qiniu_secret_key=None, qiniu_bucket_name=None, qiniu_domain=None)
db.session.add(users_info)
db.session.commit()
session['user_id'] = tid
# Send mail
s = Serializer(app.config['SECRET_KEY'], 3600)
token = s.dumps({'user_id': tid})
send_mail(email, ' Please confirm your account',
'mail/confirm', username=username, token=token)
# return result
flash(u'注册成功！请到邮箱查看验证邮件，验证通过后方可登录。', 'success')
return redirect(url_for('register'))
return render_template("register.html", data=data)
def test_ingress(pc):
client = pc.client
ns = pc.cluster.client.create_namespace(name=random_str(),
projectId=pc.project.id)
# wl = client.create_workload(namespaceId=ns.id,
# scale=1,
# containers=[{
# 'name': 'one',
# 'image': 'nginx',
# }])
# name = random_str()
# client.create_ingress(name=name,
# namespaceId=ns.id,
# rules=[
# {
# 'paths': {
# '/': {
# 'targetPort': 80,
# 'workloadIds': [wl.id],
# }
# }
# },
# ])
# assert ingress.rules[0]['paths']['/'] == {
# 'targetPort': 80,
# 'workloadIds': [wl.id]
# }
client.delete(ns)
def test_secrets(pc):
client = pc.client
name = random_str()
secret = client.create_secret(name=name, stringData={'foo': 'bar'})
assert secret.type == 'secret'
assert secret.kind == 'Opaque'
assert secret.name == name
assert secret.data['foo'] == 'YmFy'
secret.data['baz'] = 'YmFy'
secret = client.update(secret, data=secret.data)
secret = client.reload(secret)
assert secret.baseType == 'secret'
assert secret.type == 'secret'
assert secret.kind == 'Opaque'
assert secret.name == name
assert secret.data['foo'] == 'YmFy'
assert secret.data['baz'] == 'YmFy'
assert secret.namespaceId is None
assert 'namespace' not in secret
assert secret.projectId == pc.project.id
found = False
for i in client.list_secret():
if i.id == secret.id:
found = True
break
assert found
client.delete(secret)
def timed_crud_rancher_cluster(self):
try:
start = time.time()
rancher_client = self.rancher_api_client()
proj = rancher_client.create_project(
name="p-" + random_str(),
clusterId="local")
create_time = time.time() - start
start = time.time()
rancher_client.by_id_project(
id=proj.id)
get_time = time.time() - start
start = time.time()
rancher_client.update_by_id_project(
id=proj.id,
description="asd")
update_time = time.time() - start
proj = rancher_client.reload(proj)
start = time.time()
rancher_client.delete(proj)
delete_time = time.time() - start
except ApiError:
return {}
times = {
"rancher_create_time": create_time,
"rancher_get_time": get_time,
"rancher_update_time": update_time,
"rancher_delete_time": delete_time
}
return times
def test_ssh_auth(pc):
client = pc.client
name = random_str()
cert = client.create_ssh_auth(name=name, privateKey='foo')
assert cert.baseType == 'secret'
assert cert.type == 'sshAuth'
assert cert.name == name
assert 'privateKey' in cert
assert cert.namespaceId is None
assert 'namespace' not in cert
assert cert.projectId == pc.project.id
cert = client.update(cert, privateKey='foo2')
cert = client.reload(cert)
assert cert.baseType == 'secret'
assert cert.type == 'sshAuth'
assert cert.name == name
assert 'privateKey' not in cert
assert cert.namespaceId is None
assert 'namespace' not in cert
assert cert.projectId == pc.project.id
found = False
for i in client.list_ssh_auth():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_ssh_auth(cert.id)
assert cert is not None
client.delete(cert)
def test_dns_ips(admin_pc, admin_cc_client):
client = admin_pc.client
ns = admin_cc_client.create_namespace(name=random_str(),
projectId=admin_pc.project.id)
name = random_str()
dns_record = client.create_dns_record(name=name,
ipAddresses=['1.1.1.1',
'2.2.2.2'],
namespaceId=ns.id)
assert dns_record.baseType == 'dnsRecord'
assert dns_record.type == 'dnsRecord'
assert dns_record.name == name
assert 'hostname' not in dns_record
assert dns_record.ipAddresses == ['1.1.1.1', '2.2.2.2']
assert dns_record.clusterIp is None
assert dns_record.namespaceId == ns.id
assert 'namespace' not in dns_record
assert dns_record.projectId == admin_pc.project.id
dns_record = client.update(dns_record, ipAddresses=['1.1.1.2', '2.2.2.1'])
dns_record = client.reload(dns_record)
assert dns_record.baseType == 'dnsRecord'
assert dns_record.type == 'dnsRecord'
assert dns_record.name == name
assert 'hostname' not in dns_record
assert dns_record.ipAddresses == ['1.1.1.2', '2.2.2.1']
assert dns_record.clusterIp is None
assert dns_record.namespaceId == ns.id
assert 'namespace' not in dns_record
assert dns_record.projectId == admin_pc.project.id
found = False
for i in client.list_dns_record():
if i.id == dns_record.id:
found = True
break
assert found
dns_record = client.by_id_dns_record(dns_record.id)
assert dns_record is not None
client.delete(dns_record)
def pc(request, cc):
p = cc.client.create_project(name='test-' + random_str(),
clusterId=cc.cluster.id)
p = cc.client.wait_success(p)
assert p.state == 'active'
request.addfinalizer(lambda: cc.client.delete(p))
url = p.links['self'] + '/schemas'
return ProjectContext(
cc, p, cattle.Client(url=url, verify=False, token=cc.client._token))
def user_mc(admin_mc):
"""Returns a ManagementContext for a newly created standard user"""
admin = admin_mc.client
username = random_str()
password = random_str()
user = admin.create_user(username=username, password=password)
admin.create_global_role_binding(userId=user.id, globalRoleId='user')
r = requests.post(AUTH_URL,
json={
'username': username,
'password': password,
'responseType': 'json',
},
verify=False)
client = rancher.Client(url=BASE_URL,
token=r.json()['token'],
verify=False)
return ManagementContext(client)
def test_namespaced_certificates(admin_pc, admin_cc_client):
client = admin_pc.client
ns = admin_cc_client.create_namespace(name=random_str(),
projectId=admin_pc.project.id)
name = random_str()
cert = client.create_namespaced_certificate(name=name,
key=KEY,
namespaceId=ns.id,
certs=CERT)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedCertificate'
assert cert.name == name
assert cert.certs == CERT
assert cert.namespaceId == ns.id
assert cert.projectId == admin_pc.project.id
assert 'namespace' not in cert
cert = client.update(cert, certs=UPDATED_CERT)
assert cert.namespaceId == ns.id
assert cert.projectId == admin_pc.project.id
cert = client.reload(cert)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedCertificate'
assert cert.name == name
assert cert.certs == UPDATED_CERT
assert cert.namespaceId == ns.id
assert cert.projectId == admin_pc.project.id
found = False
for i in client.list_namespaced_certificate():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_namespaced_certificate(cert.id)
assert cert is not None
client.delete(cert)
def test_namespaced_certificates(pc):
client = pc.client
ns = pc.cluster.client.create_namespace(name=random_str(),
projectId=pc.project.id)
name = random_str()
cert = client.create_namespaced_certificate(name=name,
key='keydata',
namespaceId=ns.id,
certs='certdata')
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedCertificate'
assert cert.name == name
assert cert.certs == 'certdata'
assert cert.namespaceId == ns.id
assert cert.projectId == pc.project.id
assert 'namespace' not in cert
cert = client.update(cert, certs='certdata2')
assert cert.namespaceId == ns.id
assert cert.projectId == pc.project.id
cert = client.reload(cert)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedCertificate'
assert cert.name == name
assert cert.certs == 'certdata2'
assert cert.namespaceId == ns.id
assert cert.projectId == pc.project.id
found = False
for i in client.list_namespaced_certificate():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_namespaced_certificate(cert.id)
assert cert is not None
client.delete(cert)
def test_namespaced_basic_auth(pc):
client = pc.client
ns = pc.cluster.client.create_namespace(name=random_str(),
projectId=pc.project.id)
name = random_str()
cert = client.create_namespaced_basic_auth(name=name,
namespaceId=ns.id,
username='******',
password='******')
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedBasicAuth'
assert cert.name == name
assert cert.username == 'foo'
assert 'password' in cert
assert cert.namespaceId == ns.id
assert 'namespace' not in cert
assert cert.projectId == pc.project.id
cert = client.update(cert, username='******')
cert = client.reload(cert)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedBasicAuth'
assert cert.name == name
assert cert.username == 'foo2'
assert 'password' not in cert
assert cert.namespaceId == ns.id
assert 'namespace' not in cert
assert cert.projectId == pc.project.id
found = False
for i in client.list_namespaced_basic_auth():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_namespaced_basic_auth(cert.id)
assert cert is not None
client.delete(cert)
def test_dns_hostname(pc):
client = pc.client
ns = pc.cluster.client.create_namespace(name=random_str(),
projectId=pc.project.id)
name = random_str()
dns_record = client.create_dns_record(name=name,
hostname='target',
namespaceId=ns.id)
assert dns_record.baseType == 'dnsRecord'
assert dns_record.type == 'dnsRecord'
assert dns_record.name == name
assert dns_record.hostname == 'target'
assert "clusterIp" not in dns_record
assert dns_record.namespaceId == ns.id
assert 'namespace' not in dns_record
assert dns_record.projectId == pc.project.id
dns_record = client.update(dns_record, hostname='target2')
dns_record = client.reload(dns_record)
assert dns_record.baseType == 'dnsRecord'
assert dns_record.type == 'dnsRecord'
assert dns_record.name == name
assert dns_record.hostname == 'target2'
assert "clusterIp" not in dns_record
assert dns_record.namespaceId == ns.id
assert 'namespace' not in dns_record
assert dns_record.projectId == pc.project.id
found = False
for i in client.list_dns_record():
if i.id == dns_record.id:
found = True
break
assert found
dns_record = client.by_id_dns_record(dns_record.id)
assert dns_record is not None
client.delete(dns_record)
def pc(request, cc):
p = cc.management.client.create_project(name='test-' + random_str(),
clusterId=cc.cluster.id)
p = cc.management.client.wait_success(p)
wait_for_condition("BackingNamespaceCreated", "True", cc.management.client,
p)
assert p.state == 'active'
request.addfinalizer(lambda: cc.management.client.delete(p))
url = p.links['self'] + '/schemas'
return ProjectContext(
cc, p, rancher.Client(url=url, verify=False, token=cc.client._token))
def test_namespaced_secrets(admin_pc, admin_cc_client):
client = admin_pc.client
ns = admin_cc_client.create_namespace(name=random_str(),
projectId=admin_pc.project.id)
name = random_str()
secret = client.create_namespaced_secret(name=name,
namespaceId=ns.id,
stringData={'foo': 'bar'})
assert secret.baseType == 'namespacedSecret'
assert secret.type == 'namespacedSecret'
assert secret.kind == 'Opaque'
assert secret.name == name
assert secret.data['foo'] == 'YmFy'
secret.data['baz'] = 'YmFy'
secret = client.update(secret, data=secret.data)
assert secret is not None
secret = client.reload(secret)
assert secret.baseType == 'namespacedSecret'
assert secret.type == 'namespacedSecret'
assert secret.kind == 'Opaque'
assert secret.name == name
assert secret.data['foo'] == 'YmFy'
assert secret.data['baz'] == 'YmFy'
assert secret.namespaceId == ns.id
assert 'namespace' not in secret
assert secret.projectId == admin_pc.project.id
found = False
for i in client.list_namespaced_secret():
if i.id == secret.id:
found = True
break
assert found
client.delete(secret)
def test_namespaced_ssh_auth(admin_pc, admin_cc_client):
client = admin_pc.client
ns = admin_cc_client.create_namespace(name=random_str(),
projectId=admin_pc.project.id)
name = random_str()
cert = client.create_namespaced_ssh_auth(name=name,
namespaceId=ns.id,
privateKey='foo')
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedSshAuth'
assert cert.name == name
assert 'privateKey' in cert
assert cert.namespaceId == ns.id
assert 'namespace' not in cert
assert cert.projectId == admin_pc.project.id
cert = client.update(cert, privateKey='foo2')
cert = client.reload(cert)
assert cert.baseType == 'namespacedSecret'
assert cert.type == 'namespacedSshAuth'
assert cert.name == name
assert 'privateKey' not in cert
assert cert.namespaceId == ns.id
assert 'namespace' not in cert
assert cert.projectId == admin_pc.project.id
found = False
for i in client.list_namespaced_ssh_auth():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_namespaced_ssh_auth(cert.id)
assert cert is not None
client.delete(cert)
def test_ingress(pc):
client = pc.client
ns = pc.cluster.client.create_namespace(name=random_str(),
projectId=pc.project.id)
name = random_str()
workload = client.create_workload(
name=name,
namespaceId=ns.id,
scale=1,
containers=[{
'name': 'one',
'image': 'nginx',
}])
name = random_str()
ingress = client.create_ingress(name=name,
namespaceId=ns.id,
rules=[{
'host': "foo.com",
'paths': {
'/': {
'targetPort': 80,
'workloadIds':
[workload.id],
}
}},
])
assert len(ingress.rules) == 1
assert ingress.rules[0]['host'] == "foo.com"
path = ingress.rules[0]['paths']['/']
assert path['targetPort'] == 80
assert path['workloadIds'] == [workload.id]
assert path['serviceId'] is None
client.delete(ns)
def test():
orimap = []
for pid in range(0, 10):
oriqueue = communicator.OriQueue()
sender = Process(target=testtask, name='send', args=([oriqueue]))
sender.start()
orimap.append(oriqueue)
while True:
msg = common.random_str(30)
index = random.randint(0, 9)
content = {"msg": msg + '\n', "wpath": "file" + str(index) + ".txt"}
orimap[index].put(content)
print "oriqueue %d put over !" % index
time.sleep(3)
def admin_pc(request, admin_cc):
"""Returns a ProjectContect for a newly created project in the local
cluster for the default global admin user. The project will be deleted
when this fixture is cleaned up."""
admin = admin_cc.management.client
p = admin.create_project(name='test-' + random_str(),
clusterId=admin_cc.cluster.id)
p = admin.wait_success(p)
wait_for_condition("BackingNamespaceCreated", "True",
admin_cc.management.client, p)
assert p.state == 'active'
request.addfinalizer(lambda: admin_cc.management.client.delete(p))
url = p.links['self'] + '/schemas'
return ProjectContext(
admin_cc, p, rancher.Client(url=url, verify=False, token=admin.token))
def test_basic_auth(admin_pc):
client = admin_pc.client
name = random_str()
cert = client.create_basic_auth(name=name,
username='******',
password='******')
assert cert.baseType == 'secret'
assert cert.type == 'basicAuth'
assert cert.name == name
assert cert.username == 'foo'
assert 'password' in cert
assert cert.namespaceId is None
assert 'namespace' not in cert
assert cert.projectId == admin_pc.project.id
cert = client.update(cert, username='******')
cert = client.reload(cert)
assert cert.baseType == 'secret'
assert cert.type == 'basicAuth'
assert cert.name == name
assert cert.username == 'foo2'
assert 'password' not in cert
assert cert.namespaceId is None
assert 'namespace' not in cert
assert cert.projectId == admin_pc.project.id
found = False
for i in client.list_basic_auth():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_basic_auth(cert.id)
assert cert is not None
client.delete(cert)
def test_certificates(admin_pc):
client = admin_pc.client
name = random_str()
cert = client.create_certificate(name=name, key=KEY, certs=CERT)
assert cert.baseType == 'secret'
assert cert.expiresAt == '2026-06-28T01:13:32Z'
assert cert.type == 'certificate'
assert cert.name == name
assert cert.certs == CERT
assert cert.namespaceId is None
assert 'namespace' not in cert
# cert = client.update(cert, certs='certdata2')
# cert = client.reload(cert)
#
# assert cert.baseType == 'secret'
# assert cert.type == 'certificate'
# assert cert.name == name
# assert cert.certs == 'certdata2'
# assert cert.namespaceId is None
# assert 'namespace' not in cert
# assert cert.projectId == pc.project.id
found = False
for i in client.list_certificate():
if i.id == cert.id:
found = True
break
assert found
cert = client.by_id_certificate(cert.id)
assert cert is not None
client.delete(cert)
def random_str():
return common.random_str()
def make_msg(strlist):
strlist.append(common.random_str())
def upload():
if session.get('is_login') is None or not session.get('is_login'):
flash(u'请先登录！', 'danger')
return redirect(url_for('login'))
upload_form = UploadForm()
# print dir(upload_form.file_upload.data)
# print dir(upload_form.file_upload.data.stream)
# print upload_form.file_upload.data.stream.read()
if upload_form.validate_on_submit():
# check access key and secret key and image limit
current_user_id = session.get('user_id')
user_info = UsersInfo.query.filter_by(user_id=current_user_id).first()
if user_info is None or not user_info:
return redirect(url_for('e500'))
if user_info.qiniu_access_key == '' or user_info.qiniu_secret_key == '' or \
user_info.qiniu_bucket_name == '' or user_info.qiniu_domain == '' or \
user_info.qiniu_access_key is None or user_info.qiniu_secret_key is None or \
user_info.qiniu_bucket_name is None or user_info.qiniu_domain is None:
# flash(u'您还未设置七牛密钥信息，请去个人中心中设置', 'danger')
return redirect(url_for('main_view'))
images = Images.query.filter_by(upload_user_id=current_user_id, use_default_config=0).all()
max_upload_count = WebConfig.query.filter_by(config_name='default_upload_count').first()
if len(images) >= int(max_upload_count.config_value):
# flash(u'您已上传的图片数量到达系统限制，
# 使用自己的七牛密钥后可以上传更多图片，请到个人中心设置。', 'danger')
return redirect(url_for('main_view'))
upload_filename = upload_form.file_upload.data.filename
ext = os.path.splitext(upload_filename)[1]
# save file in tmp directory
local_filename = random_str(32) + ext
with open('tmp/'+local_filename, 'wb') as ff:
ff.write(upload_form.file_upload.data.stream.read())
# init qiniu
current_user_id = session.get('user_id')
users_info = UsersInfo.query.filter_by(user_id=current_user_id).first()
access_key = users_info.qiniu_access_key
secret_key = users_info.qiniu_secret_key
bucket_name = users_info.qiniu_bucket_name
domain = users_info.qiniu_domain
q = Auth(access_key, secret_key)
remote_filename = local_filename
upload_token = q.upload_token(bucket_name, remote_filename, 3600)
local_file = 'tmp/' + local_filename
ret, info = put_file(upload_token, remote_filename, local_file)
url = 'http://' + domain + '/' + ret['key']
# url2 = request.host_url + session.get('username') + '/' + local_filename
# print '[*]', url
# insert into image table
title = upload_form.title.data
description = upload_form.description.data
qiniu_have_account = session.get('qiniu_have_account')
if qiniu_have_account is None:
flash(u'系统错误！请稍后再试！', 'danger')
return redirect(url_for('main_view'))
# use_default_config = 0: use system config
# use_default_config = 1: use user's config
images = Images(image_id='', title=title, description=description, filename=local_filename,
link=url, upload_time=str(int(time.time())), upload_user_id=current_user_id,
use_default_config=qiniu_have_account)
db.session.add(images)
db.session.commit()
user_dir = 'tmp/' + session.get('username') + '/'
if not os.path.exists(user_dir):
os.mkdir(user_dir)
thumbnail_file = user_dir + local_filename
im = Image.open(local_file)
im.thumbnail((128, 128))
im.save(thumbnail_file)
if os.path.exists(local_file):
os.remove(local_file)
flash(u'上传成功！链接为 '+url+'，您可在个人中心中查看已上传的全部图片。', 'success')
return redirect(url_for('main_view'))
return redirect(url_for('main_view'))
