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, 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