def on_convert(self, request):
if should_exclude_visitor(request):
return json_success({'excluded': 'true'}, request)
experiment_name = request.args.get('experiment')
client_id = request.args.get('client_id')
kpi = request.args.get('kpi', None)
if client_id is None or experiment_name is None:
return json_error({'message': 'missing arguments'}, request, 400)
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
try:
alt = convert(experiment_name, client_id, kpi=kpi, datetime=dt, redis=self.redis)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'alternative': {
'name': alt.name
},
'experiment': {
'name': alt.experiment.name,
},
'conversion': {
'value': None,
'kpi': kpi
},
'client_id': client_id
}
return json_success(resp, request)
def on_convert(self, request):
if should_exclude_visitor(request):
return json_success({'excluded': 'true'}, request)
experiment_name = request.args.get('experiment')
client_id = request.args.get('client_id')
kpi = request.args.get('kpi', None)
if client_id is None or experiment_name is None:
return json_error({'message': 'missing arguments'}, request, 400)
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
try:
alt = convert(experiment_name, client_id, kpi=kpi, datetime=dt, redis=self.redis)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'alternative': {
'name': alt.name
},
'experiment': {
'name': alt.experiment.name,
},
'conversion': {
'value': None,
'kpi': kpi
},
'client_id': client_id
}
return json_success(resp, request)
def on_alt_fractions(self, request):
experiment_name = request.args.get('experiment')
if experiment_name is None:
return json_error(
{
'message':
'set alt_fractions fail because of missing experiment name'
}, request, 400)
try:
exp = Experiment.find(experiment_name, redis=self.redis)
alt_fractions = []
for alternabive in exp.alternatives:
alt_fractions.append(request.args.get(alternabive.name))
exp.set_alt_fractions(alt_fractions)
exp.save()
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'experiment': {
'name': experiment_name,
},
'alt_fraction': exp.alt_fractions,
'status': 'ok'
}
return json_success(resp, request)
def decorated(*args, **kwargs):
data = request.data.decode('utf-8')
try:
request_json = json.loads(data)
except (ValueError, KeyError, TypeError):
return json_error('Use JSON to comunicate with our API')
if not require_data:
return f(request_json=request_json, *args, **kwargs)
elif 'data' in request_json.keys():
data = str(request_json['data']).strip()
if required_data_words:
if len(data.split()) != required_data_words:
return json_error("Data must have %d word(s)!" %
required_data_words)
if required_data_characters:
if len(data) != required_data_characters:
return json_error("Data must have %d characters!" %
required_data_characters)
return f(data=data, request_json=request_json, *args, **kwargs)
return json_error('Data not provided')
def decorated(*args, **kwargs):
data = request.data.decode('utf-8')
try:
request_json = json.loads(data)
except (ValueError, KeyError, TypeError):
return json_error('Use JSON to comunicate with our API')
if not require_data:
return f(request_json=request_json, *args, **kwargs)
elif 'data' in request_json.keys():
data = str(request_json['data']).strip()
if required_data_words:
if len(data.split()) != required_data_words:
return json_error("Data must have %d word(s)!" %
required_data_words)
if required_data_characters:
if len(data) != required_data_characters:
return json_error("Data must have %d characters!" %
required_data_characters)
return f(data=data, request_json=request_json, *args, **kwargs)
return json_error('Data not provided')
def on_client_experiments(self, request, client_id):
api_key = request.args.get('api_key', None)
exclude_archived = False if request.args.get(
'exclude_archived', '').lower() == 'false' else True
exclude_paused = False if request.args.get(
'exclude_paused', '').lower() == 'false' else True
if client_id is None:
return json_error({'message': 'missing arguments'}, request, 400)
try:
experiment_alternatives = client_experiments(
api_key, client_id, redis=self.redis,
exclude_archived=exclude_archived,
exclude_paused=exclude_paused)
except (ValueError, APIError) as e:
return json_error({'message': str(e)}, request, 500)
if not experiment_alternatives:
return json_success({'experiments': []}, request)
experiment_info = [
{
'alternative': {
'name': alt.name
},
'experiment': {
'name': alt.experiment.name,
'is_paused': alt.experiment.is_paused(),
'is_archived': alt.experiment.is_archived()
},
}
for alt in experiment_alternatives
]
resp = {
'experiments': experiment_info
}
return json_success(resp, request)
def post_order():
"""
header Authorization: Token Authentication_user_token
{
"event_key": "y37jsnks",
"drinks": [{
"mixer_type": "coke",
"alcohol_type": "rhum",
"double": True
}],
}
"""
if request.content_type != JSON_MIME_TYPE:
return json_error('Invalid Content Type', 'Invalid Content Type', 400)
if g.get('current_user', None) is None:
return json_error('No user found might have been a machine token',
status=401)
data = request.json
event = Event.find(data.get('event_key'))
if event is None:
return json_error('Event not found', 'Event not found', 404)
drinks = [
Drink(drink.get('mixer_type'), drink.get('alcohol_type'),
drink.get('double')) for drink in data.get('drinks')
]
# total_price = Order.get_price_from_drinks(drinks)
# TODO process transation, for now assume the trasaction always passes
new_order = Order(g.current_user._id, drinks, payed=True)
new_order.create()
event.add_new_order(new_order)
g.current_user.add_order(new_order)
return json_response(json.dumps(new_order.to_dict()), status=200)
def on_traffic():
experiment_name = request.args.get('experiment')
traffic_fraction = request.args.get('traffic_fraction')
if traffic_fraction is None or experiment_name is None:
return utils.json_error(
{'message': 'set traffic fail because of missing arguments'},
request, 400)
traffic_fraction = float(traffic_fraction)
try:
exp = Experiment.find(experiment_name, redis=db.REDIS)
exp.set_traffic_fraction(traffic_fraction)
exp.save()
except ValueError as e:
return utils.json_error({'message': str(e)}, request, 400)
resp = {
'experiment': {
'name': experiment_name,
},
'traffic_fraction': traffic_fraction,
'status': 'ok'
}
return utils.json_success(resp, request)
def on_participate(self, request):
#获取分组列表
alts = request.args.getlist('alternatives')
# alt_fractions = request.args.getlist('alt_fractions')
experiment_name = request.args.get('experiment') #实验名称
force = request.args.get('force')
#获取record_force参数，并进行to_bool判断若为[y,ture,yes],返回Ture,否则False
record_force = to_bool(request.args.get('record_force', 'false'))
client_id = request.args.get('client_id') #获取client_id
traffic_fraction = request.args.get('traffic_fraction') #获取参与比例
if traffic_fraction is not None:
traffic_fraction = float(
traffic_fraction) #若traffic_fraction存在则转为float()
prefetch = to_bool(request.args.get(
'prefetch',
'false')) #获取prefetch，并进行to_bool判断若为[y,ture,yes],返回Ture,否则Fals
if client_id is None or experiment_name is None or alts is None: #三个必要参数，否则返回400
return json_error({'message': 'missing arguments'}, request, 400)
dt = None
if request.args.get(
"datetime"): #获取datetime参数，转化为datetime.datetime()类型，没有则默认None
dt = dateutil.parser.parse(request.args.get("datetime"))
try:
if should_exclude_visitor(
request): #判断user_agent是爬虫或者IP为指定排除的ip,则拒绝参与
exp = Experiment.find(experiment_name, redis=self.redis)
if exp.winner is not None: #判断是否已经胜出
alt = exp.winner
else:
alt = exp.control #没有胜出，返回分组中的第一个赋值给alt
else:
alt = participate(
experiment_name,
alts,
client_id,
force=force,
record_force=record_force,
traffic_fraction=traffic_fraction,
# alt_fraction=alt_fractions,
prefetch=prefetch,
datetime=dt,
redis=self.redis)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'alternative': {
'name': alt.name
},
'experiment': {
'name': alt.experiment.name,
},
'client_id': client_id,
'status': 'ok'
}
return json_success(resp, request)
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, 'on_' + endpoint)(request, **values)
except NotFound:
return json_error({"message": "not found"}, request, 404)
except HTTPException:
return json_error({"message": "an internal error has occurred"}, request, 500)
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, 'on_' + endpoint)(request, **values)
except NotFound:
return json_error({"message": "not found"}, request, 404)
except HTTPException:
return json_error({"message": "an internal error has occurred"}, request, 500)
def get(request):
if not 'id' in request.GET:
return json_error(1, arg1='id')
try:
result = Location.objects\
.values('id', 'longitude', 'latitude', 'last_update', 'date_created')\
.get(id=int(request.GET['id']))
except (ObjectDoesNotExist, ValueError, TypeError):
return json_error(2, arg1='id')
return json_result(result)
def post_machine_to_event(event_key):
"""
header Authorization: Token Authentication_machine_token
/api/v1/user/event/<string:event_key>
"""
if g.get('current_machine', None) is None:
return json_error('No machine found might have been a user token',
status=401)
event = Event.find(event_key)
if event is None:
return json_error('Event not found', 'Event not found', 404)
event.add_machine(g.current_machine)
return json_response(json.dumps(event.to_dict()), status=200)
def get(request):
if (not 'id' in request.GET) and (not 'name' in request.GET):
return json_error(1, arg1='id or name')
try:
res = Truck.objects.values('id', 'name', 'location_id', 'last_update', 'date_created')
if 'id' in request.GET:
result = res.get(id=request.GET['id'])
else:
result = res.get(name=request.GET['name'])
except ObjectDoesNotExist:
return json_error(2, arg1='id or name')
return json_result(result)
def on_participate(self, request):
alts = request.args.getlist('alternatives')
experiment_name = request.args.get('experiment')
bucket = request.args.get('bucket')
force = request.args.get('force')
client_id = request.args.get('client_id')
traffic_fraction = request.args.get('traffic_fraction')
if traffic_fraction is not None:
traffic_fraction = float(traffic_fraction)
prefetch = to_bool(request.args.get('prefetch', 'false'))
if client_id is None or experiment_name is None or alts is None:
return json_error({'message': 'missing arguments'}, request, 400)
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
if should_exclude_visitor(request):
exp = Experiment.find(experiment_name, redis=self.redis)
if exp.winner is not None:
alt = exp.winner
else:
alt = exp.control
else:
try:
alt = participate(experiment_name,
alts,
client_id,
force=force,
bucket=bucket,
traffic_fraction=traffic_fraction,
prefetch=prefetch,
datetime=dt,
redis=self.redis)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'alternative': {
'name': alt.name
},
'experiment': {
'name': alt.experiment.name,
},
'client_id': client_id,
'status': 'ok'
}
return json_success(resp, request)
def dispatch_request_with_metrics(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
with self.statsd.timer('{}.response_time'.format(endpoint)):
response = getattr(self, 'on_' + endpoint)(request, **values)
self.statsd.incr('{}.count'.format(endpoint))
self._incr_status_code(response.status_code)
return response
except NotFound:
self._incr_status_code(404)
return json_error({"message": "not found"}, request, 404)
except HTTPException:
self._incr_status_code(500)
return json_error({"message": "an internal error has occurred"}, request, 500)
def post_machine():
"""
header Authorization: Token Authentication_user_token
"""
if g.get('current_user', None) is None:
return json_error('No user found might have been a machine token',
status=401)
new_machine = Machine()
try:
new_machine.create(g.current_user)
except Machine_Creation_Exception:
return json_error('User: '******' unautherised for this creation action',
status=401)
return json_response(json.dumps(new_machine.to_dict()), status=200)
def dispatch_request_with_metrics(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
with self.statsd.timer('{}.response_time'.format(endpoint)):
response = getattr(self, 'on_' + endpoint)(request, **values)
self.statsd.incr('{}.count'.format(endpoint))
self._incr_status_code(response.status_code)
return response
except NotFound:
self._incr_status_code(404)
return json_error({"message": "not found"}, request, 404)
except HTTPException:
self._incr_status_code(500)
return json_error({"message": "an internal error has occurred"}, request, 500)
def get(request):
if (not 'id' in request.GET) and (not 'name' in request.GET):
return json_error(1, arg1='id or name')
try:
res = Truck.objects.values('id', 'name', 'location_id', 'last_update',
'date_created')
if 'id' in request.GET:
result = res.get(id=request.GET['id'])
else:
result = res.get(name=request.GET['name'])
except ObjectDoesNotExist:
return json_error(2, arg1='id or name')
return json_result(result)
def on_participate(self, request):
opts = {}
alts = request.args.getlist('alternatives')
experiment_name = request.args.get('experiment')
force = request.args.get('force')
client_id = request.args.get('client_id')
distribution = request.args.get('traffic_dist')
if client_id is None or experiment_name is None or alts is None:
return json_error({'message': 'missing arguments'}, request, 400)
if distribution:
opts['distribution'] = distribution
try:
experiment = Experiment.find_or_create(experiment_name, alts,
self.redis, opts)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
alternative = None
if force and force in alts:
alternative = force
elif not cfg.get('enabled', True):
alternative = alts[0]
elif experiment.winner is not None:
alternative = experiment.winner
elif should_exclude_visitor(request):
alternative = alts[0]
else:
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
client = Client(client_id, self.redis)
alternative = experiment.get_alternative(client, dt=dt).name
resp = {
'alternative': {
'name': alternative
},
'experiment': {
'name': experiment.name,
},
'client_id': client_id,
'status': 'ok'
}
return json_success(resp, request)
def create():
data = request.get_json()
form = TopicForm(**data)
if form.validate():
form_data = form.data
form_data['ip'] = request.remote_addr
try:
topic = g.user.create_topic(**form_data)
alert = dict(
type='success',
messages=_("Your topic has been created successfully. You will be redirected to it shortly")
)
redirect = topic.get_url('view')
cache.update_sorted_topics(topic, 'date_created')
return jsonify({"data": topic.json_data(), "alert": alert, "redirect": redirect})
except ModelException, me:
db_session.rollback()
return json_error(type=me.type, messages=me.message)
except Exception, e:
logging.error(e)
db_session.rollback()
return json_error_database()
def get_md5sum(request, share, subpath):
from utils import md5sum
file_path = os.path.join(share.get_path(), subpath)
try:
return json_response({'md5sum': md5sum(file_path), 'path': subpath})
except Exception, e:
return json_error(str(e))
def add(request):
if not 'name' in request.GET:
return json_error(1, arg1='name')
if not 'location_id' in request.GET:
return json_error(1, arg1='location_id')
try:
location = Location.objects.get(id=int(request.GET['location_id']))
except (ObjectDoesNotExist, ValueError, TypeError):
return json_error(2, arg1='location')
result = Truck.objects.create(name=request.GET['name'], location=location)
return json_result(result.id)
def on_experiment_details(self, request, name):
exp = Experiment.find(name, redis=self.redis)
if exp is None:
return json_error({'message': 'experiment not found'}, request,
404)
return json_success(exp.objectify_by_period('day', True), request)
def create():
data = request.get_json()
form = TopicForm(**data)
if form.validate():
form_data = form.data
form_data['ip'] = request.remote_addr
try:
topic = g.user.create_topic(**form_data)
alert = dict(
type='success',
messages=
_("Your topic has been created successfully. You will be redirected to it shortly"
))
redirect = topic.get_url('view')
cache.update_sorted_topics(topic, 'date_created')
return jsonify({
"data": topic.json_data(),
"alert": alert,
"redirect": redirect
})
except ModelException, me:
db_session.rollback()
return json_error(type=me.type, messages=me.message)
except Exception, e:
logging.error(e)
db_session.rollback()
return json_error_database()
def comment_create():
data = request.get_json()
topic = g.topic
form = CommentForm(**data)
if form.validate():
form_data = form.data
form_data['user'] = g.user
form_data['ip'] = request.remote_addr
try:
comment = topic.create_comment(**form_data)
topic.update_comment_count()
topic.update_user_comment_count(user_id=comment.user_id)
db_session.commit()
cache.update_topic(topic.id, topic)
cache.update_sorted_topics(topic, 'comment_count')
return jsonify({"data": comment.json_data()})
except ModelException, me:
db_session.rollback()
return json_error(type=me.type, messages=me.message)
except Exception, e:
logging.error(e)
db_session.rollback()
return json_error_database()
def calculate_capacity(self):
try:
in_data = json_request()
resource = in_data["Resource"]
if not isinstance(resource, dict):
raise Exception("Resource field is not an object!")
if "Allocation" in in_data:
allocation = in_data["Allocation"]
if not isinstance(allocation,list):
raise Exception("Allocation field is not an array!")
else:
allocation = {}
if "Release" in in_data:
release = in_data["Release"]
if not isinstance(release, list):
raise Exception("Release field is not an array!")
else:
release = {}
return json_reply(self._calculate_capacity(resource, allocation, release))
except Exception as e:
return json_error(e)
def create_reservation(self):
try:
in_data = json_request()
alloc_req = in_data["Allocation"]
if not isinstance(alloc_req, list):
raise Exception("Allocation field is not an array!")
if "Constraints" in in_data:
constraints = in_data["Constraints"]
if not isinstance(constraints, list):
raise Exception("Constraints field is not an array!")
else:
constraints = []
if "Monitor" in in_data:
monitor = in_data["Monitor"]
if not isinstance(monitor, dict):
raise Exception("Monitor field is not an object!")
else:
monitor = {}
if "Scheduler" in in_data:
scheduler = in_data["Scheduler"]
else:
scheduler = ""
ResourcesView().request_resources()
return json_reply(
self._create_reservation(scheduler, alloc_req, constraints,
monitor))
except Exception as e:
return json_error(e)
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
if endpoint == 'participate' or endpoint == 'convert' or endpoint == 'experiment_details':
self.set_redis_prefix(request)
return getattr(self, 'on_' + endpoint)(request, **values)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
except NotFound:
return json_error({"message": "not found"}, request, 404)
except HTTPException:
return json_error({"message": "an internal error has occurred"}, request, 500)
def calculate_capacity(self):
try:
in_data = json_request()
resource = in_data["Resource"]
if not isinstance(resource, dict):
raise Exception("Resource field is not an object!")
if "Allocation" in in_data:
allocation = in_data["Allocation"]
if not isinstance(allocation, list):
raise Exception("Allocation field is not an array!")
else:
allocation = {}
if "Release" in in_data:
release = in_data["Release"]
if not isinstance(release, list):
raise Exception("Release field is not an array!")
else:
release = {}
return json_reply(
self._calculate_capacity(resource, allocation, release))
except Exception as e:
return json_error(e)
def comment_create():
data = request.get_json()
article = g.article
form = CommentForm(**data)
if form.validate():
form_data = form.data
form_data['user'] = g.user
form_data['ip'] = request.remote_addr
try:
comment = article.create_comment(**form_data)
article.update_comment_count()
article.update_user_comment_count(user_id=comment.user_id)
db_session.commit()
cache.update_article(article.id, article)
cache.update_sorted_articles(article, 'comment_count')
return jsonify({"data": comment.json_data()})
except ModelException, me:
db_session.rollback()
return json_error(type=me.type, messages=me.message)
except Exception, e:
logging.error(e)
db_session.rollback()
return json_error_database()
def add(request):
if not 'name' in request.GET:
return json_error(1, arg1='name')
if not 'location_id' in request.GET:
return json_error(1, arg1='location_id')
try:
location = Location.objects.get(id=int(request.GET['location_id']))
except (ObjectDoesNotExist, ValueError, TypeError):
return json_error(2, arg1='location')
result = Truck.objects.create(name=request.GET['name'], location=location)
return json_result(result.id)
def on_participate(self, request):
opts = {}
alts = request.args.getlist('alternatives')
experiment_name = request.args.get('experiment')
force = request.args.get('force')
client_id = request.args.get('client_id')
distribution = request.args.get('traffic_dist')
if client_id is None or experiment_name is None or alts is None:
return json_error({'message': 'missing arguments'}, request, 400)
if distribution:
opts['distribution'] = distribution
try:
experiment = Experiment.find_or_create(experiment_name, alts, self.redis, opts)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
alternative = None
if force and force in alts:
alternative = force
elif not cfg.get('enabled', True):
alternative = alts[0]
elif experiment.winner is not None:
alternative = experiment.winner
elif should_exclude_visitor(request):
alternative = alts[0]
else:
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
client = Client(client_id, self.redis)
alternative = experiment.get_alternative(client, dt=dt).name
resp = {
'alternative': {
'name': alternative
},
'experiment': {
'name': experiment.name,
},
'client_id': client_id,
'status': 'ok'
}
return json_success(resp, request)
def request_resources(self):
try:
managers = copy.copy(ManagersTreeView.managers)
for id in managers:
self.request_resources_id(id)
return json_reply({})
except Exception as e:
return json_error(e)
def delete_managers(self):
try:
ManagersTreeView.managers = {}
return json_reply({})
except Exception as e:
return json_error(e)
def get_user():
"""
header Authorization: Token Authentication_user_token
"""
if g.get('current_user', None) is None:
return json_error('No user found might have been a machine token',
status=401)
return json_response(json.dumps(g.current_user.to_dict()), status=200)
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
if endpoint == 'participate' or endpoint == 'convert' or endpoint == 'experiment_details':
self.set_redis_prefix(request)
return getattr(self, 'on_' + endpoint)(request, **values)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
except NotFound:
return json_error({"message": "not found"}, request, 404)
except HTTPException:
return json_error({"message": "an internal error has occurred"},
request, 500)
def request_resources(self):
try:
managers = copy.copy(ManagersTreeView.managers)
for id in managers:
self.request_resources_id(id)
return json_reply({})
except Exception as e:
return json_error(e)
def on_participate(self, request):
alts = request.args.getlist('alternatives')
experiment_name = request.args.get('experiment')
force = request.args.get('force')
record_force = to_bool(request.args.get('record_force', 'false'))
client_id = request.args.get('client_id')
traffic_fraction = request.args.get('traffic_fraction')
if traffic_fraction is not None:
traffic_fraction = float(traffic_fraction)
prefetch = to_bool(request.args.get('prefetch', 'false'))
if client_id is None or experiment_name is None or alts is None:
return json_error({'message': 'missing arguments'}, request, 400)
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
try:
if should_exclude_visitor(request):
exp = Experiment.find(experiment_name, redis=self.redis)
if exp.winner is not None:
alt = exp.winner
else:
alt = exp.control
else:
alt = participate(experiment_name, alts, client_id,
force=force, record_force=record_force,
traffic_fraction=traffic_fraction,
prefetch=prefetch, datetime=dt, redis=self.redis)
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'alternative': {
'name': alt.name
},
'experiment': {
'name': alt.experiment.name,
},
'client_id': client_id,
'status': 'ok'
}
return json_success(resp, request)
def download_archive_stream(request, share, subdir=None):
# try:
selection = request.GET.get('selection', '').split(',')
for item in selection:
test_path(item)
try:
return share.create_archive_stream(items=selection, subdir=subdir)
except Exception, e:
return json_error([str(e)])
def get_manager(self, id):
try:
if id in ManagersTreeView.managers:
return json_reply(ManagersTreeView.managers[id])
raise Exception("invalid manager id: " + id)
except Exception as e:
return json_error(e)
def add(request):
if not 'longitude' in request.GET:
return json_error(1, arg1='longitude')
if not 'latitude' in request.GET:
return json_error(1, arg1='latitude')
#
# defaults = request.GET
# if 'id' in defaults:
# defaults.pop('id')
# defaults.pop('longitude')
# defaults.pop('latitude')
result, created = Location.objects\
.get_or_create(longitude=request.GET['longitude'], latitude=request.GET['latitude'])
return json_result(result.id)
def download_archive_stream(request, share, subdir=None):
# try:
selection = request.GET.get('selection').split(',')
for item in selection:
test_path(item)
try:
return share.create_archive_stream(items=selection,subdir=subdir)
except Exception, e:
return json_error([e.message])
def create_folder(request, share, subdir=None):
form = FolderForm(request.POST)
data = json_form_validate(form)
if form.is_valid():
folder_path = share.create_folder(form.cleaned_data['name'],subdir)
(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(folder_path)
data['objects']=[{'name':form.cleaned_data['name'],'modified':datetime.datetime.fromtimestamp(mtime).strftime("%m/%d/%Y %I:%M %p")}]
ShareLog.create(share=share,user=request.user,action=ShareLog.ACTION_FOLDER_CREATED,paths=[form.cleaned_data['name']],subdir=subdir)
return json_response(data)
else:
return json_error([error for name, error in form.errors.items()])
def get_managers(self):
try:
mgrs = []
for i in ManagersTreeView.managers:
mgrs.append(ManagersTreeView.managers[i])
return json_reply(mgrs)
except Exception as e:
return json_error(e)
def create_folder(request, share, subdir=None):
form = FolderForm(request.POST)
data = json_form_validate(form)
if form.is_valid():
folder_path = share.create_folder(form.cleaned_data['name'],subdir)
(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(folder_path)
data['objects']=[{'name':form.cleaned_data['name'],'modified':datetime.datetime.fromtimestamp(mtime).strftime("%m/%d/%Y %I:%M %p")}]
ShareLog.create(share=share,user=request.user,action=ShareLog.ACTION_FOLDER_CREATED,paths=[form.cleaned_data['name']],subdir=subdir)
return json_response(data)
else:
return json_error([error for name, error in form.errors.items()])
def create():
data = request.get_json()
form = QuestionForm(**data)
if form.validate():
form_data = form.data
form_data['ip'] = request.remote_addr
question = g.user.create_question(**form_data)
return jsonify({"data": question.json_data()})
else:
return json_error(type="VALIDATION_FAILED", messages=form.errors)
def delete_manager(self, id):
try:
print "Unregistering %s" % id
if id in ManagersTreeView.managers:
item = ManagersTreeView.managers[id]
key = ManagersTreeView.gen_key(item['Name'], item['Address'], item['Port'])
self._deleteManager(item['Name'], item['Address'], item['Port'], id)
ManagersTreeView.managers.pop(id)
return json_reply({})
except Exception as e:
return json_error(e)
def on_convert(self, request):
if should_exclude_visitor(request):
return json_success({'excluded': 'true'}, request)
experiment_name = request.args.get('experiment')
client_id = request.args.get('client_id')
kpi = request.args.get('kpi', None)
if client_id is None or experiment_name is None:
return json_error({'message': 'missing arguments'}, request, 400)
client = Client(client_id, self.redis)
try:
experiment = Experiment.find(experiment_name, self.redis)
if cfg.get('enabled', True):
dt = None
if request.args.get("datetime"):
dt = dateutil.parser.parse(request.args.get("datetime"))
alternative = experiment.convert(client, dt=dt, kpi=kpi)
else:
alternative = experiment.control.name
except ValueError as e:
return json_error({'message': str(e)}, request, 400)
resp = {
'alternative': {
'name': alternative
},
'experiment': {
'name': experiment.name,
},
'conversion': {
'value': None,
'kpi': kpi
},
'client_id': client_id
}
return json_success(resp, request)
def request_resources_id(self, id):
try:
if not id in ManagersTreeView.managers:
raise Exception("cannot find manager: " + id)
data = ManagersTreeView.managers[id]
try:
out = get("getResources", data["Port"], data["Address"])
if "result" in out:
ResourcesView.resources[data["ManagerID"]] = out["result"]["Resources"]
if "Constraints" in out["result"]:
ResourcesView.resource_constraints[data["ManagerID"]] = out["result"]["Constraints"]
except requests.exceptions.ConnectionError:
ManagersTreeView._class().delete_manager(data["ManagerID"])
return json_error(Exception)
except Exception as e:
return json_error(e)
return json_reply({})
except Exception as e:
return json_error(e)
def add_class():
"""
Запрос на создание дисциплины
:param name: - string - имя новой дисциплины(уникально)
:return:
В случае прохода валидации параметров возвращает 200 код ответа
"""
data = request.get_json(force=True)
try:
add_to_db_by_session(db.session, Class(data['name']))
except Exception as e:
return json_error(e.message, 400)
return jsonify({"status": "ok"})
def get_metrics_get(self):
try:
reservID=request.args.get('id')
if reservID is None:
raise Exception("no id specified!")
addr=request.args.get('addr')
if addr is None:
addr = ""
entry=request.args.get('entry')
if entry is None:
entry = 0
entry_int = int(entry)
return json_reply(self._get_metrics(reservID, addr, entry_int))
except Exception as e:
return json_error(e)
def register_manager(self):
try:
in_data = json_request()
if 'Address' in in_data:
addr = in_data['Address']
else:
addr = request.remote_addr
# when testing (no requests), addr is None. We assume localhost
if addr is None:
addr = "127.0.0.1"
port = in_data['Port']
name = in_data['Name']
if not self._acceptManager(addr, port, name):
raise Exception("Manager %s rejected!" % name)
key = ManagersTreeView.gen_key(name, addr, port)
################### check the database ####
conn = sqlite3.connect('manager.db')
c = conn.cursor()
c.execute("SELECT * from managers where key = '%s'" % key)
r = c.fetchone()
if r == None:
idx = str(uuid.uuid1())
c.execute("INSERT INTO managers VALUES ('%s', '%s')" % (key, idx))
conn.commit()
else:
idx = r[1]
conn.close()
data = { 'Address': addr, 'Port': port, 'Name': name, 'ManagerID': idx }
ManagersTreeView.managers[idx] = data
print "Adding manager: %s" % data['Name']
self._registerManager(data)
return json_reply(ManagersTreeView.managers[idx])
except Exception as e:
return json_error(e)
def create():
data = request.get_json()
form = ArticleForm(**data)
if form.validate():
form_data = form.data
form_data['ip'] = request.remote_addr
article = g.user.create_article(**form_data)
alert = dict(
type='success',
messages=_("Your article has been submitted successfully. The staff will approve it soon. Thank you for your contribution")
)
redirect = url_for("site.page", name="home")
return jsonify({"data": article.json_data(), "alert": alert, "redirect": redirect})
else:
return json_error(type="VALIDATION_FAILED", messages=form.errors)
def get_metrics_post(self):
try:
in_data = json_request()
reservID = in_data['ReservationID']
if "Address" not in in_data:
addr = ""
else:
addr = in_data['Address']
if 'Entry' not in in_data:
entry = 1
else:
entry = in_data['Entry']
ret = self._get_metrics(reservID, addr, entry)
return json_reply(ret)
except Exception as e:
return json_error(e)
def update():
article = g.article
user = g.user
data = request.get_json()
form = ArticleForm(**data)
if form.validate():
form_data = form.data
data = form_data
data['ip'] = request.remote_addr
data['user'] = user
# Make sure that users cant change article status
try:
if not user.has_permission('approve_article'):
del data['is_active']
except Exception:
pass
article.update(**data)
cache.update_article(article.id, article)
return jsonify({"data": article.json_data()})
else:
return json_error(type="VALIDATION_FAILED", messages=form.errors)
