def GET(self):
""" List all RSEs.
HTTP Success:
200 OK
HTTP Error:
400 Bad request
401 Unauthorized
404 Resource not Found
500 InternalError
:returns: A list containing all RSEs.
"""
header('Content-Type', 'application/x-json-stream')
params = input()
if 'expression' in params:
try:
for rse in parse_rse_expression(params['expression']):
item = {'rse': rse}
yield render_json(**item) + '\n'
except InvalidRSEExpression, e:
raise generate_http_error(400, 'InvalidRSEExpression', e)
except InvalidObject, e:
raise generate_http_error(400, 'InvalidObject', e[0][0])
def add_did(self, scope, name, type, statuses=None, meta=None, rules=None, lifetime=None):
"""
Add data identifier for a dataset or container.
:param scope: The scope name.
:param name: The data identifier name.
:paran type: The data identifier type (file|dataset|container).
:param statuses: Dictionary with statuses, e.g.g {'monotonic':True}.
:meta: Meta-data associated with the data identifier is represented using key/value pairs in a dictionary.
:rules: Replication rules associated with the data identifier. A list of dictionaries, e.g., [{'copies': 2, 'rse_expression': 'TIERS1'}, ].
:param lifetime: DID's lifetime (in seconds).
"""
path = '/'.join([self.DIDS_BASEURL, scope, name])
url = build_url(choice(self.list_hosts), path=path)
# Build json
data = {'type': type}
if statuses:
data['statuses'] = statuses
if meta:
data['meta'] = meta
if rules:
data['rules'] = rules
if lifetime:
data['lifetime'] = lifetime
r = self._send_request(url, type='POST', data=render_json(**data))
if r.status_code == codes.created:
return True
else:
exc_cls, exc_msg = self._get_exception(r.headers, r.status_code)
raise exc_cls(exc_msg)
def GET(self, account):
header('Content-Type', 'application/x-json-stream')
try:
for identity in list_identities(account):
yield render_json(**identity) + "\n"
except AccountNotFound, e:
raise generate_http_error(404, 'AccountNotFound', e.args[0][0])
def GET(self, scope, name):
""" get locks for a given scope, name.
HTTP Success:
200 OK
HTTP Error:
404 Not Found
500 InternalError
:returns: JSON dict containing informations about the requested user.
"""
header('Content-Type', 'application/x-json-stream')
did_type = None
if ctx.query:
params = parse_qs(ctx.query[1:])
if 'did_type' in params:
did_type = params['did_type'][0]
try:
if did_type == 'dataset':
for lock in get_dataset_locks(scope, name):
yield render_json(**lock) + '\n'
else:
raise InternalError('Wrong did_type specified')
except RucioException, e:
raise generate_http_error(500, e.__class__.__name__, e.args[0])
def GET(self, rse):
"""
Get RSE limits.
:param rse: the RSE name.
"""
header('Content-Type', 'application/json')
try:
limits = get_rse_limits(rse=rse, issuer=ctx.env.get('issuer'))
return render_json(**limits)
except RSENotFound, e:
raise generate_http_error(404, 'RSENotFound', e[0][0])
def GET(self, account):
""" get account information for given account name.
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
404 Not Found
406 Not Acceptable
500 InternalError
:param Rucio-Account: Account identifier.
:param Rucio-Auth-Token: as an 32 character hex string.
:returns: JSON dict containing informations about the requested user.
"""
header('Content-Type', 'application/json')
if account == 'whoami':
# Redirect to the account uri
frontend = ctx.env.get('HTTP_X_REQUESTED_HOST')
if frontend:
raise redirect(frontend + "/accounts/%s" %
(ctx.env.get('issuer')))
raise seeother(ctx.env.get('issuer'))
acc = None
try:
acc = get_account_info(account)
except AccountNotFound as error:
raise generate_http_error(404, 'AccountNotFound', error.args[0])
except AccessDenied as error:
raise generate_http_error(401, 'AccessDenied', error.args[0])
except RucioException as error:
raise generate_http_error(500, error.__class__.__name__,
error.args[0])
except Exception as error:
print(format_exc())
raise InternalError(error)
dict = acc.to_dict()
for key, value in dict.items():
if isinstance(value, datetime):
dict[key] = value.strftime('%Y-%m-%dT%H:%M:%S')
del dict['_sa_instance_state']
return render_json(**dict)
def import_data(self, data):
"""
Imports data into Rucio.
:param data: a dict containing data to be imported into Rucio.
"""
path = '/'.join([self.IMPORT_BASEURL])
url = build_url(choice(self.list_hosts), path=path)
r = self._send_request(url, type_='POST', data=render_json(**data))
if r.status_code == codes.created:
return r.text
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def get(self):
""" List all RSEs.
.. :quickref: RSEs; List all RSEs.
:query expression: The returned list only contains RSE matching this expression.
:resheader Content-Type: application/x-json-stream
:status 200: DIDs found.
:status 400: Invalid RSE Expression.
:status 401: Invalid Auth Token.
:status 500: Internal Error.
:returns: A list containing all RSEs.
"""
expression = request.args.get('name', None)
if expression:
try:
data = ""
for rse in parse_rse_expression(expression):
item = {'rse': rse}
data += render_json(**item) + '\n'
return Response(data, content_type="application/x-json-stream")
except InvalidRSEExpression as error:
return generate_http_error_flask(400, 'InvalidRSEExpression',
error.args[0])
except InvalidObject as error:
return generate_http_error_flask(400, 'InvalidObject',
error.args[0])
except RucioException as error:
return generate_http_error_flask(500, error.__class__.__name__,
error.args[0])
else:
data = ""
for rse in list_rses():
data += render_json(**rse) + '\n'
return Response(data, content_type="application/x-json-stream")
def get(self, account, rse_expression=None):
"""
---
summary: Get gloabl limit
description: Get the current gloabl limits for an account on a specific RSE expression.
tags:
- Account
parameters:
- name: account
in: path
description: The account identifier.
schema:
type: string
style: simple
- name: rse_expression
in: path
description: The rse identifier.
schema:
type: string
style: simple
responses:
200:
description: OK
content:
application/json:
schema:
description: Json object with rse expression as keys and limits in bytes as values.
type: object
401:
description: Invalid Auth Token
404:
description: RSE not found
406:
description: Not Acceptable
"""
try:
if rse_expression:
limits = get_global_account_limit(
account=account,
rse_expression=rse_expression,
vo=request.environ.get('vo'))
else:
limits = get_global_account_limits(
account=account, vo=request.environ.get('vo'))
except RSENotFound as error:
return generate_http_error_flask(404, error)
return Response(render_json(**limits), content_type="application/json")
def set_tombstone(self, replicas):
"""
Set a tombstone on a list of replicas.
:param replicas: list of replicas.
"""
url = build_url(self.host,
path='/'.join([self.REPLICAS_BASEURL, 'tombstone']))
data = {'replicas': replicas}
r = self._send_request(url, type='POST', data=render_json(**data))
if r.status_code == codes.created:
return True
exc_cls, exc_msg = self._get_exception(headers=r.headers,
status_code=r.status_code,
data=r.content)
raise exc_cls(exc_msg)
def get(self, rule_id):
""" get analysis for given rule.
.. :quickref: RuleAnalysis; analyse rule,
:resheader Content-Type: application/json
:status 200: Rule found
:status 406: Not Acceptable
:returns: JSON dict containing informations about the requested user.
"""
analysis = examine_replication_rule(
rule_id,
issuer=request.environ.get('issuer'),
vo=request.environ.get('vo'))
return Response(render_json(**analysis),
content_type='application/json')
def generate_http_error(status_code, exc_cls, exc_msg):
"""
utitily function to generate a complete HTTP error response.
:param status_code: The HTTP status code to generate a response for.
:param exc_cls: The name of the exception class to send with the response.
:param exc_msg: The error message.
:returns: a web.py HTTP response object.
"""
data, headers = _error_response(exc_cls, exc_msg)
try:
return HTTPError(status=codes[status_code],
headers=headers,
data=render_json(**data))
except Exception:
print(data)
raise
def get(self, scope, name):
"""
Returns the contents of a data identifier.
.. :quickref: Attachement; Get DID contents.
**Example request**:
.. sourcecode:: http
GET /dids/scope1/dataset1?dynamic HTTP/1.1
Host: rucio.cern.ch
**Example response**:
.. sourcecode:: http
HTTP/1.1 200 OK
Vary: Accept
Content-Type: application/json
{"scope": "scope1", "did_type": "DATASET", "name": "dataset1",
"bytes": 234, "length": 3, "account": "jdoe", "open": True,
"monotonic": False, "expired_at": null}
:query dynamic: Flag to dynamically calculate size for open DIDs
:resheader Content-Type: application/x-json-stream
:status 200: DID found
:status 401: Invalid Auth Token
:status 404: Scope not found
:status 406: Not Acceptable
:returns: Dictionary with DID metadata
"""
try:
data = ""
for did in list_content(scope=scope, name=name):
data += render_json(**did) + '\n'
return Response(data, content_type="application/x-json-stream")
except DataIdentifierNotFound as error:
return generate_http_error_flask(404, 'DataIdentifierNotFound',
error.args[0])
except RucioException as error:
return generate_http_error_flask(500, error.__class__.__name__,
error.args[0])
except Exception as error:
print(format_exc())
return error, 500
def get(self, account):
""" get account parameters for given account name.
.. :quickref: AccountParameter; Get account parameters.
:param account: The account identifier.
:status 200: OK.
:status 401: Invalid auth token.
:status 404: Account not found.
:status 406: Not Acceptable.
:status 500: Database exception.
:returns: JSON dict containing informations about the requested user.
"""
if account == 'whoami':
# Redirect to the account uri
frontend = request.environ.get('HTTP_X_REQUESTED_HOST')
if frontend:
return redirect(frontend + "/accounts/%s" %
(request.environ.get('issuer')),
code=302)
return redirect(request.environ.get('issuer'), code=303)
acc = None
try:
acc = get_account_info(account)
except AccountNotFound as error:
return generate_http_error_flask(404, 'AccountNotFound',
error.args[0])
except AccessDenied as error:
return generate_http_error_flask(401, 'AccessDenied',
error.args[0])
except RucioException as error:
return generate_http_error_flask(500, error.__class__.__name__,
error.args[0])
except Exception as error:
print(format_exc())
return error, 500
dict = acc.to_dict()
for key, value in dict.items():
if isinstance(value, datetime):
dict[key] = value.strftime('%Y-%m-%dT%H:%M:%S')
del dict['_sa_instance_state']
return Response(render_json(**dict), content_type="application/json")
def get(self, scope_name):
"""
Retrieve a single data identifier.
.. :quickref: DIDs; Retrieve a single DID.
**Example request**:
.. sourcecode:: http
GET /dids/scope1/dataset1?dynamic HTTP/1.1
Host: rucio.cern.ch
**Example response**:
.. sourcecode:: http
HTTP/1.1 200 OK
Vary: Accept
Content-Type: application/json
{"scope": "scope1", "did_type": "DATASET", "name": "dataset1",
"bytes": 234, "length": 3, "account": "jdoe", "open": True,
"monotonic": False, "expired_at": null}
:query dynamic: Flag to dynamically calculate size for open DIDs
:resheader Content-Type: application/json
:status 200: DID found
:status 401: Invalid Auth Token
:status 404: Scope not found
:status 406: Not Acceptable.
:returns: Dictionary with DID metadata
"""
try:
scope, name = parse_scope_name(scope_name,
request.environ.get('vo'))
dynamic = 'dynamic' in request.args
did = get_did(scope=scope,
name=name,
dynamic=dynamic,
vo=request.environ.get('vo'))
return Response(render_json(**did),
content_type='application/json')
except ValueError as error:
return generate_http_error_flask(400, error)
except (ScopeNotFound, DataIdentifierNotFound) as error:
return generate_http_error_flask(404, error)
def GET(self, rse):
"""
Get RSE limits.
:param rse: the RSE name.
"""
header('Content-Type', 'application/json')
try:
limits = get_rse_limits(rse=rse, issuer=ctx.env.get('issuer'), vo=ctx.env.get('vo'))
return render_json(**limits)
except RSENotFound as error:
raise generate_http_error(404, 'RSENotFound', error.args[0])
except RucioException as error:
raise generate_http_error(500, error.__class__.__name__, error.args[0])
except Exception as error:
print(format_exc())
raise InternalError(error)
def detach_dids(self, scope, name, dids):
"""
Detach data identifier
:param scope: The scope name.
:param name: The data identifier name.
:param dids: The content.
"""
path = '/'.join([self.DIDS_BASEURL, quote_plus(scope), quote_plus(name), 'dids'])
url = build_url(choice(self.list_hosts), path=path)
data = {'dids': dids}
r = self._send_request(url, type='DEL', data=render_json(**data))
if r.status_code == codes.ok:
return True
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def detach_dids(self, scope, name, dids):
"""
Detach data identifier
:param scope: The scope name.
:param name: The data identifier name.
:param dids: The content.
"""
path = '/'.join([self.DIDS_BASEURL, scope, name, 'dids'])
url = build_url(choice(self.list_hosts), path=path)
data = {'dids': dids}
r = self._send_request(url, type='DEL', data=render_json(**data))
if r.status_code == codes.ok:
return True
exc_cls, exc_msg = self._get_exception(r.headers, r.status_code)
raise exc_cls(exc_msg)
def GET(self, rse):
"""
Get RSE usage information.
:param rse: the RSE name.
"""
header('Content-Type', 'application/x-json-stream')
source = None
if ctx.query:
params = parse_qs(ctx.query[1:])
if 'source' in params:
source = params['source'][0]
try:
for usage in list_rse_usage_history(rse=rse, issuer=ctx.env.get('issuer'), source=source):
yield render_json(**usage) + '\n'
except RSENotFound, e:
raise generate_http_error(404, 'RSENotFound', e[0][0])
def GET(self, rse):
"""
Get RSE usage information.
:param rse: the RSE name.
"""
header('Content-Type', 'application/x-json-stream')
source = None
if ctx.query:
params = parse_qs(ctx.query[1:])
if 'source' in params:
source = params['source'][0]
try:
for usage in list_rse_usage_history(rse=rse, issuer=ctx.env.get('issuer'), source=source):
yield render_json(**usage) + '\n'
except RSENotFound, error:
raise generate_http_error(404, 'RSENotFound', error[0][0])
def GET(self):
""" Export data from Rucio.
HTTP Success:
200 OK
HTTP Error:
400 Bad request
401 Unauthorized
404 Resource not Found
406 Not Acceptable
500 InternalError
"""
header('Content-Type', 'application/json')
try:
return render_json(**export_data(issuer=ctx.env.get('issuer'), vo=ctx.env.get('vo')))
except RucioException as error:
raise generate_http_error(500, error.__class__.__name__, error.args[0])
def update_replicas_states(self, rse, files):
"""
Bulk update the file replicas states from a RSE.
:param rse: the RSE name.
:param files: The list of files. This is a list of DIDs like :
[{'scope': <scope1>, 'name': <name1>}, {'scope': <scope2>, 'name': <name2>}, ...]
:return: True if files have been deleted successfully.
"""
url = build_url(choice(self.list_hosts), path=self.REPLICAS_BASEURL)
data = {'rse': rse, 'files': files}
r = self._send_request(url, type='PUT', data=render_json(**data))
if r.status_code == codes.ok:
return True
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def GET(self, rse):
""" Details about a specific RSE.
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
404 Resource not Found
500 InternalError
:returns: A list containing all RSEs.
"""
header('Content-Type', 'application/json')
try:
rse_prop = get_rse(rse=rse)
return render_json(**rse_prop)
except RSENotFound, e:
raise generate_http_error(404, 'RSENotFound', e[0][0])
def GET(self, scope, name):
""" List all parents of a data identifier.
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
500 InternalError
:returns: A list of dictionary containing all dataset information.
"""
header('Content-Type', 'application/x-json-stream')
try:
for dataset in list_parent_dids(scope=scope, name=name):
yield render_json(**dataset) + "\n"
except DataIdentifierNotFound, error:
raise generate_http_error(404, 'DataIdentifierNotFound',
error.args[0][0])
def get(self, rule_id):
""" get rule information for given rule id.
.. :quickref: Rule; get rule info
:returns: JSON dict containing informations about the requested user.
:status 200: Rule found
:status 406: Not Acceptable
:status 410: Invalid Auth Token
:status 404: no rule found for id
"""
parameters = json_parameters(optional=True)
estimate_ttc = param_get(parameters, 'estimate_ttc', default=False)
try:
rule = get_replication_rule(rule_id, estimate_ttc=estimate_ttc, issuer=request.environ.get('issuer'), vo=request.environ.get('vo'))
except RuleNotFound as error:
return generate_http_error_flask(404, error)
return Response(render_json(**rule), content_type="application/json")
def GET(self, rse):
""" Details about a specific RSE.
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
404 Resource not Found
500 InternalError
:returns: A list containing all RSEs.
"""
header('Content-Type', 'application/json')
try:
rse_prop = get_rse(rse=rse)
return render_json(**rse_prop)
except RSENotFound, error:
raise generate_http_error(404, 'RSENotFound', error[0][0])
def add_replicas(self, rse, files, ignore_availability=True):
"""
Bulk add file replicas to a RSE.
:param rse: the RSE name.
:param files: The list of files. This is a list of DIDs like :
[{'scope': <scope1>, 'name': <name1>}, {'scope': <scope2>, 'name': <name2>}, ...]
:param ignore_availability: Ignore the RSE blacklisting.
:return: True if files were created successfully.
"""
url = build_url(choice(self.list_hosts), path=self.REPLICAS_BASEURL)
data = {'rse': rse, 'files': files, 'ignore_availability': ignore_availability}
r = self._send_request(url, type='POST', data=render_json(**data))
if r.status_code == codes.created:
return True
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def get(self, rule_id):
"""
---
summary: Return a Rule
tags:
- Rule
parameters:
- name: rule_id
in: path
description: The id of the replication rule.
schema:
type: string
style: simple
responses:
200:
description: OK
content:
application/json:
schema:
type: string
406:
description: Not Acceptable
401:
description: Invalid Auth Token
404:
description: No rule found for the given id
"""
parameters = json_parameters(optional=True)
estimate_ttc = param_get(parameters, 'estimate_ttc', default=False)
if estimate_ttc:
return generate_http_error_flask(
501,
"NotImplemented",
exc_msg="estimate_ttc is not implemented!")
try:
rule = get_replication_rule(rule_id,
issuer=request.environ.get('issuer'),
vo=request.environ.get('vo'))
except RuleNotFound as error:
return generate_http_error_flask(404, error)
return Response(render_json(**rule), content_type="application/json")
def get(self, rule_id):
""" get analysis for given rule.
.. :quickref: RuleAnalysis; analyse rule,
:resheader Content-Type: application/x-json-stream
:status 200: Rule found
:status 406: Not Acceptable
:status 500: Database Exception
:returns: JSON dict containing informations about the requested user.
"""
try:
analysis = examine_replication_rule(rule_id, issuer=request.environ.get('issuer'), vo=request.environ.get('vo'))
except RucioException as error:
return generate_http_error_flask(500, error.__class__.__name__, error.args[0])
except Exception as error:
return error, 500
return Response(render_json(**analysis), content_type="application/x-json-stream")
def get(self, rse):
""" Details about a specific RSE.
.. :quickref: RSE; get RSE details.
:param rse: the RSE name.
:resheader Content-Type: application/json
:status 200: OK.
:status 401: Invalid Auth Token.
:status 404: RSE not found.
:status 406: Not Acceptable.
:returns: A list containing all RSEs.
"""
try:
rse_prop = get_rse(rse=rse, vo=request.environ.get('vo'))
return Response(render_json(**rse_prop), content_type="application/json")
except RSENotFound as error:
return generate_http_error_flask(404, error)
def get(self, subscription_id):
"""
Retrieve a subscription matching the given subscription id
.. :quickref: SubscriptionId; Get a subscription by ID.
:param subscription_id: The subscription id.
:resheader Content-Type: application/json
:status 200: OK.
:status 401: Invalid Auth Token.
:status 404: Subscription Not Found.
:status 406: Not Acceptable.
:returns: dictionary with subscription information.
"""
try:
subscription = get_subscription_by_id(subscription_id, vo=request.environ.get('vo'))
except SubscriptionNotFound as error:
return generate_http_error_flask(404, error)
return Response(render_json(**subscription), content_type="application/json")
def get(self, rse):
""" Details about a specific RSE.
.. :quickref: RSE; get RSE details.
:param rse: the RSE name.
:resheader Content-Type: application/json
:status 200: OK.
:status 401: Invalid Auth Token.
:status 404: RSE not found.
:status 500: Internal Error.
:returns: A list containing all RSEs.
"""
try:
rse_prop = get_rse(rse=rse)
return Response(render_json(**rse_prop),
content_type="application/json")
except RSENotFound, error:
return generate_http_error_flask(404, 'RSENotFound', error.args[0])
def generate_http_error_flask(status_code, exc_cls, exc_msg, headers=None):
"""
utitily function to generate a complete HTTP error response.
:param status_code: The HTTP status code to generate a response for.
:param exc_cls: The name of the exception class to send with the response.
:param exc_msg: The error message.
:returns: a Flask HTTP response object.
:param headers: any default headers to send along.
"""
data, prioheaders = _error_response(exc_cls, exc_msg)
headers = Headers(headers)
headers.extend(prioheaders)
try:
return Response(status=status_code,
headers=headers,
content_type=prioheaders['Content-Type'],
response=render_json(**data))
except Exception:
print(data)
raise
def attach_dids(self, scope, name, dids, rse=None):
"""
Attach data identifier.
:param scope: The scope name.
:param name: The data identifier name.
:param dids: The content.
:param rse: The RSE name when registering replicas.
"""
path = '/'.join([self.DIDS_BASEURL, quote_plus(scope), quote_plus(name), 'dids'])
url = build_url(choice(self.list_hosts), path=path)
data = {'dids': dids}
if rse:
data['rse'] = rse
r = self._send_request(url, type='POST', data=render_json(**data))
if r.status_code == codes.created:
return True
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def get(self, rse):
"""
Get RSE limits.
.. :quickref: Limits; Get RSE limits.
:param rse: the RSE name.
:resheader Content-Type: application/json
:status 200: OK.
:status 401: Invalid Auth Token.
:status 404: RSE Not Found.
:status 406: Not Acceptable.
:returns: List of dictionaries with RSE limits.
"""
try:
limits = get_rse_limits(rse=rse, issuer=request.environ.get('issuer'), vo=request.environ.get('vo'))
return Response(render_json(**limits), content_type="application/json")
except RSENotFound as error:
return generate_http_error_flask(404, error)
def attach_dids(self, scope, name, dids, rse=None):
"""
Attach data identifier.
:param scope: The scope name.
:param name: The data identifier name.
:param dids: The content.
:param rse: The RSE name when registering replicas.
"""
path = '/'.join([self.DIDS_BASEURL, scope, name, 'dids'])
url = build_url(choice(self.list_hosts), path=path)
data = {'dids': dids}
if rse:
data['rse'] = rse
r = self._send_request(url, type='POST', data=render_json(**data))
if r.status_code == codes.created:
return True
else:
exc_cls, exc_msg = self._get_exception(r.headers, r.status_code)
raise exc_cls(exc_msg)
def get(self):
""" list all rucio accounts.
.. :quickref: Account; List all accounts.
:resheader Content-Type: application/x-json-stream
:status 200: OK.
:status 401: Invalid auth token.
:status 500: Database exception
:returns: A list containing all account names as dict.
"""
filter = {}
for k, v in request.args.items():
filter[k] = v
data = ""
for account in list_accounts(filter=filter):
data += render_json(**account) + "\n"
return Response(data, content_type="application/x-json-stream")
def GET(self):
""" list all rucio accounts.
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
500 InternalError
:param Rucio-Account: Account identifier.
:param Rucio-Auth-Token: as an 32 character hex string.
:returns: A list containing all account names as dict.
"""
header('Content-Type', 'application/x-json-stream')
filter = {}
if ctx.query:
filter = dict(parse_qsl(ctx.query[1:]))
for account in list_accounts(filter=filter):
yield render_json(**account) + "\n"
def GET(self):
""" list all rucio accounts.
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
500 InternalError
:param Rucio-Account: Account identifier.
:param Rucio-Auth-Token: as an 32 character hex string.
:returns: A list containing all account names as dict.
"""
header('Content-Type', 'application/x-json-stream')
filter = {}
if ctx.query:
filter = dict(parse_qsl(ctx.query[1:]))
for account in list_accounts(filter=filter):
yield render_json(**account) + "\n"
def GET(self, rule_id):
""" get analysis for given rule.
HTTP Success:
200 OK
HTTP Error:
404 Not Found
500 InternalError
:returns: JSON dict containing informations about the requested user.
"""
header('Content-Type', 'application/x-json-stream')
try:
analysis = examine_replication_rule(rule_id)
except RucioException as error:
raise generate_http_error(500, error.__class__.__name__, error.args[0])
except Exception as error:
raise InternalError(error)
return render_json(**analysis)
header('Content-Type', 'application/x-json-stream')
params = input()
if 'expression' in params:
try:
for rse in parse_rse_expression(params['expression']):
item = {'rse': rse}
yield render_json(**item) + '\n'
except InvalidRSEExpression, e:
raise generate_http_error(400, 'InvalidRSEExpression', e)
except InvalidObject, e:
raise generate_http_error(400, 'InvalidObject', e[0][0])
except RucioException, e:
raise generate_http_error(500, e.__class__.__name__, e.args[0][0])
else:
for rse in list_rses():
yield render_json(**rse) + '\n'
class RSE(RucioController):
""" Create, update, get and disable RSE. """
def POST(self, rse):
""" Create RSE with given name.
HTTP Success:
201 Created
HTTP Error:
400 Bad request
401 Unauthorized
500 Internal Error
404 Not Found
500 InternalError
:returns: JSON dict containing informations about the requested user.
"""
header('Content-Type', 'application/json')
try:
rule = get_replication_rule(rule_id)
except RuleNotFound, e:
raise generate_http_error(404, 'RuleNotFound', e.args[0][0])
except RucioException, e:
raise generate_http_error(500, e.__class__.__name__, e.args[0])
except Exception, e:
raise InternalError(e)
return render_json(**rule)
def PUT(self, rule_id):
"""
Update the replication rules locked flag .
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
404 Not Found
500 InternalError
"""
json_data = data()
try:
Retrieve a subscription matching the given subscription id
HTTP Success:
200 OK
HTTP Error:
401 Unauthorized
404 Not Found
"""
header('Content-Type', 'application/json')
try:
subscription = get_subscription_by_id(subscription_id)
except SubscriptionNotFound, e:
raise generate_http_error(404, 'SubscriptionNotFound', e.args[0][0])
except RucioException, e:
raise generate_http_error(500, e.__class__.__name__, e.args[0])
except Exception, e:
raise InternalError(e)
return render_json(**subscription)
"""----------------------
Web service startup
----------------------"""
app = application(urls, globals())
app.add_processor(loadhook(rucio_loadhook))
application = app.wsgifunc()
raise generate_http_error(401, 'AccessDenied', e.args[0][0])
except RucioException, e:
raise generate_http_error(500, e.__class__.__name__, e.args[0][0])
except Exception, e:
print format_exc()
raise InternalError(e)
dict = acc.to_dict()
for key, value in dict.items():
if isinstance(value, datetime):
dict[key] = value.strftime('%Y-%m-%dT%H:%M:%S')
del dict['_sa_instance_state']
return render_json(**dict)
def PUT(self, account):
""" update account informations for given account name """
raise BadRequest()
def POST(self, account):
""" create account with given account name.
HTTP Success:
201 Created
HTTP Error:
400 Bad Reqeust
401 Unauthorized
409 Conflict
