class AddHySDSIOType(Resource):
"""Add job spec"""
resp_model = api.model('HySDS IO Addition Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.String(required=True, description="HySDS IO ID")
})
parser = api.parser()
parser.add_argument('spec', required=True, type=str, help="HySDS IO JSON Object")
@api.expect(parser)
@api.marshal_with(resp_model)
def post(self):
'''
Add a HySDS IO specification
'''
try:
spec = request.form.get('spec',request.args.get('spec', None))
if spec is None:
raise Exception("'spec' must be supplied")
obj = json.loads(spec)
ident = hysds_commons.hysds_io_utils.add_hysds_io(app.config["ES_URL"], obj, logger=app.logger)
except Exception as e:
message = "Failed to add ES for HySDS IO. {0}:{1}".format(type(e),str(e))
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': ident }
def test_multiple_discriminator_field(self):
model = self.api.model(
'Test', {
'name': fields.String(discriminator=True),
'name2': fields.String(discriminator=True),
})
with self.assertRaises(ValueError):
self.api.marshal(object(), model)
def create_event(self):
requirement = self.api.model(
'Requirement', {
'name':
fields.String(required=True, description='Event name'),
'quantity':
fields.Integer(required=True, description='Name of event')
})
event = self.api.model(
'Event',
{
'tag':
fields.String(required=False, description='Tag of event'),
'name':
fields.String(required=True, description='Name of event'),
'date':
fields.String(required=True, description='Date of event'
), # Cambiar el type por lo que corresponde.
'time':
fields.String(required=False, description='Time of event'),
'capacity':
fields.String(required=False, description='Capacity of event'),
'venue':
fields.Nested(self.venueDocument.venue,
required=False,
description='Venue of event'),
'image':
fields.String(required=False, description='Image of event'),
'description':
fields.String(required=False,
description='Description of event'),
'visibility':
fields.String(required=True,
description='Visibility of event'),
'hasAssistance':
fields.Boolean(required=False, description=''),
'isOwner':
fields.Boolean(required=False, description=''),
'soldOut':
fields.Boolean(required=False, description=''),
'gests':
fields.List(fields.String(),
required=False,
description='Description of event'),
'requirementMissing':
fields.List(fields.Nested(requirement),
required=False,
description='Requirements missing'),
'requirement':
fields.List(fields.Nested(requirement),
required=False,
description='Requirements')
})
return event
class IndexDataset(Resource):
"""Dataset indexing API."""
resp_model = api.model(
'JsonResponse', {
'success':
fields.Boolean(
required=True,
description="if 'false', " +
"encountered exception; otherwise no errors " + "occurred"),
'message':
fields.String(
required=True,
description="message describing " + "success or failure"),
'objectid':
fields.String(required=True, description="ID of indexed dataset"),
'index':
fields.String(required=True, description="dataset index name"),
})
parser = api.parser()
parser.add_argument('dataset_info',
required=True,
type=str,
location='form',
help="HySDS dataset info JSON")
@api.marshal_with(resp_model)
@api.expect(parser, validate=True)
def post(self):
# get info
info = request.form.get('dataset_info',
request.args.get('dataset_info', None))
if info is not None:
try:
info = json.loads(info)
except Exception, e:
message = "Failed to parse dataset info JSON."
app.logger.debug(message)
return {
'success': False,
'message': message,
'job_id': None
}, 500
# update
try:
return updateDataset(info)
except Exception, e:
message = "Failed index dataset. {0}:{1}\n{2}".format(
type(e), e, traceback.format_exc())
app.logger.debug(message)
return {'success': False, 'message': message}, 500
def create_signup(self):
signup = self.api.model(
'Signup', {
'username': fields.String(required=True,
description='Username'),
'email': fields.String(required=True, description='Email'),
'firstName': fields.String(required=False,
description='FirstName'),
'lastName': fields.String(required=False,
description='LastName'),
'phone': fields.String(required=False, description='Phone'),
})
return signup
def create_venue(self):
venue = self.api.model(
'Venue', {
'name':
fields.String(required=True, description='Name of venue'),
'city':
fields.String(required=True, description='City of venue'),
'street':
fields.String(required=True, description='Street of venue'),
'country':
fields.String(required=True, description='Country of venue'),
})
return venue
class GetContainerAdd(Resource):
"""Add a container"""
resp_model = api.model('Container Add Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.String(required=True,description="Container ID")
})
parser = api.parser()
parser.add_argument('name', required=True, type=str, help="Container Name")
parser.add_argument('url', required=True, type=str, help="Container URL")
parser.add_argument('version', required=True, type=str, help="Container Version")
parser.add_argument('digest', required=True, type=str, help="Container Digest")
@api.expect(parser)
@api.marshal_with(resp_model)
def post(self):
'''
Add a container specification to Mozart
'''
try:
# get job id
print request.form
print request.args
name = request.form.get('name', request.args.get('name', None))
url = request.form.get('url', request.args.get('url', None))
version = request.form.get('version', request.args.get('version', None))
digest = request.form.get('digest', request.args.get('digest', None))
if name is None:
raise Exception("'name' must be supplied")
if url is None:
raise Exception("'url' must be supplied")
if version is None:
raise Exception("'version' must be supplied")
if digest is None:
raise Exception("'digest' must be supplied")
ident = hysds_commons.container_utils.add_container(app.config['ES_URL'],
name, url, version,
digest, logger=app.logger)
except Exception as e:
message = "Failed to add container {2}. {0}:{1}".format(type(e),str(e),name)
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': ident }
def test_string_field_with_enum(self):
field = fields.String(enum=['A', 'B', 'C'])
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'enum': ['A', 'B', 'C']
})
def test_string_field_with_readonly(self):
field = fields.String(readonly=True)
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'readOnly': True
})
def test_string_field_with_title(self):
field = fields.String(title='A title')
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'title': 'A title'
})
def test_string_field_with_description(self):
field = fields.String(description='A description')
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'description': 'A description'
})
def test_string_field_with_default(self):
field = fields.String(default='aaa')
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'default': 'aaa'
})
class BlockListResource(WigoResource):
model = Block
@user_token_required
@check_last_modified('user', 'last_block_change')
@api.response(200, 'Success')
def get(self, user_id, headers):
return g.user.get_blocked_ids(), 200, headers
@user_token_required
@api.expect(
api.model(
'NewBlock', {
'blocked_id':
fields.Integer(description='User to block', required=True),
'type':
fields.String(
description=
'The block type, "abusive" is only supported value')
}))
@api.response(200, 'Success')
def post(self, user_id):
block = Block()
block.user_id = g.user.id
block.blocked_id = self.get_id_field('blocked_id')
block.type = request.get_json().get('type')
block.save()
return {'success': True}
class Demo(Resource):
@api.doc(description='A demo HTTP GET',
responses={400: ("Bad request", api.model('Error', {"message": fields.String})),
500: "Unhandled exception (captured in server logs)"})
def get(self):
return 'This is a demo!', 200
@api.expect(api.model('Demo Request', {"data": fields.String(required=True)}))
@api.doc(description='A demo HTTP POST',
responses={400: ("Bad request", api.model('Error', {"message": fields.String})),
500: "Unhandled exception (captured in server logs)"})
@api.marshal_with(api.model(
'Demo Response',
{"id": fields.String(required=True), "data": fields.String(required=True)}), code=201)
def post(self):
return {'id': uuid4().hex, 'data': 'Created new demo resource'}, 201
class LayerTokenResource(WigoResource):
@user_token_required
@api.expect(api.model('Nonce', {
'nonce': fields.String(description='Nonce', required=True)
}))
def post(self):
user_id = g.user.id
nonce = request.get_json().get('nonce')
if not nonce:
abort(400, message='Nonce missing')
# Create identity token
# Make sure you have PyJWT and PyCrypto libraries installed and imported
id_token = jwt.encode(
payload={
'iss': PROVIDER_ID, # String - The Provider ID found in the Layer Dashboard
'prn': str(user_id), # String - Provider's internal ID for the authenticating user
'iat': datetime.now(), # Integer - Time of Token Issuance in RFC 3339 seconds
'exp': datetime.utcnow() + timedelta(seconds=30),
# Integer - Arbitrary Token Expiration in RFC 3339 seconds
'nce': nonce # The nonce obtained via the Layer client SDK.
},
key=RSA_KEY,
headers={
'typ': 'JWT', # String - Expresses a MIME Type of application/JWT
'alg': 'RS256', # String - Expresses the type of algorithm used to sign the token, must be RS256
'cty': 'layer-eit;v=1', # String - Express a Content Type of Layer External Identity Token, version 1
'kid': KEY_ID # String - Private Key associated with 'layer.pem', found in the Layer Dashboard
},
algorithm='RS256'
)
return {'token': id_token}
def test_discriminator_field(self):
model = self.api.model('Test', {
'name': fields.String(discriminator=True),
})
data = self.api.marshal(object(), model)
self.assertEqual(data, {'name': 'Test'})
class RemoveHySDSIOType(Resource):
"""Remove job spec"""
resp_model = api.model('HySDS IO Removal Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
})
parser = api.parser()
parser.add_argument('id', required=True, type=str, help="HySDS IO ID")
@api.expect(parser)
@api.marshal_with(resp_model)
def get(self):
'''
Remove HySDS IO for the given ID
'''
try:
ident = request.form.get('id',request.args.get('id', None))
hysds_commons.hysds_io_utils.remove_hysds_io(app.config["ES_URL"], ident, logger=app.logger)
except Exception as e:
message = "Failed to add ES for HySDS IO. {0}:{1}".format(type(e),str(e))
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': ""}
class GetJobSpecType(Resource):
"""Get list of job queues and return as JSON."""
resp_model = api.model('Job Type Specification Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.Raw(required=True, description="Job Type Specification")
})
parser = api.parser()
parser.add_argument('id', required=True, type=str, help="Job Type ID")
@api.expect(parser)
@api.marshal_with(resp_model)
def get(self):
'''
Gets a Job Type specification object for the given ID.
'''
try:
ident = request.form.get('id',request.args.get('id', None))
spec = hysds_commons.job_spec_utils.get_job_spec(app.config['ES_URL'], ident, logger=app.logger)
except Exception as e:
message = "Failed to query ES for Job spec. {0}:{1}".format(type(e),str(e))
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': spec }
class GetHySDSIOTypes(Resource):
"""Get list of registered hysds-io and return as JSON."""
resp_model_job_types = api.model('HySDS IO List Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.List(fields.String, required=True,
description="list of hysds-io types")
})
@api.marshal_with(resp_model_job_types)
def get(self):
'''
List HySDS IO specifications
'''
try:
ids = hysds_commons.hysds_io_utils.get_hysds_io_types(app.config["ES_URL"], logger=app.logger)
except Exception as e:
message = "Failed to query ES for HySDS IO types. {0}:{1}".format(type(e),str(e))
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': ids }
class GetJobs(Resource):
"""Get list of job IDs."""
resp_model = api.model('Jobs Listing Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.List(fields.String, required=True,
description="list of job IDs")
})
parser = api.parser()
parser.add_argument('page_size', required=False, type=str, help="Job Listing Pagination Size")
parser = api.parser()
parser.add_argument('offset', required=False, type=str, help="Job Listing Pagination Offset")
@api.marshal_with(resp_model)
def get(self):
'''
Paginated list submitted jobs
'''
try:
page_size = request.form.get('page_size', request.args.get('page_size', 100))
offset = request.form.get('offset', request.args.get('id', 0))
jobs = mozart.lib.job_utils.get_job_list(page_size,offset)
except Exception as e:
message = "Failed to get job listing(page: {2}, offset: {3}). {0}:{1}".format(type(e),str(e),page_size,offset)
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': jobs }
class GetContainerInfo(Resource):
"""Info a container"""
resp_model = api.model('Container Info Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.Raw(required=True,description="Container Info")
})
parser = api.parser()
parser.add_argument('id', required=True, type=str, help="Container ID")
@api.expect(parser)
@api.marshal_with(resp_model)
def get(self):
'''
Get information on container by ID
'''
try:
# get job id
ident = request.form.get('id', request.args.get('id', None))
info = hysds_commons.container_utils.get_container(app.config['ES_URL'], ident, logger=app.logger)
except Exception as e:
message = "Failed to get info for container {2}. {0}:{1}".format(type(e),str(e),ident)
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': info }
class GetJobInfo(Resource):
"""Get info of job IDs."""
resp_model = api.model('Job Info Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.Raw(required=True,description="Job Info Object")
})
parser = api.parser()
parser.add_argument('id', required=True, type=str, help="Job ID")
@api.expect(parser)
@api.marshal_with(resp_model)
def get(self):
'''
Get complete infor on submitted job based on id
'''
try:
# get job id
ident = request.form.get('id', request.args.get('id', None))
info = mozart.lib.job_utils.get_job_info(ident)
except Exception as e:
message = "Failed to get job info for {2}. {0}:{1}".format(type(e),str(e),ident)
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': info }
class GetQueueNames(Resource):
"""Get list of job queues and return as JSON."""
resp_model = api.model('Queue Listing Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false', " +
"encountered exception; otherwise no errors " +
"occurred"),
'message': fields.String(required=True, description="message describing " +
"success or failure"),
'result': fields.Raw(required=True, description="queue response")
})
parser = api.parser()
parser.add_argument('id', required=False, type=str, help="Job Type Specification ID")
@api.expect(parser)
@api.marshal_with(resp_model)
def get(self):
'''
Gets a listing of non-celery queues handling jobs.
'''
try:
ident = request.form.get('id',request.args.get('id', None))
queues = mozart.lib.queue_utils.get_queue_names(ident)
app.logger.warn("Queues:"+str(queues))
except Exception as e:
message = "Failed to list job queues. {0}:{1}".format(type(e),str(e))
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return { 'success': True,
'message': "",
'result': queues }
class QueryJson(Resource):
"""Get PROV-ES document by ID and return as JSON."""
resp_model = api.model('JsonResponse', {
'success': fields.Boolean(required=True, description="if 'false', encountered exception; otherwise no errors occurred"),
'message': fields.String(required=True, description="message describing success or failure"),
'result': fields.Raw(required=True, description="PROV-ES JSON document")
})
@api.doc(params={ 'id': 'ID of PROV-ES document'})
@api.marshal_with(resp_model)
def get(self):
id = request.args.get('id', None)
if id is None:
return { 'success': False,
'message': "Missing id parameter.",
'result': {} }, 400
# query
try: pej = get_prov_es_json(id)
except Exception, e:
message = "Failed to get PROV-ES document for id %s: %s" % (id, str(e))
current_app.logger.debug(message)
return { 'success': False,
'message': message,
'result': {} }, 500
# set message
if len(pej) == 0: message = "No document found with id %s." % id
else: message = ""
# return result
return { 'success': True,
'message': message,
'result': pej.get('_source', {}) }
class UserMetaResource(WigoResource):
model = User
@user_token_required
@api.response(200,
'Success',
model=api.model(
'UserMeta', {
'last_message_received': fields.DateTime(),
'last_friend_request': fields.DateTime(),
'last_notification': fields.DateTime(),
'is_tapped': fields.Boolean(),
'is_friend': fields.Boolean(),
'is_blocked': fields.Boolean(),
'attending_event_id': fields.Integer(),
'friend_request': fields.String(),
'num_friends_in_common': fields.Integer()
}))
def get(self, user_id):
user_id = self.get_id(user_id)
meta = {}
if user_id == g.user.id:
user_meta = wigo_db.get_redis().hgetall(
skey('user', user_id, 'meta'))
if user_meta:
def format_date(field):
return datetime.utcfromtimestamp(float(
user_meta[field])).isoformat()
if 'last_message_received' in user_meta:
meta['last_message_received'] = format_date(
'last_message_received')
if 'last_friend_request' in user_meta:
meta['last_friend_request'] = format_date(
'last_friend_request')
if 'last_notification' in user_meta:
meta['last_notification'] = format_date(
'last_notification')
meta['attending_event_id'] = g.user.get_attending_id()
else:
meta['is_tapped'] = g.user.is_tapped(user_id)
meta['is_friend'] = g.user.is_friend(user_id)
meta['is_blocked'] = g.user.is_blocked(user_id)
if g.user.is_friend_request_sent(user_id):
meta['friend_request'] = 'sent'
elif g.user.is_friend_request_received(user_id):
meta['friend_request'] = 'received'
if request.args.get('num_friends_in_common') == 'true':
meta['num_friends_in_common'] = len(
g.user.get_friend_ids_in_common(user_id))
meta['num_friends'] = wigo_db.get_sorted_set_size(
skey('user', user_id, 'friends'))
return meta
def create_requirement(self):
return self.api.model(
'Requirement', {
'name':
fields.String(required=True, description='Event name'),
'quantity':
fields.Integer(required=True, description='Name of event')
})
def test_with_callable_enum(self):
enum = lambda: ['A', 'B', 'C'] # noqa
field = fields.String(enum=enum)
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'enum': ['A', 'B', 'C'],
'example': 'A'
})
def test_with_enum(self):
enum = ['A', 'B', 'C']
field = fields.String(enum=enum)
self.assertFalse(field.required)
self.assertEqual(field.__schema__, {
'type': 'string',
'enum': enum,
'example': enum[0]
})
class GetJobStatus(Resource):
"""Get status of job ID."""
resp_model = api.model(
'Job Status Response(JSON)', {
'success':
fields.Boolean(
required=True,
description="if 'false', " +
"encountered exception; otherwise no errors " + "occurred"),
'message':
fields.String(
required=True,
description="message describing " + "success or failure"),
'status':
fields.String(required=True,
enum=[
'job-queued', 'job-started', 'job-failed',
'job-completed', 'job-offline', 'job-revoked'
],
description='job status')
})
parser = api.parser()
parser.add_argument('id', required=True, type=str, help="Job ID")
@api.expect(parser)
@api.marshal_with(resp_model)
def get(self):
'''
Gets the status of a submitted job based on job id
'''
try:
# get job id
ident = request.form.get('id', request.args.get('id', None))
status = mozart.lib.job_utils.get_job_status(ident)
except Exception as e:
message = "Failed to get job status for {2}. {0}:{1}".format(
type(e), str(e), ident)
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
# return result
return {'success': True, 'message': "", 'status': status}
class QueryTurtle(Resource):
"""Get PROV-ES document by ID and return as Turtle."""
resp_model = api.model('TurtleResponse', {
'success': fields.Boolean(required=True, description="if 'false', encountered exception; otherwise no errors occurred"),
'message': fields.String(required=True, description="message describing success or failure"),
'result': fields.String(required=True, description="PROV-ES Turtle document")
})
@api.doc(params={ 'id': 'ID of PROV-ES document'})
@api.marshal_with(resp_model)
def get(self):
id = request.args.get('id', None)
if id is None:
return { 'success': False,
'message': "Missing id parameter.",
'result': "" }, 400
# query
try: pej = get_prov_es_json(id)
except Exception, e:
message = "Failed to get PROV-ES document for id %s: %s" % (id, str(e))
current_app.logger.debug(message)
return { 'success': False,
'message': message,
'result': "" }, 500
# if no document found, return
if len(pej) == 0:
message = "No PROV-ES document found with id %s." % id
current_app.logger.debug(message)
return { 'success': False,
'message': message,
'result': "" }, 500
# convert PROV-ES JSON to turtle
try: ttl = get_ttl(pej['_source']['prov_es_json'])
except Exception, e:
message = "Failed to transform PROV-ES JSON document to Turtle for id %s: %s" % (id, str(e))
current_app.logger.debug(message)
return { 'success': False,
'message': message,
'result': "" }, 500
