rucio 32.8.6__py3-none-any.whl → 35.8.0__py3-none-any.whl

rucio/core/config.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,7 +16,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
 from dogpile.cache.api import NoValue
-from sqlalchemy import func
+from sqlalchemy import and_, delete, func, select, update
 
 from rucio.common.cache import make_region_memcached
 from rucio.common.exception import ConfigNotFound
@@ -35,23 +34,23 @@ REGION = make_region_memcached(expiration_time=900)
 SECTIONS_CACHE_KEY = 'sections'
 
 
-def _has_section_cache_key(section):
+def _has_section_cache_key(section: str) -> str:
     return 'has_section_%s' % section
 
 
-def _options_cache_key(section):
+def _options_cache_key(section: str) -> str:
     return 'options_%s' % section
 
 
-def _has_option_cache_key(section, option):
+def _has_option_cache_key(section: str, option: str) -> str:
     return 'has_option_%s_%s' % (section, option)
 
 
-def _items_cache_key(section):
+def _items_cache_key(section: str) -> str:
     return 'items_%s' % section
 
 
-def _value_cache_key(section, option):
+def _value_cache_key(section: str, option: str) -> str:
     return 'get_%s_%s' % (section, option)
 
 
@@ -61,7 +60,7 @@ def sections(
         use_cache: bool = True,
         expiration_time: int = 900,
         session: "Session"
-):
+) -> list[str]:
     """
     Return a list of the sections available.
 
@@ -75,15 +74,18 @@ def sections(
     if use_cache:
         all_sections = read_from_cache(SECTIONS_CACHE_KEY, expiration_time)
     if isinstance(all_sections, NoValue):
-        query = session.query(models.Config.section).distinct().all()
-        all_sections = [section[0] for section in query]
+        stmt = select(
+            models.Config.section
+        ).distinct(
+        )
+        all_sections = list(session.execute(stmt).scalars().all())
         write_to_cache(SECTIONS_CACHE_KEY, all_sections)
 
     return all_sections
 
 
 @transactional_session
-def add_section(section: str, *, session: "Session"):
+def add_section(section: str, *, session: "Session") -> None:
     """
     Add a section to the configuration.
     :param session: The database session in use.
@@ -115,8 +117,12 @@ def has_section(
     if use_cache:
         has_section = read_from_cache(has_section_key, expiration_time)
     if isinstance(has_section, NoValue):
-        query = session.query(models.Config).filter_by(section=section)
-        has_section = True if query.first() else False
+        stmt = select(
+            models.Config
+        ).where(
+            models.Config.section == section
+        )
+        has_section = session.execute(stmt).first() is not None
         write_to_cache(has_section_key, has_section)
     return has_section
 
@@ -143,21 +149,25 @@ def options(
     if use_cache:
         options = read_from_cache(options_key, expiration_time)
     if isinstance(options, NoValue):
-        query = session.query(models.Config.opt).filter_by(section=section).distinct().all()
-        options = [option[0] for option in query]
+        stmt = select(
+            models.Config.opt
+        ).where(
+            models.Config.section == section
+        ).distinct()
+        options = list(session.execute(stmt).scalars().all())
         write_to_cache(options_key, options)
     return options
 
 
 @read_session
 def has_option(
-        section,
-        option,
+        section: str,
+        option: str,
         *,
-        use_cache=True,
-        expiration_time=900,
+        use_cache: bool = True,
+        expiration_time: int = 900,
         session: "Session"
-):
+) -> bool:
     """
     Check if the given section exists and contains the given option.
 
@@ -173,8 +183,13 @@ def has_option(
     if use_cache:
         has_option = read_from_cache(has_option_key, expiration_time)
     if isinstance(has_option, NoValue):
-        query = session.query(models.Config).filter_by(section=section, opt=option)
-        has_option = True if query.first() else False
+        stmt = select(
+            models.Config
+        ).where(
+            and_(models.Config.section == section,
+                 models.Config.opt == option)
+        )
+        has_option = session.execute(stmt).first() is not None
         write_to_cache(has_option_key, has_option)
     return has_option
 
@@ -210,7 +225,13 @@ def get(
     if use_cache:
         value = read_from_cache(value_key, expiration_time)
     if isinstance(value, NoValue):
-        tmp = session.query(models.Config.value).filter_by(section=section, opt=option).first()
+        stmt = select(
+            models.Config.value
+        ).where(
+            and_(models.Config.section == section,
+                 models.Config.opt == option)
+        )
+        tmp = session.execute(stmt).first()
         if tmp is not None:
             value = convert_type_fnc(tmp[0])
             write_to_cache(value_key, tmp[0])
@@ -248,9 +269,15 @@ def items(
     if use_cache:
         items = read_from_cache(items_key, expiration_time)
     if isinstance(items, NoValue):
-        items = session.query(models.Config.opt, models.Config.value).filter_by(section=section).all()
+        stmt = select(
+            models.Config.opt,
+            models.Config.value
+        ).where(
+            models.Config.section == section
+        )
+        items = session.execute(stmt).all()
         write_to_cache(items_key, items)
-    return [(item[0], convert_type_fnc(item[1])) for item in items]
+    return [(opt, convert_type_fnc(val)) for opt, val in items]
 
 
 @transactional_session
@@ -260,7 +287,7 @@ def set(
         value: Any,
         *,
         session: "Session"
-):
+) -> None:
     """
     Set the given option to the specified value. If the option doesn't exist, it is created.
 
@@ -283,14 +310,27 @@ def set(
             delete_from_cache(key=SECTIONS_CACHE_KEY)
             delete_from_cache(key=_has_section_cache_key(section))
     else:
-        old_value = session.query(models.Config.value).filter_by(section=section,
-                                                                 opt=option).first()[0]
+        stmt = select(
+            models.Config.value
+        ).where(
+            and_(models.Config.section == section,
+                 models.Config.opt == option)
+        )
+        old_value = session.execute(stmt).scalar_one_or_none()
         if old_value != str(value):
             old_option = models.ConfigHistory(section=section,
                                               opt=option,
                                               value=old_value)
             old_option.save(session=session)
-            session.query(models.Config).filter_by(section=section, opt=option).update({'value': str(value)})
+            stmt = update(
+                models.Config
+            ).where(
+                and_(models.Config.section == section,
+                     models.Config.opt == option)
+            ).values({
+                models.Config.value: str(value)
+            })
+            session.execute(stmt)
             delete_from_cache(key=_value_cache_key(section, option))
             delete_from_cache(key=_items_cache_key(section))
 
@@ -308,7 +348,12 @@ def remove_section(section: str, *, session: "Session") -> bool:
     if not has_section(section=section, session=session):
         return False
     else:
-        for old in session.query(models.Config.value).filter_by(section=section).all():
+        stmt = select(
+            models.Config.value
+        ).where(
+            models.Config.section == section
+        )
+        for old in session.execute(stmt).all():
             old_option = models.ConfigHistory(section=old[0],
                                               opt=old[1],
                                               value=old[2])
@@ -316,7 +361,12 @@ def remove_section(section: str, *, session: "Session") -> bool:
             delete_from_cache(key=_has_option_cache_key(old[0], old[1]))
             delete_from_cache(key=_value_cache_key(old[0], old[1]))
 
-        session.query(models.Config).filter_by(section=section).delete()
+        stmt = delete(
+            models.Config
+        ).where(
+            models.Config.section == section
+        )
+        session.execute(stmt)
         delete_from_cache(key=SECTIONS_CACHE_KEY)
         delete_from_cache(key=_items_cache_key(section))
         return True
@@ -336,14 +386,34 @@ def remove_option(section: str, option: str, *, session: "Session") -> bool:
     if not has_option(section=section, option=option, session=session, use_cache=False):
         return False
     else:
+        stmt = select(
+            models.Config.value
+        ).where(
+            and_(models.Config.section == section,
+                 models.Config.opt == option)
+        )
+        result = session.execute(stmt).scalar_one_or_none()
         old_option = models.ConfigHistory(section=section,
                                           opt=option,
-                                          value=session.query(models.Config.value).filter_by(section=section,
-                                                                                             opt=option).first()[0])
+                                          value=result)
         old_option.save(session=session)
-        session.query(models.Config).filter_by(section=section, opt=option).delete()
 
-        if not session.query(func.count('*')).select_from(models.Config).filter_by(section=section).scalar():
+        stmt = delete(
+            models.Config
+        ).where(
+            and_(models.Config.section == section,
+                 models.Config.opt == option)
+        )
+        session.execute(stmt)
+
+        stmt = select(
+            func.count()
+        ).select_from(
+            models.Config
+        ).where(
+            models.Config.section == section
+        )
+        if not session.execute(stmt).scalar_one_or_none():
             # we deleted the last config entry in the section. Invalidate the section cache
             delete_from_cache(key=SECTIONS_CACHE_KEY)
             delete_from_cache(key=_has_section_cache_key(section))
@@ -353,7 +423,7 @@ def remove_option(section: str, option: str, *, session: "Session") -> bool:
         return True
 
 
-def read_from_cache(key, expiration_time=900):
+def read_from_cache(key: str, expiration_time: int = 900) -> Any:
     """
     Try to read a value from a cache.
 
@@ -365,7 +435,7 @@ def read_from_cache(key, expiration_time=900):
     return value
 
 
-def write_to_cache(key, value):
+def write_to_cache(key: str, value: Any) -> None:
     """
     Set a value on a key in a cache.
 
@@ -376,7 +446,7 @@ def write_to_cache(key, value):
     REGION.set(key, value)
 
 
-def delete_from_cache(key):
+def delete_from_cache(key: str) -> None:
     """
     Delete from cache any data stored for the given key
 

rucio/core/credential.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,7 +17,8 @@ import datetime
 import hmac
 import time
 from hashlib import sha1
-from urllib.parse import urlparse, urlencode
+from typing import Literal
+from urllib.parse import urlencode, urlparse
 
 import boto3
 from botocore.client import Config
@@ -27,6 +27,7 @@ from google.oauth2.service_account import Credentials
 
 from rucio.common.cache import make_region_memcached
 from rucio.common.config import config_get, get_rse_credentials
+from rucio.common.constants import RseAttr
 from rucio.common.exception import UnsupportedOperation
 from rucio.core.monitor import MetricManager
 from rucio.core.rse import get_rse_attribute
@@ -37,11 +38,17 @@ REGION = make_region_memcached(expiration_time=900)
 METRICS = MetricManager(module=__name__)
 
 
-def get_signed_url(rse_id: str, service: str, operation: str, url: str, lifetime=600) -> str:
+def get_signed_url(
+        rse_id: str,
+        service: Literal['gsc', 's3', 'swift'],
+        operation: Literal['read', 'write', 'delete'],
+        url: str,
+        lifetime: int = 600
+) -> str:
     """
     Get a signed URL for a particular service and operation.
 
-    The signed URL will be valid for 1 hour but can be overriden.
+    The signed URL will be valid for 1 hour but can be overridden.
 
     :param rse_id: The ID of the RSE that the URL points to.
     :param service: The service to authorise, either 'gcs', 's3' or 'swift'.
@@ -87,8 +94,8 @@ def get_signed_url(rse_id: str, service: str, operation: str, url: str, lifetime
         else:
             # GCS is timezone-sensitive, don't use UTC
             # has to be converted to Unixtime
-            lifetime = datetime.datetime.now() + datetime.timedelta(seconds=lifetime)
-            lifetime = int(time.mktime(lifetime.timetuple()))
+            lifetime_datetime = datetime.datetime.now() + datetime.timedelta(seconds=lifetime)
+            lifetime = int(time.mktime(lifetime_datetime.timetuple()))
 
         # sign the path only
         path = components.path
@@ -112,7 +119,7 @@ def get_signed_url(rse_id: str, service: str, operation: str, url: str, lifetime
         # get RSE S3 URL style (path or host)
         # path-style: https://s3.region-code.amazonaws.com/bucket-name/key-name
         # host-style: https://bucket-name.s3.region-code.amazonaws.com/key-name
-        s3_url_style = get_rse_attribute(rse_id, 's3_url_style')
+        s3_url_style = get_rse_attribute(rse_id, RseAttr.S3_URL_STYLE)
 
         # no S3 URL style specified, assume path-style
         if s3_url_style is None: