def login():
if request.method == "GET":
return jsonify(msg="please login")
try:
data = json.loads(request.data.decode('utf8'))
username = data.get("username")
password = data.get("password")
except Exception:
response = jsonify(errMsg="wrong format")
response.status_code = 401
return response
if username == None or password == None:
response = jsonify(errMsg="fields not complete")
response.status_code = 401
return response
db = DBSession()
results = db.query(User).filter(User.username == username).filter(
User.password == md5(password))
# if successfully logged in
if results.count() == 1:
user = results.first()
login_info = dict()
login_info['user_id'] = user.id
login_info['username'] = user.username
login_info['kind'] = user.kind
authorization = base64.b64encode(
json.dumps(login_info).encode('utf-8'))
if user.kind == 0:
kind = "customer"
else:
kind = "saler"
response = jsonify(kind=kind)
response.headers['authorization'] = authorization
response.status_code = 200
DBSession.remove()
return response
# if login failed
response = jsonify(errMsg="login failed")
response.status_code = 401
DBSession.remove()
return response
def register():
if request.method == 'GET':
return jsonify(msg="Please register")
else:
try:
data = json.loads(request.data.decode('utf8'))
username = data.get("username")
password = data.get("password")
kind = data.get("kind")
except Exception:
response = jsonify(errMsg="wrong format")
response.status_code = 400
return response
if username == None or password == None or kind == None:
response = jsonify(errMsg="fields not complete")
response.status_code = 400
return response
if kind == "customer":
kind = 0
elif kind == "saler":
kind = 1
else:
response = jsonify(errMsg="fields with illegal value")
response.status_code = 400
return response
db = DBSession()
if db.query(User).filter(User.username == username).count() != 0:
response = jsonify(errMsg="user already exists")
response.status_code = 400
DBSession.remove()
return response
user = User(username=username, password=md5(password), kind=kind)
db.add(user)
db.commit()
response = jsonify(msg="register successfully")
response.status_code = 201
DBSession.remove()
return response
def tearDown(self):
DBSession.remove()
testing.tearDown()
def tearDown(self):
DBSession.remove()
testing.tearDown()
def run(self):
logger.info(f"{self} - started")
source = self.source
destination = self.destination
src_path = os.path.join(source.src_path, self.dataset)
dst_path = destination.dst_path
tc = GlobusTransfer.transfer_client
td = TransferData(tc, source.uuid, destination.uuid)
td.add_item(src_path, dst_path, recursive=True)
try:
task = tc.submit_transfer(td)
request_time = datetime.utcnow()
task_id = task.get("task_id")
"""
A Globus transfer job (task) can be in one of the three states:
ACTIVE, SUCCEEDED, FAILED. The script every 60 seconds polls a
status of the transfer job (task) from the Globus Transfer service,
with 60 second timeout limit. If the task is ACTIVE after time runs
out 'task_wait' returns False, and True otherwise.
"""
while not tc.task_wait(task_id, 60, 60):
if datetime.utcnow() - request_time >= timedelta(
seconds=GlobusTransfer.deadline):
break
task = tc.get_task(task_id)
if task.get("is_paused"):
break
"""
The Globus transfer job (task) has been finished (SUCCEEDED or FAILED),
or is still active (ACTIVE). Check if the transfer SUCCEEDED or FAILED.
"""
task = tc.get_task(task_id)
if task["status"] == "SUCCEEDED":
bps = task.get("effective_bytes_per_second")
rate = GlobusTransfer.convert_bps(bps)
logger.info(
f"Globus transfer {task_id}, from {source.uuid}{src_path} to {destination.uuid}{dst_path} succeeded"
)
logger.info(
"{} - files transferred: {}, bytes transferred: {}, effective transfer rate: {}, faults: {}"
.format(self, task.get("files_transferred"),
task.get("bytes_transferred"), rate,
task.get("faults")))
faults = task.get("faults")
message = None
if faults > 0:
message = self.get_error_events(tc, task_id)
t = TransferModel(uuid=task_id,
set=self.set,
source=source.name,
destination=destination.name,
dataset=self.dataset,
status=SUCCEEDED,
rate=bps,
message=message,
faults=faults)
elif task.get("status") == "ACTIVE":
if task.get("is_paused"):
pause_info = tc.task_pause_info(task_id)
paused_rules = pause_info.get("pause_rules")
reason = paused_rules[0].get("message")
message = f"The task was paused. Reason: {reason}"
status = PAUSED
logger.info("{} - {}".format(self, message))
else:
message = f"The task reached a {GlobusTransfer.deadline} second deadline\n"
events = tc.task_event_list(task_id,
num_results=5,
filter="is_error:1")
message += self.get_error_events(tc, task_id)
status = DEADLINE
logger.warning("{} - faults: {}, error: {}".format(
self, task.get("faults"), message))
tc.cancel_task(task_id)
t = TransferModel(uuid=task_id,
set=self.set,
source=source.name,
destination=destination.name,
dataset=self.dataset,
status=status,
message=message,
faults=task.get("faults"))
else:
t = TransferModel(uuid=task_id,
set=self.set,
source=source.name,
destination=destination.name,
dataset=self.dataset,
status=FAILED)
except Exception as e:
logger.error(f"{self} - exception: {e}")
t = TransferModel(set=self.set,
source=source.name,
destination=destination.name,
dataset=self.dataset,
status=EXCEPTION,
message=f"Globus SDK Exception: {e}")
self.done = True
GlobusTransfer.transfers2do -= 1
session = DBSession()
session.add(t)
session.commit()
DBSession.remove()
self.release()
logger.info(f"{self} - finished")
def acquire_coupons(username, couponname):
# select for update example
auth_info = get_auth_info()
if auth_info['kind'] != 0:
response = jsonify(errMsg='saler could not acquire a coupon')
response.status_code = 204
return response
db = DBSession()
user_kind = rs.get(username)
# user_kind=='2'means it does exist
if not user_kind:
user = db.query(User).filter(User.username == username).first()
if not user:
rs.set(username, 2)
response = jsonify(errMsg="the username must be valid")
response.status_code = 204
DBSession.remove()
return response
if user.kind == 0:
rs.set(username, 0)
response = jsonify(errMsg="the username must be a saler")
response.status_code = 204
DBSession.remove()
return response
rs.set(username, 1)
elif user_kind == '2':
response = jsonify(errMsg="the username must be valid(from redis)")
response.status_code = 204
DBSession.remove()
return response
elif user_kind == '0':
response = jsonify(errMsg="the username must be a saler(from redis)")
response.status_code = 204
DBSession.remove()
return response
key = auth_info['username'] + "_" + couponname
if not rs.get(key):
# get the coupon of a saler
coupon=db.query(Coupon).filter(Coupon.username==username)\
.filter(Coupon.coupon_name == couponname).with_for_update().first()
if coupon and coupon.left > 0:
db.add(
Coupon(username=auth_info['username'],
coupon_name=coupon.coupon_name,
stock=coupon.stock,
description=coupon.description))
coupon.left -= 1
try:
db.commit()
except Exception:
# the user already has the coupon
rs.set(key, 'has')
response = jsonify(errMsg="coupons acquired failed")
response.status_code = 204
DBSession.remove()
return response
# acquire the coupon successfully
rs.set(key, 'has')
response = jsonify(msg="coupon acquired successfully")
response.status_code = 201
DBSession.remove()
return response
# the key is in the redis, it means the customer has the coupon
response = jsonify(errMsg="coupons acquired failed(from redis)")
response.status_code = 204
DBSession.remove()
return response
def addreadcoupons(username):
auth_info = get_auth_info()
# get method to get the page for different kinds of users
if request.method == 'GET':
try:
page = int(request.args.get('page'))
except Exception:
page = 1
if page <= 0:
page = 1
#check if username exists
db = DBSession()
user = db.query(User).filter(User.username == username).first()
if not user:
response = jsonify(errMsg="username does not exist")
response.status_code = 401
DBSession.remove()
return response
# usernames different
if auth_info['username'] != username:
# the asked username is a customer
if user.kind == 0:
response = jsonify(
errMsg=
"usernames different and the asked username is a customer")
response.status_code = 401
DBSession.remove()
return response
# the asked username is a saler
else:
# return the left 20 coupons of that saler
data, status_code = returnsalercoupons(db, username, page)
response = jsonify(data=data)
response.status_code = status_code
DBSession.remove()
return response
else:
# usernames identical
if auth_info['kind'] == 1:
# saler
# return the left 20 coupons of that saler
data, status_code = returnsalercoupons(db, username, page)
response = jsonify(data=data)
response.status_code = status_code
DBSession.remove()
return response
else:
# customer
# return the acquired coupons for that customer
data, status_code = returncustomercoupons(db, username)
response = jsonify(data=data)
response.status_code = status_code
DBSession.remove()
return response
# post method to add coupons
try:
coupon_info = json.loads(request.data.decode('utf8'))
except Exception:
response = jsonify(errMsg='wrong coupon information')
response.status_code = 400
return response
coupon_name = coupon_info.get('name')
amount = coupon_info.get('amount')
description = coupon_info.get('description')
stock = coupon_info.get('stock')
# check legality of inputs
# only salers could create coupons
if auth_info['kind'] != 1:
response = jsonify(errMsg='Customers can not add a coupon')
response.status_code = 400
return response
if coupon_name == None or amount == None or stock == None:
response = jsonify(errMsg='fields not complete')
response.status_code = 400
return response
try:
amount = int(amount)
stock = int(stock)
except ValueError:
response = jsonify(errMsg='amount or stock must be numbers')
response.status_code = 400
return response
# add coupon to the database
db = DBSession()
coupon_info = Coupon(username=auth_info['username'],
coupon_name=coupon_name,
amount=amount,
left=amount,
stock=stock,
description=description)
try:
db.add(coupon_info)
db.commit()
except Exception:
response = jsonify(errMsg="coupons already exists")
response.status_code = 400
DBSession.remove()
return response
response = jsonify(msg="coupon added successfully")
response.status_code = 201
DBSession.remove()
return response
def shutdown_session(exception=None):
DBSession.remove()
def cleanup_callback(request):
from models import DBSession
DBSession.flush()
DBSession.remove()
