def before_request():
request_param = {key.lower(): value for key, value in request.environ.items()
if key in ('CONTENT_TYPE', 'CONTENT_LENGTH', 'HTTP_HOST',
'HTTP_ACCEPT', 'HTTP_ACCEPT_ENCODING', 'HTTP_COOKIE',
'HTTP_USER_AGENT', 'PATH_INFO', 'QUERY_STRING',
'SERVER_PROTOCOL', 'REQUEST_METHOD', 'HTTP_HOST',
'SERVER_PORT', 'SERVER_SOFTWARE', 'REMOTE_ADDR',
'REMOTE_PORT', 'HTTP_ACCEPT_LANGUAGE')}
g.request_raw_data = request.get_data().decode('utf8')
g.request_time = datetime.now()
g.api_method = request.args['method']
g.api_version = request.args['v']
g.request_param = request_param
g.request_form = request.form.to_dict() if request.form else None
try:
g.request_json = request.get_json() if request.is_json else None
except Exception:
raise ApiSysExceptions.invalid_json
python类is_json()的实例源码
def update_payments(id):
try:
if not request.is_json:
raise DataValidationError('Invalid payment: Content Type is not json')
data = request.get_json(silent=True)
message = payment_service.update_payment(id,payment_replacement=data)
rc = status.HTTP_200_OK
except PaymentNotFoundError as e:
message = e.message
rc = status.HTTP_404_NOT_FOUND
except DataValidationError as e:
message = e.message
rc = status.HTTP_400_BAD_REQUEST
return make_response(jsonify(message), rc)
######################################################################
# UPDATE AN EXISTING PAYMENT PARTIALLY
######################################################################
def update_partial_payments(id):
try:
if not request.is_json:
raise DataValidationError('Invalid payment: Content Type is not json')
data = request.get_json(silent=True)
message = payment_service.update_payment(id,payment_attributes=data)
rc = status.HTTP_200_OK
except PaymentNotFoundError as e:
message = e.message
rc = status.HTTP_404_NOT_FOUND
except DataValidationError as e:
message = e.message
rc = status.HTTP_400_BAD_REQUEST
return make_response(jsonify(message), rc)
######################################################################
# DELETE A PAYMENT
######################################################################
def charge_payment(user_id):
try:
if not request.data:
raise DataValidationError('Invalid request: body of request contained no data')
if not request.is_json:
raise DataValidationError('Invalid request: request not json')
data = request.get_json()
if data['amount']:
if(data['amount'] < 0):
raise DataValidationError('Invalid request: Order amount is negative.')
else:
resp = payment_service.perform_payment_action(user_id,payment_attributes=data)
if resp == True:
message = {'success' : 'Default payment method for user_id: %s has been charged $%.2f' % (str(user_id), data['amount'])}
rc = status.HTTP_200_OK
except DataValidationError as e:
message = {'error' : e.message}
rc = status.HTTP_400_BAD_REQUEST
except KeyError as e:
message = {'error' : 'Invalid request: body of request does not have the amount to be charged'}
rc = status.HTTP_400_BAD_REQUEST
return make_response(jsonify(message), rc)
def get_json_arg(name, parser=None, validator=None):
jdata = request.get_json(force=True, silent=True)
if not request.is_json:
raise APIError(ret=1, msg='????????')
if jdata is None:
raise APIError(ret=1, msg='????????')
val = jdata.get(name, None)
if val is None:
raise APIError(ret=1, msg='????:{}'.format(name))
if parser and callable(parser):
try:
val = parser(val)
except Exception as e:
raise APIError(ret=1, msg='????:{}??'.format(name))
if validator and callable(validator):
if not validator(val):
raise APIError(ret=1, msg='??:{}???'.format(name))
return val
def get_json_arg_default(name, default=None, parser=None, validator=None):
jdata = request.get_json(force=True, silent=True)
if not request.is_json:
raise APIError(ret=1, msg='????????')
if jdata is None:
raise APIError(ret=1, msg='????????')
val = jdata.get(name, None)
if val is None:
if default is not None:
return default
raise APIError(ret=1, msg='????:{}'.format(name))
if parser and callable(parser):
try:
val = parser(val)
except Exception as e:
raise APIError(ret=1, msg='????:{}??'.format(name))
if validator and callable(validator):
if not validator(val):
raise APIError(ret=1, msg='??:{}???'.format(name))
return val
def save_topology(name):
"""Save a topology layout in a file.
This method get a json topology from request and puts this in a file.
Parameters:
name (string): name of the topology to be saved or loaded.
Returns:
topology (string): topology using json format.
"""
if not request.is_json:
return json.dumps('{"error": "gt was not a JSON request"}'), 400
topology = request.get_json()
with open(join(settings.TOPOLOGY_DIR, name + '.json'), 'w') as outfile:
json.dump(topology, outfile)
return json.dumps({'response': 'Saved'}), 201
def login():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username:
return jsonify({"msg": "Missing username parameter"}), 400
if not password:
return jsonify({"msg": "Missing password parameter"}), 400
if username != 'test' or password != 'test':
return jsonify({"msg": "Bad username or password"}), 401
# Identity can be any data that is json serializable
access_token = create_access_token(identity=username)
return jsonify(access_token=access_token), 200
# Protect a view with jwt_required, which requires a valid access token
# in the request to access.
def login():
"""Authenticate user and return token
"""
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username or not password:
return jsonify({"msg": "Missing username or password"}), 400
user = User.query.filter_by(username=username).first()
if user is None or not pwd_context.verify(password, user.password):
return jsonify({"msg": "Bad credentials"}), 400
access_token = create_access_token(identity=user.id)
refresh_token = create_refresh_token(identity=user.id)
ret = {
'access_token': access_token,
'refresh_token': refresh_token
}
return jsonify(ret), 200
def process_image():
try:
assert request.is_json
assert 'imageUrl' in request.json
image_url = request.json['imageUrl']
trusted_source_url, trusted_source_image = None, None
trusted_data = check_url(image_url)
if trusted_data is not None and 'image_url' in trusted_data:
trusted_source_image = trusted_data.image_url
trusted_source_url = trusted_data.url
result = {
'status': STATUS_OK,
'trusted_source_url': trusted_source_url,
'trusted_source_image': trusted_source_image,
'source_url': image_url
}
return jsonify(result)
except AssertionError:
return make_response(jsonify({'status': STATUS_ERROR, 'message': 'malformed request'}), 400)
def set_default(user_id):
try:
if not request.data:
raise DataValidationError('Invalid request: body of request contained no data')
if not request.is_json:
raise DataValidationError('Invalid request: request not json')
data = request.get_json()
if data['payment_id']:
resp = payment_service.perform_payment_action(user_id,payment_attributes=data)
if resp == True:
message = { 'success' : 'Payment with id: %s set as default for user with user_id: %s.' % (data['payment_id'], str(user_id)) }
rc = status.HTTP_200_OK
else:
message = { 'error' : 'No Payment with id: %s was found for user with user_id: %s.' % (data['payment_id'], str(user_id)) }
rc = status.HTTP_404_NOT_FOUND
except DataValidationError as e:
message = {'error' : e.message}
rc = status.HTTP_400_BAD_REQUEST
except KeyError as e:
message = {'error' : 'Invalid request: body of request does not have the payment_id'}
rc = status.HTTP_400_BAD_REQUEST
return make_response(jsonify(message), rc)
######################################################################
# RETRIEVE A PAYMENT
######################################################################
def get_http_info(self):
"""
Determine how to retrieve actual data, basically if it's JSON or not.
"""
try:
is_json = request.is_json
except AttributeError:
is_json = request.get_json(silent=True) is not None
if is_json:
retriever = Breathalyzer.get_json_data
else:
retriever = Breathalyzer.get_form_data
return self.get_http_info_with_retriever(retriever)
def is_json(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not request.is_json:
return jsonify(error=True,
status=400,
message='Content-Type should be application/json')
return f(*args, **kwargs)
return decorated_function
def request_from_github(abort_code=418):
def decorator(f):
"""
Decorator that checks if a request is a GitHub hook request
"""
@wraps(f)
def decorated_function(*args, **kwargs):
if request.method != 'POST':
return 'OK'
else:
# Do initial validations on required headers
if 'X-Github-Event' not in request.headers:
abort(abort_code)
if 'X-Github-Delivery' not in request.headers:
abort(abort_code)
if 'X-Hub-Signature' not in request.headers:
abort(abort_code)
if not request.is_json:
abort(abort_code)
if 'User-Agent' not in request.headers:
abort(abort_code)
ua = request.headers.get('User-Agent')
if not ua.startswith('GitHub-Hookshot/'):
abort(abort_code)
request_ip = ip_address(u'{0}'.format(request.remote_addr))
meta_json = requests.get('https://api.github.com/meta').json()
hook_blocks = meta_json['hooks']
# Check if the POST request is from GitHub
for block in hook_blocks:
if ip_address(request_ip) in ip_network(block):
break
else:
g.log.info("Unauthorized attempt to deploy by IP %s" %
request_ip)
abort(abort_code)
return f(*args, **kwargs)
return decorated_function
return decorator
def with_json_request(func):
@wraps(func)
def dec(*args, **kwargs):
if not request.is_json:
return 'Bad json request', 400
return func(*args, **kwargs)
return dec
def get_items(slugs):
if slugs:
items_list = slugs.split(',')
elif request.is_json:
items_list = request.get_json()
# Check if there are items from ugc collection and test their access control
ugc_items = []
for item in items_list:
if item.startswith('ugc'):
ugc_items.append(item)
user_oid = current_user.is_authenticated and current_user.id
items = fetch_items(items_list)
if len(items) == 1 and 'error_code' in items[0]:
error = items[0]
abort(error['error_code'], error['msg'])
else:
# Cast items to list
if type(items) != list:
items = [items]
# Check that each of the ugc_items is accessible by the logged in user
for ugc_item_id in [i[4:] for i in ugc_items]:
for item in items:
if item['_id'] == ugc_item_id and item.has_key('owner') and item['owner'] != unicode(user_oid):
abort(403, 'You are not authorized to access item ugc.{}'.format(str(item['_id'])))
return humanify(items)
def test_instance_attachment_collection_service(test_id):
resp = flask.Response(json.dumps({'status': 'failed'}))
if request.method == 'POST':
if request.is_xhr:
file = request.files['attachments']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
dirpath = os.path.join(UPLOAD_FOLDER, str(test_id), 'attachments')
os.makedirs(dirpath, exist_ok=True)
filepath = os.path.join(dirpath, filename)
file.save(filepath)
# db: update the attachment for the test where test.id = test_id
test = Test.query.get(test_id)
test.test_attachment.append(TestAttachment(name=filename, attachment_url=filepath))
db.session.commit()
resp = flask.Response(json.dumps({'status': 'success', 'url': filepath}))
elif request.method == 'DELETE':
if request.is_json:
filename = secure_filename(request.json['removedFile'])
dirpath = os.path.join(UPLOAD_FOLDER, str(test_id), 'attachments')
filepath = os.path.join(dirpath, filename)
try:
os.remove(filepath)
# db: delete the attachment for the test where test.id = test_id
TestAttachment.query.filter(
(TestAttachment.test_id == test_id) &
(TestAttachment.name == filename)
).delete()
db.session.commit()
resp = flask.Response(json.dumps({'status': 'success', 'url': filepath}))
except FileNotFoundError:
print('FileNotFound: ', filepath)
resp = flask.Response(json.dumps({'status': 'failed', 'url': filepath}))
return set_debug_response_header(resp)
def formulation_instance_service(f_id):
resp = flask.Response(json.dumps({'status': 'failed'}))
if request.method == 'PUT':
if request.is_json:
p_json_list = request.json['properties']
formulation = Formulation.query.get(f_id)
formulation.formulation_property.delete()
# fp_rs = Formulation.query.get(f_id).formulation_property
# FormulationProperty.query.filter(FormulationProperty.formulation_id == f_id).delete()
for p in p_json_list:
formulation.formulation_property.append(FormulationProperty(
key=p['keyName'],
value=p['valueName']
))
db.session.commit()
p_list = []
for p in formulation.formulation_property:
p_list.append({p.key: p.value})
resp = flask.Response(json.dumps({'status': 'success',
'formulation_id': formulation.id,
'formulation_properties': p_list}))
elif request.method == 'DELETE':
formulation = Formulation.query.get(f_id)
test_count = formulation.test.count()
if test_count > 0:
resp = flask.Response(json.dumps({'status': 'failed',
'error': 'the tests count of formulation id %d is not 0, '
'delete tests first'}))
else:
Formulation.query.filter(Formulation.id == f_id).delete()
db.session.commit()
return set_debug_response_header(resp)
def process_text():
try:
assert request.is_json
tweet = request.json['text'] if 'text' in request.json else None
url = request.json['pageUrl'] if 'pageUrl' in request.json else None
share, total_engaged, resource_trust = None, None, None
if url:
comments, reaction, share, total_engaged = check_virality(url)
resource_trust = check_info_source(url)
analysis_result = None
if tweet:
tweet = tweet if len(tweet) < 1000 else tweet[:1000]
analysis_result = compare_tweet_with_storage(tweet)
result = {
'status': STATUS_OK,
'data': {
'credibility': analysis_result,
'engaged': total_engaged,
'shares': share,
'site_credibility': resource_trust
},
'source_text': tweet
}
return jsonify(result)
except AssertionError:
return make_response(jsonify({'status': STATUS_ERROR, 'message': 'malformed request'}), 400)
# except:
# return make_response(jsonify({'status': STATUS_ERROR, 'message': 'oops...'}), 500)
def json_required(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not request.is_json:
abort(400, "JSON Required")
return f(*args, **kwargs)
return decorated_function
def post(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
"""
A post request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
will create a chain between two interfaces at the specified vnfs.
The POST data contains the path like this.
{ "path": ["dc1.s1", "s1", "dc4.s1"]}
path specifies the destination vnf and interface and contains a list of switches
that the path traverses. The path may not contain single hop loops like:
[s1, s2, s1].
This is a limitation of Ryu, as Ryu does not allow the `INPUT_PORT` action!
:param src_vnf: Name of the source VNF
:type src_vnf: ``str``
:param src_intfs: Name of the source VNF interface to chain on
:type src_intfs: ``str``
:param dst_vnf: Name of the destination VNF
:type dst_vnf: ``str``
:param dst_intfs: Name of the destination VNF interface to chain on
:type dst_intfs: ``str``
:return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
501 if one of the VNF / intfs does not exist
:rtype: :class:`flask.Response`
"""
if request.is_json:
path = request.json.get('path')
layer2 = request.json.get('layer2', True)
else:
path = None
layer2 = True
# check if both VNFs exist
if not self.api.manage.check_vnf_intf_pair(src_vnf, src_intfs):
return Response(u"VNF %s or intfs %s does not exist" % (src_vnf, src_intfs), status=501,
mimetype="application/json")
if not self.api.manage.check_vnf_intf_pair(dst_vnf, dst_intfs):
return Response(u"VNF %s or intfs %s does not exist" % (dst_vnf, dst_intfs), status=501,
mimetype="application/json")
try:
cookie = self.api.manage.network_action_start(src_vnf, dst_vnf, vnf_src_interface=src_intfs,
vnf_dst_interface=dst_intfs, bidirectional=True,
path=path, layer2=layer2)
resp = {'cookie': cookie}
return Response(json.dumps(resp), status=200, mimetype="application/json")
except Exception as e:
logging.exception(u"%s: Error setting up the chain.\n %s" % (__name__, e))
return Response(u"Error setting up the chain", status=500, mimetype="application/json")
def post(self, src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs):
"""
A post request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
will create a chain between two interfaces at the specified vnfs.
The POST data contains the path like this.
{ "path": ["dc1.s1", "s1", "dc4.s1"]}
path specifies the destination vnf and interface and contains a list of switches
that the path traverses. The path may not contain single hop loops like:
[s1, s2, s1].
This is a limitation of Ryu, as Ryu does not allow the `INPUT_PORT` action!
:param src_vnf: Name of the source VNF
:type src_vnf: ``str``
:param src_intfs: Name of the source VNF interface to chain on
:type src_intfs: ``str``
:param dst_vnf: Name of the destination VNF
:type dst_vnf: ``str``
:param dst_intfs: Name of the destination VNF interface to chain on
:type dst_intfs: ``str``
:return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
501 if vnf / intfs do not exist
:rtype: :class:`flask.Response`
"""
if request.is_json:
path = request.json.get('path')
layer2 = request.json.get('layer2', True)
else:
path = None
layer2 = True
# search for real names
real_names = self._findNames(src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
if type(real_names) is not tuple:
# something went wrong
return real_names
container_src, container_dst, interface_src, interface_dst = real_names
try:
cookie = self.api.manage.network_action_start(container_src, container_dst, vnf_src_interface=interface_src,
vnf_dst_interface=interface_dst, bidirectional=True,
path=path, layer2=layer2)
resp = {'cookie': cookie}
return Response(json.dumps(resp), status=200, mimetype="application/json")
except Exception as e:
logging.exception(u"%s: Error setting up the chain.\n %s" % (__name__, e))
return Response(u"Error setting up the chain", status=500, mimetype="application/json")
def start_trex():
if request.method == 'POST':
if request.is_json:
req_data = request.get_json(cache=False)
if req_data is not None:
try:
traffic_config = {
"pps": int(req_data['input']['pps'].encode("ascii")),
"src_n": int(req_data['input']['src_n'].encode("ascii")),
"pkts_n": int(req_data['input']['pkts_n'].encode("ascii")),
"mac_dest": req_data['input']['mac_dest'].encode("ascii"),
"packet_size": int(req_data['input']['packet_size'].encode("ascii")),
"mult": int(req_data['input']['mult'].encode("ascii")),
}
if traffic_config["pps"] > 0 and traffic_config["mac_dest"]:
"""If # of PPS or MAC addresses is positive"""
if not Trex.is_running():
try:
start_traffic(traffic_config)
except:
import traceback
print "exception", traceback.format_exc()
return responsify('error', get_error_message('trex_not_start'))
return responsify('ok', 'start')
else:
return responsify('error', get_error_message('trex_already_running'))
else:
"""Stop TRex if 0 PPS or MAC addresses received"""
stop_trex(True)
return responsify('error', get_error_message('pps_must_be_positive'))
except (AttributeError, KeyError):
return responsify('error', get_error_message('not_json'))
except ValueError:
return responsify('error', get_error_message('ascii_error'))
else:
return responsify('error', get_error_message('not_json'))
else:
return responsify('error', get_error_message('not_json'))
else:
return responsify("ok", "ok")
# Stop sending traffic
def test_collection_service():
resp = flask.Response(json.dumps({'status': 'failed'}))
if request.method == 'GET':
if request.args.get('formulationID'):
formulation_id = request.args['formulationID']
test_list = []
test_rs = Formulation.query.get(formulation_id).test
for test_r in test_rs:
test_list.append({
'id': test_r.id,
'name': test_r.name,
'measure_type': test_r.measure_type,
'thickness': test_r.thickness,
'temperature_max': test_r.temperature_max,
'temperature_min': test_r.temperature_min,
'frequency_max': test_r.frequency_max,
'frequency_min': test_r.frequency_min,
'test_type': test_r.test_type,
'data_file_url': test_r.data_file_url,
'date': test_r.date.timestamp(),
'formulation_id': test_r.formulation_id,
})
resp = flask.Response(json.dumps({'status': 'success', 'test_list': test_list}))
elif request.method == 'POST':
if request.is_json:
temperature, temperature_min, temperature_max = 0, 0, 0
frequency, frequency_min, frequency_max = 0, 0, 0
measure_type = request.json['measureType']
date_ts = request.json.pop('date', datetime.now().timestamp())
if measure_type == 'temperature':
frequency_min = frequency_max = request.json['frequencyMin']
temperature_min = request.json['temperatureMin']
temperature_max = request.json['temperatureMax']
elif measure_type == 'frequency':
temperature_min = temperature_max = request.json['temperatureMin']
frequency_min = request.json['frequencyMin']
frequency_max = request.json['frequencyMax']
test = Test(name=request.json['name'],
measure_type=measure_type,
thickness=request.json['thickness'],
temperature_max=temperature_max,
temperature_min=temperature_min,
frequency_max=frequency_max,
frequency_min=frequency_min,
test_type=request.json['testType'],
formulation_id=request.json['selectedFormulationID'],
date=datetime.fromtimestamp(date_ts))
db.session.add(test)
db.session.commit()
resp = flask.Response(json.dumps({'status': 'success',
'test_id': test.id,
'test_name': test.name}))
return set_debug_response_header(resp)
def formulation_collection_service():
resp = flask.Response(json.dumps({'status': 'failed'}))
if request.method == 'GET':
formulations = []
formulations_rs = Formulation.query.all()
for formulation_r in formulations_rs:
formulation_properties = []
formulations_property_rs = formulation_r.formulation_property.all()
for formulations_property_r in formulations_property_rs:
formulation_properties.append({formulations_property_r.key: formulations_property_r.value})
formulations.append({
'id': formulation_r.id,
'name': formulation_r.name,
'date': formulation_r.date.timestamp(),
'formulation_properties': formulation_properties
})
resp = flask.Response(json.dumps({'status': 'success', 'formulations': formulations}))
elif request.method == 'POST':
if request.is_json:
req_json = request.json
property_list, property_key_list = [], []
name = req_json.pop('formulationName', 'formulation-%f' % datetime.now().timestamp())
date_ts = req_json.pop('formulationDate', datetime.now().timestamp())
property_key_list = [x for x in req_json if x.startswith('key-')]
property_key_list.sort(key=lambda x: int(x.replace('key-', '')))
for fpkey in property_key_list:
key = req_json[fpkey]
val = req_json['value-%s' % fpkey.split('-', maxsplit=1)[1]]
property_list.append((key, val))
# create new formulation in db
formulation = Formulation(name=name, date=datetime.fromtimestamp(date_ts))
db.session.add(formulation)
db.session.commit()
for fpkey, fpval in property_list:
formulation.formulation_property.append(FormulationProperty(key=fpkey, value=fpval))
db.session.commit()
resp = flask.Response(json.dumps({'status': 'success',
'new_formulation_id': formulation.id,
'new_formulation_name': formulation.name}))
return set_debug_response_header(resp)
