spark-migration 0.1.0__py3-none-any.whl

Migration/__init__.py

@@ -0,0 +1,6 @@
+"""Public interface for the Migration framework."""
+
+from Migration.service.main import Migration
+
+__all__ = ["Migration"]
+__version__ = "0.1.0"

Migration/engine/__init__.py

@@ -0,0 +1 @@
+"""Infraestrutura de conexao, tarefas e Spark."""

Migration/engine/connect.py

@@ -0,0 +1,72 @@
+from sqlalchemy import  create_engine, inspect, Engine
+from Migration.logs.logs import logger
+
+#Cria Conexão do banco de dados e retorna o nome de todas as tabelas
+
+class Engine:
+    def __init__(self, url:str, name:str)-> None:
+        
+        #Url que conecta com o banco de dados
+        self.__url = url
+        
+        self.name = name
+        
+        self.eng = self.con()
+    
+    #Cria a engine do banco de dados
+    def con(self) -> Engine:
+        
+        try:
+            logger.info(f"Connecting to database {self.name}...")
+            
+            eng = create_engine(
+                url=self.__url
+            )
+            
+            logger.info(f"Connected to database {self.name}.")
+            
+            return eng
+        
+        except Exception as error:
+            
+            raise Exception(error)
+     
+    #Pega todas as tabelas do banco e retorna em uma lista  
+    def tables(self) -> list:
+        
+        try:
+            logger.info(f"Discovering tables in database {self.name}...")
+            
+            inspector = inspect(self.eng)
+            
+            tables = inspector.get_table_names()
+            
+            logger.info(
+                f"Discovered {len(tables)} table(s): "
+                f"{', '.join(tables) if tables else '[none]'}"
+            )
+            
+            return tables
+        
+        except Exception as error:
+            
+            raise Exception(error)
+        
+    
+        
+        
+    
+        
+        
+        
+            
+        
+        
+        
+    
+        
+        
+        
+        
+        
+

Migration/engine/init_spark.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+from Migration.logs.logs import logger
+from pyspark.sql import SparkSession
+
+logger.info("Starting Spark session...")
+
+# Usa o driver que acompanha o projeto. No Windows, spark.jars.packages tenta
+# baixar/copiar o arquivo via Hadoop e exige winutils.exe/HADOOP_HOME.
+postgres_driver = (
+    Path(__file__).resolve().parents[1]
+    / "drivers"
+    / "postgresql-42.7.12.jar"
+)
+
+if not postgres_driver.is_file():
+    raise FileNotFoundError(f"Driver PostgreSQL nao encontrado: {postgres_driver}")
+
+driver_path = str(postgres_driver)
+
+app_spark = (
+    SparkSession.builder
+    .appName("Migration")
+    .master("local[*]")
+    .config("spark.driver.extraClassPath", driver_path)
+    .config("spark.executor.extraClassPath", driver_path)
+    .getOrCreate()
+)
+logger.info("Spark session started.")
+

Migration/engine/init_task.py

@@ -0,0 +1,61 @@
+from concurrent.futures import ThreadPoolExecutor
+from functools import wraps
+from queue import Queue
+
+from Migration.logs.logs import logger
+
+class Channel:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.queue = Queue()
+        logger.info(f"Channel {self.name} created.")
+
+    def send(self, result) -> None:
+        self.queue.put(result)
+
+    def get(self):
+        return self.queue.get()
+
+
+class Task:
+    """Executa tarefas em threads para compartilhar uma unica sessao Spark."""
+
+    def __init__(self, max_workers: int, name: str, channel: Channel) -> None:
+        self.name = name
+        self.channel = channel
+        self.executor = ThreadPoolExecutor(
+            max_workers=max_workers,
+            thread_name_prefix=name,
+        )
+
+    def run(self):
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                future = self.executor.submit(func, *args, **kwargs)
+
+                def finished(completed):
+                    try:
+                        self.channel.send(completed.result())
+                    except BaseException as error:
+                        self.channel.send(error)
+
+                future.add_done_callback(finished)
+                return future
+
+            return wrapper
+
+        return decorator
+
+
+# Canal onde vai receber o resultado das tasks.
+ch = Channel(name="Migrations")
+
+# Threads evitam criar uma JVM/SparkSession por tabela e excecoes nao precisam
+# ser serializadas entre processos.
+task = Task(
+    max_workers=4,
+    name="Migration_task",
+    channel=ch
+)
+

Migration/logs/__init__.py

@@ -0,0 +1 @@
+"""Configuracao de logs do framework."""

Migration/logs/global_logs.py

@@ -0,0 +1,9 @@
+#Cria a configuração global de logs
+import logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    handlers=[
+        logging.StreamHandler()
+    ]
+)

Migration/logs/logs.py

@@ -0,0 +1,4 @@
+#Pega a configuração global de logs
+from Migration.logs import global_logs
+import logging
+logger = logging.getLogger(__name__)

Migration/schema/__init__.py

@@ -0,0 +1 @@
+"""Modelos e controle da migracao de dados."""

Migration/schema/control.py

@@ -0,0 +1,101 @@
+from Migration.logs.logs import logger
+from Migration.engine.init_spark import app_spark
+from pyspark.sql import DataFrame
+import time
+
+#Essa classe serve para ler e transferir a tabela
+class SparkDb:
+    def __init__(
+        self,
+        url: str,
+        table_name: str,
+        new_url: str,
+        user: str,
+        password: str,
+        new_user: str,
+        new_password: str,
+    ) -> None:
+        
+        self.url = url
+        self.table = table_name
+        self.spark = app_spark
+        self.new_url = new_url
+        self.user = user
+        self.password = password
+        self.new_user = new_user
+        self.new_password = new_password
+        
+    #Le a tabela  
+    def read(self, max_attempts: int = 3)-> DataFrame:
+        for attempt in range(1, max_attempts + 1):
+            try:
+                logger.info(
+                    f"Reading table {self.table} "
+                    f"(attempt {attempt}/{max_attempts})"
+                )
+
+                df = (self.spark.
+                      read.format("jdbc").
+                      option("url", self.url).
+                      option("dbtable", self.table).
+                      option("driver", "org.postgresql.Driver").
+                      option("user", self.user).
+                      option("password", self.password).
+                      option("connectTimeout", "30").
+                      option("socketTimeout", "300").
+                      option("tcpKeepAlive", "true").
+                      load())
+
+                logger.info(f"Table {self.table} loaded.")
+                return df
+
+            except Exception as error:
+                if attempt == max_attempts:
+                    raise RuntimeError(
+                        f"Nao foi possivel ler a tabela {self.table} "
+                        f"apos {max_attempts} tentativas: {error}"
+                    ) from error
+
+                logger.warning(
+                    f"Temporary failure while reading {self.table}: {error}. "
+                    "Retrying..."
+                )
+                time.sleep(3 * attempt)
+        
+    #Salva no novo banco de dados
+    def save(self) -> None:
+        try:
+            logger.info(f"Writing table {self.table}...")
+            
+            (self.df.write.
+             format("jdbc").
+             option("url", self.new_url).
+             option("dbtable", self.table).
+             option("driver", "org.postgresql.Driver").
+             option("user", self.new_user).
+             option("password", self.new_password).
+             mode("append").save()
+             )
+            
+            logger.info(f"Table {self.table} written successfully.")
+            
+        except Exception as error:
+            raise Exception(error)
+        
+    def run(self) -> str:
+        self.df = self.read()
+        self.save()
+        return self.table
+    
+
+            
+        
+        
+    
+                
+            
+        
+        
+    
+        
+    

Migration/schema/model.py

@@ -0,0 +1,22 @@
+from urllib.parse import quote_plus
+#serve pra formatar od dados
+class Formate:
+    
+    def __init__(self, host:str, port:int, user:str, password:str, dbname:str)->None:
+        self.host = host
+        self.port = port
+        self.user = user
+        self.Pass = password
+        self.db = dbname
+       
+    #formata os dados de conexão pra url do spark   
+    def url_spark(self) -> str:
+        return f"jdbc:postgresql://{self.host}:{self.port}/{self.db}"
+    
+    #forma para url do sqlalchemy
+    def url_alchemy(self) ->str:
+         password = quote_plus(self.Pass)
+
+         return f"postgresql://{self.user}:{password}@{self.host}:{self.port}/{self.db}"
+            
+        

Migration/service/__init__.py

@@ -0,0 +1,2 @@
+"""Servico publico de migracao."""
+from Migration.service.main import Migration

Migration/service/main.py

@@ -0,0 +1,81 @@
+from Migration.logs.logs import logger
+from Migration.engine.connect import Engine
+from Migration.tasks.task_db import SaveDb
+from Migration.engine.init_task import ch
+from Migration.schema.model import Formate
+
+#Faz toda migração do banco de dados
+class Migration:
+    def __init__(self, data:dict, new_data:dict)->None:
+        
+        self.__url = Formate(
+            host=data["host"],
+            port=data["port"], 
+            dbname=data["dbname"],
+            password=data["password"],
+            user=data["user"]
+        )
+        
+        self.__newurl = Formate(
+            host=new_data["host"],
+            port=new_data["port"], 
+            dbname=new_data["dbname"],
+            password=new_data["password"],
+            user=new_data["user"]
+        )
+
+        self.__source_user = data["user"]
+        self.__source_password = data["password"]
+        self.__destination_user = new_data["user"]
+        self.__destination_password = new_data["password"]
+        
+        self.tables = Engine(url=self.__url.url_alchemy(), name=data["dbname"]).tables()
+        
+        self.channel = ch
+      
+    #Incia uma task para cada tabela do banco de dados  
+    def init_task(self)->None:
+        for table in self.tables:
+            SaveDb(
+                table_name=table,
+                url=self.__url.url_spark(),
+                new_url=self.__newurl.url_spark(),
+                user=self.__source_user,
+                password=self.__source_password,
+                new_user=self.__destination_user,
+                new_password=self.__destination_password,
+            )
+          
+    #Chama o metodo init_task para iniciar as tasks, e depois entra num loop e espera todas as tasks finalizarem  
+    def run(self) -> None:
+        logger.info("Starting database migration...")
+        
+        self.init_task()
+        
+        tables_finish = []
+        
+        while len(tables_finish) != len(self.tables):
+            
+            data = self.channel.get()
+
+            if isinstance(data, BaseException):
+                raise RuntimeError(f"Falha durante a migracao: {data}") from data
+
+            if data is not None:
+                logger.info(f"Table {data} migrated successfully.")
+                tables_finish.append(data)
+                
+        
+        logger.info("Database migration completed successfully.")
+                
+            
+                
+        
+        
+            
+        
+    
+        
+        
+        
+        

Migration/tasks/__init__.py

@@ -0,0 +1 @@
+"""Tarefas de migracao por tabela."""

Migration/tasks/task_db.py

@@ -0,0 +1,28 @@
+
+from Migration.engine.init_task import task
+from Migration.schema.control import SparkDb
+
+#Transforma todo sparkdb em uma task
+@task.run()
+def SaveDb(
+    url: str,
+    new_url: str,
+    table_name: str,
+    user: str,
+    password: str,
+    new_user: str,
+    new_password: str,
+):
+    tb = SparkDb(
+        url=url,
+        new_url=new_url,
+        table_name=table_name,
+        user=user,
+        password=password,
+        new_user=new_user,
+        new_password=new_password,
+    ).run()
+    return tb
+    
+
+

spark_migration-0.1.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: spark_migration
+Version: 0.1.0
+Summary: Spark Migration: framework concorrente para migracao de dados PostgreSQL com Apache Spark.
+Keywords: database,migration,postgresql,pyspark,spark,etl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyspark<5,>=4.0
+Requires-Dist: SQLAlchemy<3,>=2.0
+Requires-Dist: psycopg2-binary<3,>=2.9
+
+<div align="center">
+
+# Spark Migration
+
+### Um framework concorrente para migração de dados PostgreSQL com Apache Spark
+
+[![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![Apache Spark](https://img.shields.io/badge/Apache_Spark-4.x-E25A1C?style=for-the-badge&logo=apachespark&logoColor=white)](https://spark.apache.org/)
+[![PostgreSQL](https://img.shields.io/badge/PostgreSQL-Suportado-4169E1?style=for-the-badge&logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+[![Status](https://img.shields.io/badge/Status-Beta-F59E0B?style=for-the-badge)](#status-do-projeto)
+
+Descubra tabelas, execute tarefas concorrentes e transfira dados via JDBC usando uma única sessão Spark compartilhada.
+
+</div>
+
+---
+
+## Visão geral
+
+Spark Migration é um framework Python para copiar dados entre bancos PostgreSQL. Ele combina SQLAlchemy para inspecionar o banco de origem, Apache Spark para transferir os dados via JDBC e um conjunto controlado de threads para processar as tabelas concorrentemente.
+
+A API pública foi projetada para ser simples:
+
+```python
+Migration(data=origem, new_data=destino).run()
+```
+
+## Recursos
+
+- Descoberta automática das tabelas do banco de origem.
+- Leitura e escrita via JDBC com Apache Spark.
+- Execução concorrente de até quatro tabelas.
+- Uma única sessão Spark compartilhada entre todas as tarefas.
+- Até três tentativas para falhas temporárias de leitura.
+- Propagação de erros das tarefas para a thread principal.
+- Driver JDBC do PostgreSQL incluído no pacote.
+- Logs estruturados em inglês.
+
+## Como funciona
+
+```mermaid
+flowchart LR
+    A["PostgreSQL de origem"] -->|"Descobre tabelas"| B["SQLAlchemy"]
+    B --> C["Serviço Spark Migration"]
+    C -->|"Uma tarefa por tabela"| D["Pool de threads"]
+    D --> E["Sessão Spark compartilhada"]
+    E -->|"Leitura JDBC"| A
+    E -->|"Escrita JDBC em append"| F["PostgreSQL de destino"]
+    D -->|"Resultado ou erro"| C
+```
+
+1. `Migration` formata as configurações de conexão da origem e do destino.
+2. O SQLAlchemy conecta-se à origem e descobre suas tabelas.
+3. O serviço cria uma tarefa para cada tabela encontrada.
+4. Cada tarefa lê sua tabela em um DataFrame Spark via JDBC.
+5. O Spark adiciona o DataFrame à tabela correspondente no destino.
+6. A thread principal aguarda os resultados e interrompe a execução quando uma tarefa falha.
+
+## Requisitos
+
+- Python 3.10 ou superior.
+- Java 17 disponível no `PATH`.
+- Bancos PostgreSQL de origem e destino.
+- Acesso de rede aos dois bancos.
+- Permissão de leitura nas tabelas de origem.
+- Permissões de criação e inserção no destino.
+
+## Instalação
+
+Instale o Spark Migration e suas dependências diretamente pelo PyPI:
+
+```bash
+pip install spark_migration
+```
+
+Após a instalação, o framework é importado como `Migration`.
+
+## Uso rápido
+
+Mantenha as credenciais fora do código-fonte. Este exemplo utiliza variáveis de ambiente:
+
+```python
+import os
+
+from Migration import Migration
+
+origem = {
+    "host": os.environ["SOURCE_DB_HOST"],
+    "port": int(os.getenv("SOURCE_DB_PORT", "5432")),
+    "dbname": os.environ["SOURCE_DB_NAME"],
+    "user": os.environ["SOURCE_DB_USER"],
+    "password": os.environ["SOURCE_DB_PASSWORD"],
+}
+
+destino = {
+    "host": os.environ["DESTINATION_DB_HOST"],
+    "port": int(os.getenv("DESTINATION_DB_PORT", "5432")),
+    "dbname": os.environ["DESTINATION_DB_NAME"],
+    "user": os.environ["DESTINATION_DB_USER"],
+    "password": os.environ["DESTINATION_DB_PASSWORD"],
+}
+
+Migration(data=origem, new_data=destino).run()
+```
+
+Execute o arquivo normalmente:
+
+```bash
+python spark_migration.py
+```
+
+Exemplo de saída:
+
+```text
+INFO | Starting Spark session...
+INFO | Spark session started.
+INFO | Connecting to database postgres...
+INFO | Discovered 1 table(s): orders
+INFO | Starting database migration...
+INFO | Reading table orders (attempt 1/3)
+INFO | Table orders written successfully.
+INFO | Database migration completed successfully.
+```
+
+## Configuração da conexão
+
+Os parâmetros `data` e `new_data` recebem os mesmos campos:
+
+| Campo | Tipo | Descrição |
+| --- | --- | --- |
+| `host` | `str` | Endereço ou IP do servidor PostgreSQL |
+| `port` | `int` | Porta do PostgreSQL, normalmente `5432` |
+| `dbname` | `str` | Nome do banco de dados |
+| `user` | `str` | Usuário do banco |
+| `password` | `str` | Senha do banco |
+
+## Comportamento da escrita
+
+A versão atual utiliza o modo `append` do Spark.
+
+- Se a tabela não existir no destino, o Spark a criará com base no DataFrame.
+- Se a tabela já existir, os novos registros serão adicionados.
+- Executar a mesma migração mais de uma vez pode duplicar os dados.
+- Uma falha durante a escrita pode deixar dados parciais no destino.
+
+Utilize um destino limpo para migrações completas e compare a quantidade de registros na origem e no destino antes de repetir uma execução.
+
+## Escopo e limitações atuais
+
+O framework atualmente migra os registros das tabelas. Ele ainda não reproduz todos os objetos e configurações do PostgreSQL, incluindo:
+
+- chaves primárias e estrangeiras;
+- índices e restrições únicas;
+- sequências e seus valores atuais;
+- views e materialized views;
+- triggers e funções armazenadas;
+- usuários, permissões e políticas de segurança em nível de linha;
+- extensões e configurações do banco.
+
+Em migrações de produção, recrie e valide esses objetos separadamente.
+
+## Observações para Windows
+
+O Spark pode informar que `winutils.exe`, `HADOOP_HOME` ou a biblioteca nativa do Hadoop não estão disponíveis. O framework carrega diretamente o driver JDBC incluído no pacote, portanto esses avisos não impedem o fluxo suportado de migração PostgreSQL.
+
+Se o Spark não iniciar, confirme se o Java 17 está instalado:
+
+```powershell
+java -version
+```
+
+## Solução de problemas
+
+### `Connection reset`
+
+O banco ou o gerenciador de conexões encerrou a conexão JDBC. O framework repete automaticamente a leitura até três vezes. Se o problema continuar, verifique o estado do banco, a estabilidade da rede, os requisitos de SSL e os limites do pool de conexões.
+
+### `Migration failed`
+
+A thread principal recebeu uma exceção de uma tarefa. Procure o primeiro erro de banco ou Spark exibido antes dessa mensagem; normalmente ele contém a causa real.
+
+### Porta da interface Spark ocupada
+
+O Spark pode selecionar outra porta quando a porta local `4040` já estiver em uso. Isso é apenas informativo e normalmente não impede a migração.
+
+## Segurança
+
+- Nunca inclua senhas de banco ou tokens do PyPI no repositório.
+- Prefira variáveis de ambiente ou um gerenciador de segredos.
+- Utilize usuários de banco dedicados e com as menores permissões necessárias.
+- Troque credenciais que já tenham sido publicadas ou compartilhadas.
+
+## Status do projeto
+
+Spark Migration está em fase **Beta**. A migração de registros entre bancos PostgreSQL está funcional. Modos de escrita idempotentes, migração completa do esquema, validação automática e suporte a outros bancos ainda estão em desenvolvimento.
+
+## Roadmap
+
+- Modos configuráveis `append`, `overwrite` e falha se a tabela existir.
+- Validação por quantidade de registros e checksum.
+- Migração de esquema, restrições, índices e sequências.
+- Filtros para incluir ou excluir tabelas.
+- Configuração de concorrência e tentativas.
+- Testes automatizados e integração contínua.
+- Suporte a outros bancos compatíveis com JDBC.

spark_migration-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+Migration/__init__.py,sha256=JtzEERalzJ2xAzBMpj1jlRT1d81Yv1mvX9EQZUWsglQ,145
+Migration/drivers/postgresql-42.7.12.jar,sha256=Mfv28GsiF_tR1RAM7lGyJiXMgWQNoGebR5FOVMHmN3w,1142967
+Migration/engine/__init__.py,sha256=ajUXJJV8VDSRl7qc7OipiHsNMNRNNNQHuLZqMpd9pfo,50
+Migration/engine/connect.py,sha256=uy868FKvtDQ3S8Kj3qG80E034e_0lt5bSPqx_vi67Cg,1668
+Migration/engine/init_spark.py,sha256=WjOui1-iTVnA4t8Y9dSj8pU9BuGe49rotGg9eF8cf1A,824
+Migration/engine/init_task.py,sha256=ncXzjJR4eWdvuRNMULPGSi3VLFAA8W916laXb-FOP0g,1611
+Migration/logs/__init__.py,sha256=iQGKX8Zm99lSQHX0WBxs6Q7y7qc4md3f3r08doBvaXo,41
+Migration/logs/global_logs.py,sha256=6Ao5j5slSVlWc-onCNYhtwmyKYt3TdnBmsCGVi8A3YY,227
+Migration/logs/logs.py,sha256=bseukWs_zC7PlQNefACYQ6B0mZ-ewHBiMGt8mPlZSi4,131
+Migration/schema/__init__.py,sha256=_0HAthGwzgZtiSQavueq9k2HPN-_PIbEGLq-AzxdxV4,47
+Migration/schema/control.py,sha256=PQf9gwuyuMchhwcNaUMi8EVWIfgLy5FPbgV_f2zcmTw,3017
+Migration/schema/model.py,sha256=QpzLfS7hd5_0pSAzLH3_Dyt5v3Yf8QHpa2qWdGZjoro,710
+Migration/service/__init__.py,sha256=lWYZMmb44ppJCxyT8F0rNmCq_uxlnYz-PO21WL94AVI,79
+Migration/service/main.py,sha256=cBSW0cbDma2_qk0r5q3QuL1QCMcyvLjN72e8MD25bRI,2544
+Migration/tasks/__init__.py,sha256=m-u01YlHrlaPH_bXt2Oif7zGmJYv2iXJtCg-DnvP8WM,38
+Migration/tasks/task_db.py,sha256=o3MultPt5heTUB-AYV4NHEOpG3miT-kP8guMkBOlTOk,524
+spark_migration-0.1.0.dist-info/METADATA,sha256=kftNcLML8L7hJ5VHundpIF3bqTinJo_uZgD6dmLx-AA,8692
+spark_migration-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+spark_migration-0.1.0.dist-info/top_level.txt,sha256=1osF59DZ2sfzNrY8VhBFNkNEscA2EUSgbJ7h7HsSHkc,10
+spark_migration-0.1.0.dist-info/RECORD,,

spark_migration-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

spark_migration-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+Migration