rucio 35.7.0__py3-none-any.whl → 37.0.0rc2__py3-none-any.whl

rucio/daemons/tracer/kronos.py

@@ -15,7 +15,6 @@
 """
 This daemon consumes tracer messages from ActiveMQ and updates the atime for replicas.
 """
-
 import functools
 import logging
 import re
@@ -26,13 +25,13 @@ from json import loads as jloads
 from queue import Queue
 from threading import Event, Thread
 from time import time
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import rucio.db.sqla.util
-from rucio.common.config import config_get, config_get_bool, config_get_int, config_get_list
+from rucio.common.config import config_get, config_get_int, config_get_list
 from rucio.common.exception import DatabaseException, RSENotFound
-from rucio.common.logging import setup_logging
-from rucio.common.stomp_utils import StompConnectionManager
+from rucio.common.logging import formatted_logger, setup_logging
+from rucio.common.stomp_utils import ListenerBase, StompConnectionManager
 from rucio.common.stopwatch import Stopwatch
 from rucio.common.types import InternalAccount, InternalScope, LoggerFunction
 from rucio.core.did import list_parent_dids, touch_dids
@@ -47,9 +46,10 @@ if TYPE_CHECKING:
     from collections.abc import Set
     from types import FrameType
 
-    from stomp import Connection
     from stomp.utils import Frame
 
+    from rucio.common.stomp_utils import Connection
+
 
 logging.getLogger("stomp").setLevel(logging.CRITICAL)
 
@@ -57,23 +57,20 @@ METRICS = MetricManager(module=__name__)
 graceful_stop = Event()
 
 
-class AMQConsumer:
+class AMQConsumer(ListenerBase):
     """ActiveMQ message consumer"""
 
-    def __init__(
-            self,
-            broker: str,
-            conn: "Connection",
-            queue: str,
-            chunksize: int,
-            subscription_id: str,
-            excluded_usrdns: "Set[str]",
-            dataset_queue: Queue,
-            bad_files_patterns: list[re.Pattern],
-            logger: LoggerFunction = logging.log
-    ):
-        self.__broker = broker
-        self.__conn = conn
+    def __init__(self,
+                 conn: "Connection",
+                 queue: str,
+                 chunksize: int,
+                 subscription_id: str,
+                 excluded_usrdns: "Set[str]",
+                 dataset_queue: Queue,
+                 bad_files_patterns: list[re.Pattern],
+                 logger: LoggerFunction = logging.log,
+                 **kwargs: dict) -> None:
+        super().__init__(conn=conn, logger=logger, **kwargs)
         self.__queue = queue
         self.__reports = []
         self.__ids = []
@@ -85,15 +82,6 @@ class AMQConsumer:
         self.__excluded_usrdns = excluded_usrdns
         self.__dataset_queue = dataset_queue
         self.__bad_files_patterns = bad_files_patterns
-        self.__logger = logger
-
-    @METRICS.count_it
-    def on_heartbeat_timeout(self) -> None:
-        self.__conn.disconnect()
-
-    @METRICS.count_it
-    def on_error(self, frame: "Frame") -> None:
-        self.__logger(logging.ERROR, 'Message receive error: [%s] %s' % (self.__broker, frame.body))
 
     @METRICS.count_it
     def on_message(self, frame: "Frame") -> None:
@@ -107,7 +95,7 @@ class AMQConsumer:
 
         try:
             if appversion == 'dq2':
-                self.__conn.ack(msg_id, self.__subscription_id)
+                self._conn.ack(msg_id, self.__subscription_id)
                 return
             else:
                 report = jloads(frame.body)  # type: ignore
@@ -115,22 +103,26 @@ class AMQConsumer:
             # message is corrupt, not much to do here
             # send count to graphite, send ack to broker and return
             METRICS.counter('json_error').inc()
-            self.__logger(logging.ERROR, 'json error', exc_info=True)
-            self.__conn.ack(msg_id, self.__subscription_id)
+            self._logger(logging.ERROR, 'json error', exc_info=True)
+            self._conn.ack(msg_id, self.__subscription_id)
             return
 
         self.__ids.append(msg_id)
         self.__reports.append(report)
 
         try:
-            self.__logger(logging.DEBUG, 'message received: %s %s %s' % (str(report['eventType']), report['filename'], report['remoteSite']))
+            self._logger(logging.DEBUG,
+                         "message received: %s %s %s",
+                         str(report['eventType']),
+                         report['filename'],
+                         report['remoteSite'])
         except Exception:
             pass
 
         if len(self.__ids) >= self.__chunksize:
             self.__update_atime()
             for msg_id in self.__ids:
-                self.__conn.ack(msg_id, self.__subscription_id)
+                self._conn.ack(msg_id, self.__subscription_id)
 
             self.__reports = []
             self.__ids = []
@@ -153,16 +145,19 @@ class AMQConsumer:
                             if 'stateReason' in report and report['stateReason'] and isinstance(report['stateReason'], str) and pattern.match(report['stateReason']):
                                 reason = report['stateReason'][:255]
                                 if 'url' not in report or not report['url']:
-                                    self.__logger(logging.ERROR, 'Missing url in the following trace : ' + str(report))
+                                    self._logger(logging.ERROR, 'Missing url in the following trace : ' + str(report))
                                 else:
                                     try:
-                                        pfn = report['url']
-                                        declare_bad_file_replicas([pfn, ], reason=reason, issuer=InternalAccount('root', vo=report['vo']), status=BadFilesStatus.SUSPICIOUS)
-                                        self.__logger(logging.INFO, 'Declare suspicious file %s with reason %s' % (report['url'], reason))
+                                        surl = report['url']
+                                        declare_bad_file_replicas([surl, ], reason=reason, issuer=InternalAccount('root', vo=report['vo']), status=BadFilesStatus.SUSPICIOUS)
+                                        self._logger(logging.INFO,
+                                                     "Declare suspicious file %s with reason %s",
+                                                     report['url'],
+                                                     reason)
                                     except Exception as error:
-                                        self.__logger(logging.ERROR, 'Failed to declare suspicious file' + str(error))
+                                        self._logger(logging.ERROR, 'Failed to declare suspicious file' + str(error))
                 except Exception as error:
-                    self.__logger(logging.ERROR, 'Problem with bad trace : %s . Error %s' % (str(report), str(error)))
+                    self._logger(logging.ERROR, 'Problem with bad trace : %s . Error %s', str(report), str(error))
 
                 # check if scope in report. if not skip this one.
                 if 'scope' not in report:
@@ -225,7 +220,7 @@ class AMQConsumer:
                         try:
                             rse_id = get_rse_id(rse=rse, vo=report['vo'])
                         except RSENotFound:
-                            self.__logger(logging.WARNING, "Cannot lookup rse_id for %s. Will skip this report.", rse)
+                            self._logger(logging.WARNING, "Cannot lookup rse_id for %s. Will skip this report.", rse)
                             METRICS.counter('rse_not_found').inc()
                             continue
                         replicas.append({'name': report['filename'], 'scope': report['scope'], 'rse': rse, 'rse_id': rse_id, 'accessed_at': datetime.utcfromtimestamp(report['traceTimeentryUnix']),
@@ -241,7 +236,7 @@ class AMQConsumer:
                         try:
                             rse_id = get_rse_id(rse=rse, vo=report['vo'])
                         except RSENotFound:
-                            self.__logger(logging.WARNING, "Cannot lookup rse_id for %s.", rse)
+                            self._logger(logging.WARNING, "Cannot lookup rse_id for %s.", rse)
                             METRICS.counter('rse_not_found').inc()
                     if 'datasetScope' in report:
                         self.__dataset_queue.put({'scope': InternalScope(report['datasetScope'], vo=report['vo']),
@@ -259,11 +254,11 @@ class AMQConsumer:
                                          'accessed_at': datetime.utcfromtimestamp(report['traceTimeentryUnix'])})
 
             except (KeyError, AttributeError):
-                self.__logger(logging.ERROR, "Cannot handle report.", exc_info=True)
+                self._logger(logging.ERROR, "Cannot handle report.", exc_info=True)
                 METRICS.counter('report_error').inc()
                 continue
             except Exception:
-                self.__logger(logging.ERROR, "Exception", exc_info=True)
+                self._logger(logging.ERROR, "Exception", exc_info=True)
                 continue
 
             for did in list_parent_dids(report['scope'], report['filename']):
@@ -276,15 +271,15 @@ class AMQConsumer:
                     try:
                         rse_id = get_rse_id(rse=rse, vo=report['vo'])
                     except RSENotFound:
-                        self.__logger(logging.WARNING, "Cannot lookup rse_id for %s. Will skip this report.", rse)
+                        self._logger(logging.WARNING, "Cannot lookup rse_id for %s. Will skip this report.", rse)
                         METRICS.counter('rse_not_found').inc()
                         continue
                     self.__dataset_queue.put({'scope': did['scope'], 'name': did['name'], 'did_type': did['type'], 'rse_id': rse_id, 'accessed_at': datetime.utcfromtimestamp(report['traceTimeentryUnix'])})
 
-        if not len(replicas):
+        if not replicas:
             return
 
-        self.__logger(logging.DEBUG, "trying to update replicas: %s", replicas)
+        self._logger(logging.DEBUG, "trying to update replicas: %s", replicas)
 
         stopwatch = Stopwatch()
         try:
@@ -301,25 +296,50 @@ class AMQConsumer:
                                 'eventVersion': replica['eventVersion']}
                     if replica['scope'].vo != 'def':
                         resubmit['vo'] = replica['scope'].vo
-                    self.__conn.send(body=jdumps(resubmit), destination=self.__queue, headers={'appversion': 'rucio', 'resubmitted': '1'})
+                    self._conn.send(body=jdumps(resubmit), destination=self.__queue, headers={'appversion': 'rucio', 'resubmitted': '1'})
                     METRICS.counter('sent_resubmitted').inc()
             METRICS.timer('update_atime').observe(stopwatch.elapsed)
         except Exception:
-            self.__logger(logging.ERROR, "Cannot update replicas.", exc_info=True)
+            self._logger(logging.ERROR, "Cannot update replicas.", exc_info=True)
             METRICS.counter('update_error').inc()
 
         METRICS.counter('updated_replicas').inc()
 
 
-def kronos_file(
-        once: bool = False,
-        dataset_queue: Optional[Queue] = None,
-        sleep_time: int = 60
-) -> None:
+def kronos_file(once: bool = False,
+                dataset_queue: "Queue | None" = None,
+                sleep_time: int = 60,
+                logger: LoggerFunction = logging.log) -> None:
     """
     Main loop to consume tracer reports.
     """
-    stomp_conn_mngr = StompConnectionManager()
+    bad_files_patterns = []
+    try:
+        patterns = config_get_list(section='kronos', option='bad_files_patterns', session=None)
+        for pat in patterns:
+            bad_files_patterns.append(re.compile(pat.strip()))
+    except (NoOptionError, NoSectionError, RuntimeError):
+        logger(logging.ERROR, "Failed to get bad_file_patterns")
+        bad_files_patterns.clear()
+    except Exception as error:
+        logger(logging.ERROR, f'Failed to get bad_file_patterns {str(error)}')
+        bad_files_patterns.clear()
+
+    excluded_usrdns = set(config_get('tracer-kronos', 'excluded_usrdns').split(','))
+
+    subscription_id = config_get('tracer-kronos', 'subscription_id')
+    stomp_conn_mngr = StompConnectionManager(config_section='tracer-kronos',
+                                             logger=logger)
+    stomp_conn_mngr.set_listener_factory('rucio-tracer-kronos',
+                                         AMQConsumer,
+                                         queue=config_get('tracer-kronos', 'queue'),
+                                         chunksize=config_get_int('tracer-kronos', 'chunksize'),
+                                         subscription_id=subscription_id,
+                                         excluded_usrdns=excluded_usrdns,
+                                         dataset_queue=dataset_queue,
+                                         bad_files_patterns=bad_files_patterns,
+                                         heartbeats=stomp_conn_mngr.config.heartbeats)
+
     run_daemon(
         once=once,
         graceful_stop=graceful_stop,
@@ -336,74 +356,20 @@ def kronos_file(
     stomp_conn_mngr.disconnect()
 
 
-def run_once_kronos_file(heartbeat_handler: HeartbeatHandler, stomp_conn_mngr: StompConnectionManager, dataset_queue: Queue, sleep_time: int, **kwargs) -> None:
+def run_once_kronos_file(heartbeat_handler: HeartbeatHandler,
+                         stomp_conn_mngr: StompConnectionManager,
+                         dataset_queue: Queue,
+                         sleep_time: int,
+                         **kwargs: dict) -> None:
     """
     Run the amq consumer once.
     """
     _, _, logger = heartbeat_handler.live()
 
-    chunksize = config_get_int('tracer-kronos', 'chunksize')
-    prefetch_size = config_get_int('tracer-kronos', 'prefetch_size')
-    subscription_id = config_get('tracer-kronos', 'subscription_id')
-    # Load bad file patterns from config
-    try:
-        bad_files_patterns = []
-        pattern = config_get(section='kronos', option='bad_files_patterns', session=None)
-        pattern = str(pattern)
-        patterns = pattern.split(",")
-        for pat in patterns:
-            bad_files_patterns.append(re.compile(pat.strip()))
-    except (NoOptionError, NoSectionError, RuntimeError):
-        bad_files_patterns = []
-    except Exception as error:
-        logger.error(f'Failed to get bad_file_patterns {str(error)}')
-        bad_files_patterns = []
-
-    use_ssl = config_get_bool('tracer-kronos', 'use_ssl', default=True, raise_exception=False)
-    if not use_ssl:
-        username = config_get('tracer-kronos', 'username')
-        password = config_get('tracer-kronos', 'password')
-
-    excluded_usrdns = set(config_get('tracer-kronos', 'excluded_usrdns').split(','))
-    vhost = config_get('tracer-kronos', 'broker_virtual_host', raise_exception=False)
-
-    brokers_alias = config_get_list('tracer-kronos', 'brokers')
-    port = config_get_int('tracer-kronos', 'port')
-    reconnect_attempts = config_get_int('tracer-kronos', 'reconnect_attempts')
-    ssl_key_file = config_get('tracer-kronos', 'ssl_key_file', raise_exception=False)
-    ssl_cert_file = config_get('tracer-kronos', 'ssl_cert_file', raise_exception=False)
-
-    created_conns, _ = stomp_conn_mngr.re_configure(
-        brokers=brokers_alias,
-        port=port,
-        use_ssl=use_ssl,
-        vhost=vhost,
-        reconnect_attempts=reconnect_attempts,
-        ssl_key_file=ssl_key_file,
-        ssl_cert_file=ssl_cert_file,
-        timeout=sleep_time,
-        heartbeats=(0, 5000),
-        logger=logger,
-    )
-
-    for conn in created_conns:
-        if not conn.is_connected():
-            logger(logging.INFO, 'connecting to %s' % str(conn.transport._Transport__host_and_ports[0]))
-            METRICS.counter('reconnect.{host}').labels(host=conn.transport._Transport__host_and_ports[0][0]).inc()
-            conn.set_listener('rucio-tracer-kronos', AMQConsumer(broker=conn.transport._Transport__host_and_ports[0],
-                                                                 conn=conn,
-                                                                 queue=config_get('tracer-kronos', 'queue'),
-                                                                 chunksize=chunksize,
-                                                                 subscription_id=subscription_id,
-                                                                 excluded_usrdns=excluded_usrdns,
-                                                                 dataset_queue=dataset_queue,
-                                                                 bad_files_patterns=bad_files_patterns,
-                                                                 logger=logger))
-            if not use_ssl:
-                conn.connect(username, password)
-            else:
-                conn.connect()
-            conn.subscribe(destination=config_get('tracer-kronos', 'queue'), ack='client-individual', id=subscription_id, headers={'activemq.prefetchSize': prefetch_size})
+    stomp_conn_mngr.subscribe(id_=config_get('tracer-kronos', 'subscription_id'),
+                              ack='client-individual',
+                              destination=config_get('tracer-kronos', 'queue'),
+                              headers={'activemq.prefetchSize': config_get_int('tracer-kronos', 'prefetch_size')})
 
 
 def kronos_dataset(dataset_queue: Queue, once: bool = False, sleep_time: int = 60) -> None:
@@ -422,10 +388,16 @@ def kronos_dataset(dataset_queue: Queue, once: bool = False, sleep_time: int = 6
     )
 
     # once again for potential backlog
-    run_once_kronos_dataset(dataset_queue=dataset_queue, return_values=return_values, heartbeat_handler=return_values['heartbeat_handler'], sleep_time=sleep_time)
+    run_once_kronos_dataset(dataset_queue=dataset_queue,
+                            return_values=return_values,
+                            heartbeat_handler=return_values['heartbeat_handler'],
+                            sleep_time=sleep_time)
 
 
-def run_once_kronos_dataset(dataset_queue: Queue, return_values: dict, heartbeat_handler: HeartbeatHandler, **kwargs) -> None:
+def run_once_kronos_dataset(dataset_queue: Queue,
+                            return_values: dict,
+                            heartbeat_handler: "HeartbeatHandler | None",
+                            **kwargs) -> None:
     if heartbeat_handler is None:
         if "heartbeat_handler" not in return_values.keys():
             return_values["heartbeat_handler"] = HeartbeatHandler("kronos-dataset", 10)
@@ -458,7 +430,7 @@ def run_once_kronos_dataset(dataset_queue: Queue, return_values: dict, heartbeat
     total, failed, start = 0, 0, time()
     for did, accessed_at in datasets.items():
         scope, name = did.split(':')
-        scope = InternalScope(scope, fromExternal=False)
+        scope = InternalScope(scope, from_external=False)
         update_did = {'scope': scope, 'name': name, 'type': DIDType.DATASET, 'accessed_at': accessed_at}
         # if update fails, put back in queue and retry next time
         if not touch_dids((update_did,)):
@@ -471,7 +443,7 @@ def run_once_kronos_dataset(dataset_queue: Queue, return_values: dict, heartbeat
     total, failed, start = 0, 0, time()
     for did, rses in dslocks.items():
         scope, name = did.split(':')
-        scope = InternalScope(scope, fromExternal=False)
+        scope = InternalScope(scope, from_external=False)
         for rse, accessed_at in rses.items():
             update_dslock = {'scope': scope, 'name': name, 'rse_id': rse, 'accessed_at': accessed_at}
             # if update fails, put back in queue and retry next time
@@ -484,7 +456,7 @@ def run_once_kronos_dataset(dataset_queue: Queue, return_values: dict, heartbeat
     total, failed, start = 0, 0, time()
     for did, rses in dslocks.items():
         scope, name = did.split(':')
-        scope = InternalScope(scope, fromExternal=False)
+        scope = InternalScope(scope, from_external=False)
         for rse, accessed_at in rses.items():
             update_dslock = {'scope': scope, 'name': name, 'rse_id': rse, 'accessed_at': accessed_at}
             # if update fails, put back in queue and retry next time
@@ -495,7 +467,7 @@ def run_once_kronos_dataset(dataset_queue: Queue, return_values: dict, heartbeat
     logger(logging.INFO, 'update done for %d collection replicas, %d failed (%ds)' % (total, failed, time() - start))
 
 
-def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
+def stop(signum: "int | None" = None, frame: "FrameType | None" = None) -> None:
     """
     Graceful exit.
     """
@@ -506,31 +478,34 @@ def run(
         once: bool = False,
         threads: int = 1,
         sleep_time_datasets: int = 60,
-        sleep_time_files: int = 60
-) -> None:
+        sleep_time_files: int = 60) -> None:
     """
     Starts up the consumer threads
     """
     setup_logging(process_name='tracer-kronos')
+    logger = formatted_logger(logging.log, 'Kronos %s')
 
     if rucio.db.sqla.util.is_old_db():
         raise DatabaseException('Database was not updated, daemon won\'t start')
 
     dataset_queue = Queue()
-    logging.info('starting tracer consumer threads')
+    logger(logging.INFO, 'starting tracer consumer threads')
 
     thread_list = []
-    for _ in range(0, threads):
-        thread_list.append(Thread(target=kronos_file, kwargs={'once': once,
-                                                              'sleep_time': sleep_time_files,
-                                                              'dataset_queue': dataset_queue}))
-        thread_list.append(Thread(target=kronos_dataset, kwargs={'once': once,
-                                                                 'sleep_time': sleep_time_datasets,
-                                                                 'dataset_queue': dataset_queue}))
-
-    [thread.start() for thread in thread_list]
-
-    logging.info('waiting for interrupts')
-
-    while len(thread_list) > 0:
-        thread_list = [thread.join(timeout=3) for thread in thread_list if thread and thread.is_alive()]
+    for _ in range(threads):
+        krf_thread = Thread(target=kronos_file, kwargs={'once': once,
+                                                        'logger': logger,
+                                                        'sleep_time': sleep_time_files,
+                                                        'dataset_queue': dataset_queue})
+        krf_thread.start()
+        krd_thread = Thread(target=kronos_dataset, kwargs={'once': once,
+                                                           'sleep_time': sleep_time_datasets,
+                                                           'dataset_queue': dataset_queue})
+        krd_thread.start()
+        thread_list.append(krf_thread)
+        thread_list.append(krd_thread)
+
+    logger(logging.INFO, 'waiting for interrupts')
+
+    while [thread.join(timeout=3.) for thread in thread_list if thread.is_alive()]:
+        pass

rucio/db/sqla/constants.py

@@ -199,3 +199,8 @@ class SubscriptionState(Enum):
 class TransferLimitDirection(Enum):
     SOURCE = 'S'
     DESTINATION = 'D'
+
+
+class DatabaseOperationType(Enum):
+    READ = 'read'
+    WRITE = 'write'

rucio/db/sqla/migrate_repo/versions/1677d4d803c8_split_rse_availability_into_multiple.py

@@ -38,7 +38,7 @@ def upgrade():
         add_column("rses", sa.Column("availability_write", sa.Boolean, server_default=true()), schema=schema)
         add_column("rses", sa.Column("availability_delete", sa.Boolean, server_default=true()), schema=schema)
 
-        RSE = sa.sql.table(
+        rse = sa.sql.table(
             "rses",
             sa.Column("id", GUID()),
             sa.Column("availability", sa.Integer),
@@ -50,9 +50,9 @@ def upgrade():
 
         conn = get_bind()
 
-        conn.execute(RSE.update().where(RSE.c.availability.in_([0, 1, 2, 3])).values({"availability_read": False}))
-        conn.execute(RSE.update().where(RSE.c.availability.in_([0, 1, 4, 5])).values({"availability_write": False}))
-        conn.execute(RSE.update().where(RSE.c.availability.in_([0, 2, 4, 6])).values({"availability_delete": False}))
+        conn.execute(rse.update().where(rse.c.availability.in_([0, 1, 2, 3])).values({"availability_read": False}))
+        conn.execute(rse.update().where(rse.c.availability.in_([0, 1, 4, 5])).values({"availability_write": False}))
+        conn.execute(rse.update().where(rse.c.availability.in_([0, 2, 4, 6])).values({"availability_delete": False}))
 
 
 def downgrade():

rucio/db/sqla/migrate_repo/versions/30d5206e9cad_increase_oauthrequest_redirect_msg_.py

@@ -0,0 +1,37 @@
+# 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.
+
+"""Increase OAuthRequest.redirect_msg length"""    # noqa: D400, D415
+
+import sqlalchemy as sa
+from alembic import context
+from alembic.op import alter_column
+
+# Alembic revision identifiers
+revision = '30d5206e9cad'
+down_revision = 'b0070f3695c8'
+
+
+def upgrade():
+    """Upgrade the database to this revision."""
+    if context.get_context().dialect.name in ['oracle', 'mysql', 'postgresql']:
+        schema = context.get_context().version_table_schema if context.get_context().version_table_schema else ''
+        alter_column('oauth_requests', 'redirect_msg', existing_type=sa.String(2048), type_=sa.String(4000), schema=schema)
+
+
+def downgrade():
+    """Downgrade the database to the previous revision."""
+    if context.get_context().dialect.name in ['oracle', 'mysql', 'postgresql']:
+        schema = context.get_context().version_table_schema if context.get_context().version_table_schema else ''
+        alter_column('oauth_requests', 'redirect_msg', existing_type=sa.String(4000), type_=sa.String(2048), schema=schema)