rucio 35.7.0__py3-none-any.whl

rucio/web/rest/flaskapi/v1/dirac.py

@@ -0,0 +1,116 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from flask import Flask, request
+
+from rucio.common.exception import AccessDenied, DatabaseException, DataIdentifierAlreadyExists, Duplicate, InvalidPath, ResourceTemporaryUnavailable, RSENotFound, UnsupportedOperation
+from rucio.common.utils import parse_response
+from rucio.gateway.dirac import add_files
+from rucio.web.rest.flaskapi.authenticated_bp import AuthenticatedBlueprint
+from rucio.web.rest.flaskapi.v1.common import ErrorHandlingMethodView, generate_http_error_flask, json_parameters, param_get, response_headers
+
+
+class AddFiles(ErrorHandlingMethodView):
+
+    def post(self):
+        """
+        ---
+        summary: Add files
+        description: |
+          Atomic method used by the RucioFileCatalog plugin in Dirac that:
+          - Creates files and their replicas
+          - Creates the dataset containing the files and attach the files to the dataset
+          - Creates a rule on the dataset with RSE expression ANY and grouping NONE
+          - Creates all the container hierarchy containing the dataset
+        tags:
+          - Dirac
+        requestBody:
+          content:
+            'application/json':
+              schema:
+                type: object
+                required:
+                - lfns
+                properties:
+                  lfns:
+                    description: "List of lfn (dictionary {'lfn': <lfn>, 'rse': <rse>, 'bytes': <bytes>, 'adler32': <adler32>, 'guid': <guid>, 'pfn': <pfn>}."
+                    type: array
+                    items:
+                      type: object
+                  ignore_availability:
+                    description: If the availability should be ignored.
+                    type: boolean
+                  parents_metadata:
+                    description: "Metadata for selected hierarchy DIDs."
+                    type: object
+        responses:
+          201:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: string
+                  enum: ["Created"]
+          400:
+            description: Cannot decode json parameter list.
+          401:
+            description: Invalid Auth Token
+          404:
+            description: DID not found
+          405:
+            description: Unsupported Operation
+          409:
+            description: Duplicate
+          503:
+            description: Temporary error.
+        """
+        parameters = json_parameters(parse_response)
+        lfns = param_get(parameters, 'lfns')
+        ignore_availability = param_get(parameters, 'ignore_availability', default=False)
+        parents_metadata = param_get(parameters, 'parents_metadata', default=None)
+        try:
+            add_files(lfns=lfns, issuer=request.environ.get('issuer'), ignore_availability=ignore_availability,
+                      parents_metadata=parents_metadata, vo=request.environ.get('vo'))
+        except InvalidPath as error:
+            return generate_http_error_flask(400, error)
+        except AccessDenied as error:
+            return generate_http_error_flask(401, error)
+        except UnsupportedOperation as error:
+            return generate_http_error_flask(405, error)
+        except (Duplicate, DataIdentifierAlreadyExists) as error:
+            return generate_http_error_flask(409, error)
+        except RSENotFound as error:
+            return generate_http_error_flask(404, error)
+        except (DatabaseException, ResourceTemporaryUnavailable) as error:
+            return generate_http_error_flask(503, error)
+
+        return 'Created', 201
+
+
+def blueprint(with_doc=False):
+    bp = AuthenticatedBlueprint('dirac', __name__, url_prefix='/dirac')
+
+    add_file_view = AddFiles.as_view('addfiles')
+    bp.add_url_rule('/addfiles', view_func=add_file_view, methods=['post', ])
+    bp.add_url_rule('/addfiles/', view_func=add_file_view, methods=['post', ])
+
+    bp.after_request(response_headers)
+    return bp
+
+
+def make_doc():
+    """ Only used for sphinx documentation """
+    doc_app = Flask(__name__)
+    doc_app.register_blueprint(blueprint(with_doc=True))
+    return doc_app

rucio/web/rest/flaskapi/v1/export.py

@@ -0,0 +1,75 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from flask import Flask, Response, request
+
+from rucio.common.utils import render_json
+from rucio.gateway.exporter import export_data
+from rucio.web.rest.flaskapi.authenticated_bp import AuthenticatedBlueprint
+from rucio.web.rest.flaskapi.v1.common import ErrorHandlingMethodView, check_accept_header_wrapper_flask, response_headers
+
+
+class Export(ErrorHandlingMethodView):
+    """ Export data. """
+
+    @check_accept_header_wrapper_flask(['application/json'])
+    def get(self):
+        """
+        ---
+        summary: Export data
+        description: Export data from rucio.
+        tags:
+          - Export
+        parameters:
+        - name: distance
+          in: query
+          description: Should the distance be enabled?
+          schema:
+            type: boolean
+          required: false
+        responses:
+          200:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: object
+                  description: Dictionary with rucio data.
+          401:
+            description: Invalid Auth Token
+          406:
+            description: Not acceptable
+        """
+        distance = request.args.get('distance', default='True') == 'True'
+        return Response(render_json(**export_data(issuer=request.environ.get('issuer'), distance=distance, vo=request.environ.get('vo'))), content_type='application/json')
+
+
+def blueprint(with_doc=False):
+    bp = AuthenticatedBlueprint('export', __name__, url_prefix='/export')
+
+    export_view = Export.as_view('scope')
+    if not with_doc:
+        # rule without trailing slash needs to be added before rule with trailing slash
+        bp.add_url_rule('', view_func=export_view, methods=['get', ])
+    bp.add_url_rule('/', view_func=export_view, methods=['get', ])
+
+    bp.after_request(response_headers)
+    return bp
+
+
+def make_doc():
+    """ Only used for sphinx documentation to add the prefix """
+    doc_app = Flask(__name__)
+    doc_app.register_blueprint(blueprint(with_doc=True))
+    return doc_app

rucio/web/rest/flaskapi/v1/heartbeats.py

@@ -0,0 +1,127 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+
+from flask import Flask, Response, request
+
+from rucio.common.exception import AccessDenied, KeyNotFound, UnsupportedKeyType, UnsupportedValueType
+from rucio.common.utils import APIEncoder
+from rucio.gateway.heartbeat import create_heartbeat, list_heartbeats
+from rucio.web.rest.flaskapi.authenticated_bp import AuthenticatedBlueprint
+from rucio.web.rest.flaskapi.v1.common import ErrorHandlingMethodView, check_accept_header_wrapper_flask, generate_http_error_flask, json_parameters, param_get, response_headers
+
+
+class Heartbeat(ErrorHandlingMethodView):
+    """ REST API for Heartbeats. """
+
+    @check_accept_header_wrapper_flask(['application/json'])
+    def get(self):
+        """
+        ---
+        summary: List
+        description: List all heartbeats.
+        tags:
+          - Heartbeat
+        responses:
+          200:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: array
+                  items:
+                    type: object
+                    description: List of tuples [('Executable', 'Hostname', ...), ...]
+          401:
+            description: Invalid Auth Token
+          406:
+            description: Not acceptable
+        """
+        return Response(json.dumps(list_heartbeats(issuer=request.environ.get('issuer'), vo=request.environ.get('vo')), cls=APIEncoder), content_type='application/json')
+
+    def post(self):
+        """
+        ---
+        summary: Create
+        tags:
+          - Heartbeat
+        requestBody:
+          content:
+            'application/json':
+              schema:
+                type: object
+                required:
+                - bytes
+                properties:
+                  executable:
+                    description: Name of the executable.
+                    type: string
+                  hostname:
+                    description: Name of the host.
+                    type: string
+                  pid:
+                    description: UNIX Process ID as a number, e.g., 1234.
+                    type: integer
+                  older_than:
+                    description: Ignore specified heartbeats older than specified nr of seconds.
+                    type: integer
+                  payload:
+                    description: Payload identifier which can be further used to identify the work a certain thread is executing.
+                    type: string
+        responses:
+          200:
+            description: OK
+          400:
+            description: Cannot decode json parameter list.
+          401:
+            description: Invalid Auth Token
+          404:
+            description: Key not found.
+        """
+        parameters = json_parameters()
+        try:
+            create_heartbeat(
+                executable=param_get(parameters, 'executable'),
+                hostname=param_get(parameters, 'hostname'),
+                pid=param_get(parameters, 'pid'),
+                older_than=param_get(parameters, 'older_than', default=None),
+                payload=param_get(parameters, 'payload', default=None),
+                issuer=request.environ.get('issuer'),
+                vo=request.environ.get('vo'),
+            )
+        except (UnsupportedValueType, UnsupportedKeyType) as error:
+            return generate_http_error_flask(400, error)
+        except AccessDenied as error:
+            return generate_http_error_flask(401, error)
+        except KeyNotFound as error:
+            return generate_http_error_flask(404, error)
+        return 'OK', 200
+
+
+def blueprint():
+    bp = AuthenticatedBlueprint('heartbeats', __name__, url_prefix='/heartbeats')
+
+    heartbeat_view = Heartbeat.as_view('heartbeat')
+    bp.add_url_rule('', view_func=heartbeat_view, methods=['get', 'post'])
+
+    bp.after_request(response_headers)
+    return bp
+
+
+def make_doc():
+    """ Only used for sphinx documentation """
+    doc_app = Flask(__name__)
+    doc_app.register_blueprint(blueprint())
+    return doc_app

rucio/web/rest/flaskapi/v1/identities.py

@@ -0,0 +1,261 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from flask import Flask, jsonify, request
+
+from rucio.gateway.identity import add_account_identity, add_identity, list_accounts_for_identity
+from rucio.web.rest.flaskapi.authenticated_bp import AuthenticatedBlueprint
+from rucio.web.rest.flaskapi.v1.common import ErrorHandlingMethodView, check_accept_header_wrapper_flask, response_headers
+
+
+class UserPass(ErrorHandlingMethodView):
+    """ Manage a username/password identity for an account. """
+
+    def put(self, account):
+        """
+        ---
+        summary: Create UserPass identity
+        description: Creates a new UserPass identity and maps it to an account.
+        tags:
+          - Identity
+        parameters:
+        - name: account
+          in: path
+          description: The account for the identity.
+          schema:
+            type: string
+          style: simple
+        - name: X-Rucio-Username
+          in: query
+          description: Username for the identity.
+          schema:
+            type: string
+          style: simple
+          required: true
+        - name: X-Rucio-Password
+          in: query
+          description: The password for the identity.
+          schema:
+            type: string
+          style: simple
+          required: true
+        - name: X-Rucio-Email
+          in: query
+          description: The email for the identity.
+          schema:
+            type: string
+          style: simple
+          required: false
+        responses:
+          201:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: string
+                  enum: ['Created']
+          401:
+            description: Invalid Auth Token
+          400:
+            description: Missing username or password.
+        """
+        username = request.headers.get('X-Rucio-Username', default=None)
+        password = request.headers.get('X-Rucio-Password', default=None)
+        email = request.headers.get('X-Rucio-Email', default=None)
+
+        if not username or not password:
+            return 'Username and Password must be set.', 400
+
+        add_identity(username, 'userpass', email, password)
+
+        add_account_identity(
+            identity_key=username,
+            id_type='userpass',
+            account=account,
+            email=email,
+            password=password,
+            issuer=request.environ.get('issuer'),
+            vo=request.environ.get('vo'),
+        )
+
+        return 'Created', 201
+
+
+class X509(ErrorHandlingMethodView):
+    """ Manage an x509 identity for an account. """
+
+    def put(self, account):
+        """
+        ---
+        summary: Create X509 identity
+        description: Creates a new X509 identity and maps it to an account.
+        tags:
+          - Identity
+        parameters:
+        - name: account
+          in: path
+          description: The account for the identity.
+          schema:
+            type: string
+          style: simple
+        - name: X-Rucio-Email
+          in: query
+          description: The email for the identity.
+          schema:
+            type: string
+          style: simple
+          required: false
+        responses:
+          201:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: string
+                  enum: ['Created']
+          401:
+            description: Invalid Auth Token
+        """
+        dn = request.environ.get('SSL_CLIENT_S_DN')
+        email = request.headers.get('X-Rucio-Email', default=None)
+
+        add_identity(dn, 'x509', email=email)
+        add_account_identity(
+            identity_key=dn,
+            id_type='x509',
+            account=account,
+            email=email,
+            issuer=request.environ.get('issuer'),
+            vo=request.environ.get('vo'),
+        )
+
+        return 'Created', 201
+
+
+class GSS(ErrorHandlingMethodView):
+    """ Manage a GSS identity for an account. """
+
+    def put(self, account):
+        """
+        ---
+        summary: Create GSS identity
+        description: Creates a new GSS identity and maps it to an account.
+        tags:
+          - Identity
+        parameters:
+        - name: account
+          in: path
+          description: The account for the identity.
+          schema:
+            type: string
+          style: simple
+        - name: X-Rucio-Email
+          in: query
+          description: The email for the identity.
+          schema:
+            type: string
+          style: simple
+          required: false
+        responses:
+          201:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: string
+                  enum: ['Created']
+          401:
+            description: Invalid Auth Token
+        """
+        gsscred = request.environ.get('REMOTE_USER')
+        email = request.headers.get('X-Rucio-Email', default=None)
+
+        add_identity(gsscred, 'gss', email=email)
+        add_account_identity(
+            identity_key=gsscred,
+            id_type='gss',
+            account=account,
+            email=email,
+            issuer=request.environ.get('issuer'),
+            vo=request.environ.get('vo'),
+        )
+
+        return 'Created', 201
+
+
+class Accounts(ErrorHandlingMethodView):
+    """ Retrieve list of accounts mapped to an identity. """
+
+    @check_accept_header_wrapper_flask(['application/json'])
+    def get(self, identity_key, type_):
+        """
+        ---
+        summary: List
+        description: List all identities mapped to an account.
+        tags:
+          - Identity
+        parameters:
+        - name: identity_key
+          in: path
+          description: Identity string.
+          schema:
+            type: string
+          style: simple
+        - name: type
+          in: path
+          description: Identity type.
+          schema:
+            type: string
+          style: simple
+          required: false
+        responses:
+          200:
+            description: OK
+            content:
+              application/json:
+                schema:
+                  type: array
+                  items:
+                    type: object
+                    description: Account for the identity.
+          401:
+            description: Invalid Auth Token
+          401:
+            description: Not acceptable
+        """
+        accounts = list_accounts_for_identity(identity_key, type_)
+        return jsonify(accounts)
+
+
+def blueprint():
+    bp = AuthenticatedBlueprint('identities', __name__, url_prefix='/identities')
+
+    userpass_view = UserPass.as_view('userpass')
+    bp.add_url_rule('/<account>/userpass', view_func=userpass_view, methods=['put', ])
+    x509_view = X509.as_view('x509')
+    bp.add_url_rule('/<account>/x509', view_func=x509_view, methods=['put', ])
+    gss_view = GSS.as_view('gss')
+    bp.add_url_rule('/<account>/gss', view_func=gss_view, methods=['put', ])
+    accounts_view = Accounts.as_view('accounts')
+    bp.add_url_rule('/<identity_key>/<type>/accounts', view_func=accounts_view, methods=['get', ])
+
+    bp.after_request(response_headers)
+    return bp
+
+
+def make_doc():
+    """ Only used for sphinx documentation """
+    doc_app = Flask(__name__)
+    doc_app.register_blueprint(blueprint())
+    return doc_app