dataflow-core 2.1.14rc1__py3-none-any.whl → 2.1.15rc2__py3-none-any.whl

dataflow/secrets_manager/providers/gcp_manager.py

@@ -0,0 +1,332 @@
+import os, base64, json, atexit
+from pathlib import Path
+from google.cloud import secretmanager
+from google.cloud.secretmanager_v1 import SecretManagerServiceClient
+from google.cloud.secretmanager_v1.types import Secret, SecretPayload
+from google.api_core.exceptions import (
+    AlreadyExists,
+    NotFound,
+    PermissionDenied,
+    Forbidden,
+    ResourceExhausted,
+    InvalidArgument,
+    FailedPrecondition
+)
+import json
+from ..interface import SecretManager
+from ...utils.exceptions import (
+    SecretNotFoundException,
+    SecretAlreadyExistsException,
+    SecretManagerAuthException,
+    SecretManagerServiceException
+)
+
+def _setup_gcp_credentials():
+    """Setup GCP credentials from base64 encoded JSON environment variable"""
+    
+    # Only run if GOOGLE_APPLICATION_CREDENTIALS is not already set
+    if os.getenv('GOOGLE_APPLICATION_CREDENTIALS'):
+        return
+    
+    # Get base64 encoded JSON credentials
+    encoded_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS_JSON')
+    
+    if encoded_json:
+        try:
+            # Decode base64 to JSON string
+            json_credentials = base64.b64decode(encoded_json).decode('utf-8')
+            
+            # Validate it's valid JSON
+            json.loads(json_credentials)  # Just to validate
+            
+            # Create credentials file in home directory
+            home_dir = Path.home()
+            credentials_dir = home_dir / '.gcp'
+            credentials_dir.mkdir(exist_ok=True)  # Create .gcp directory if it doesn't exist
+            
+            credentials_path = credentials_dir / 'credentials.json'
+            
+            # Write JSON string to credentials file
+            with open(credentials_path, 'w') as f:
+                f.write(json_credentials)
+            
+            # Set the standard Google environment variable that the SDK looks for
+            os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = str(credentials_path)
+            
+            # Clean up file on exit
+            atexit.register(lambda: credentials_path.unlink() if credentials_path.exists() else None)
+            
+            print(f"GCP credentials decoded and configured at {credentials_path}")
+            
+        except Exception as e:
+            print(f"Error setting up GCP credentials: {e}")
+
+
+class GCPSecretsManager(SecretManager):
+    """Google Cloud Platform Secrets Manager implementation."""
+
+    def __init__(self, project_id: str, region: str):
+        """Initialize the GCP Secret Manager client.
+        
+        Args:
+            project_id: The GCP project ID where secrets will be stored.
+            region: The GCP region where secrets will be stored.
+        """
+        self.project_id = project_id
+        self.region = region
+        try:
+            _setup_gcp_credentials()
+            self.client = secretmanager.SecretManagerServiceClient()
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("initialize_gcp_client", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("initialize_gcp_client", original_error=str(e))
+    
+    def _get_secret_path(self, vault_path: str) -> str:
+        """Get the full secret path in GCP format.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            
+        Returns:
+            The full path to the secret in GCP format.
+        """
+        return f"projects/{self.project_id}/secrets/{vault_path}"
+    
+    def _get_secret_version_path(self, vault_path: str, version: str = "latest") -> str:
+        """Get the full path to a specific secret version.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            version: The version of the secret (default is "latest").
+            
+        Returns:
+            The full path to the secret version in GCP format.
+        """
+        return f"{self._get_secret_path(vault_path)}/versions/{version}"
+    
+    def create_secret(self, vault_path: str, secret_data: dict) -> str:
+        """Create a new secret.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            region: The region where the secret will be stored.
+            secret_data: The data to store in the secret.
+            
+        Returns:
+            A success message.
+            
+        Raises:
+            SecretAlreadyExistsException: If the secret already exists.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Convert dictionary to JSON string before saving
+            secret_string = json.dumps(secret_data)
+            
+            # First create the secret
+            parent = f"projects/{self.project_id}"
+            secret = Secret(
+                replication={
+                    "user_managed": {
+                        "replicas": [
+                            {"location": self.region }
+                        ]
+                    }
+                }
+            )
+            
+            self.client.create_secret(
+                request={
+                    "parent": parent,
+                    "secret_id": vault_path,
+                    "secret": secret
+                }
+            )
+            
+            # Then add the secret version with the data
+            secret_path = self._get_secret_path(vault_path)
+            self.client.add_secret_version(
+                request={
+                    "parent": secret_path,
+                    "payload": {"data": secret_string.encode("UTF-8")}
+                }
+            )
+            
+            return "Secret created successfully"
+        except AlreadyExists as e:
+            raise SecretAlreadyExistsException("secret", vault_path, original_error=str(e))
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("create_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("create_secret", original_error=str(e))
+        except FailedPrecondition as e:
+            # Handle case where secret might be in recovery/deleted state
+            if "pending deletion" in str(e).lower() or "scheduled for deletion" in str(e).lower():
+                raise SecretAlreadyExistsException("secret", vault_path, original_error=str(e), is_scheduled_for_deletion=True)
+            else:
+                raise SecretManagerServiceException("create_secret", original_error=str(e))
+        except ResourceExhausted as e:
+            raise SecretManagerServiceException("create_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("create_secret", original_error=str(e))
+    
+    def get_secret_by_key(self, vault_path: str) -> dict:
+        """Get a secret by its key.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            
+        Returns:
+            The secret data as a dictionary.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Get the latest version of the secret
+            name = self._get_secret_version_path(vault_path)
+            response = self.client.access_secret_version(request={"name": name})
+            
+            # Decode the payload and convert JSON string back to dictionary
+            secret_string = response.payload.data.decode("UTF-8")
+            secret_data = json.loads(secret_string)
+            return secret_data
+        except NotFound as e:
+            raise SecretNotFoundException("secret", vault_path, original_error=str(e))
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("get_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("get_secret", original_error=str(e))
+        except InvalidArgument as e:
+            raise SecretManagerServiceException("get_secret", original_error=str(e))
+        except json.JSONDecodeError as e:
+            raise SecretManagerServiceException("get_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("get_secret", original_error=str(e))
+    
+    def update_secret(self, vault_path: str, update_data: dict) -> str:
+        """Update an existing secret.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            update_data: The data to update in the secret.
+            
+        Returns:
+            A success message.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Get current secret data
+            current_data = self.get_secret_by_key(vault_path)
+            
+            # Update with new data
+            current_data.update(update_data)
+            
+            # Convert updated dictionary to JSON string
+            updated_string = json.dumps(current_data)
+            
+            # Add a new version of the secret with updated data
+            secret_path = self._get_secret_path(vault_path)
+            self.client.add_secret_version(
+                request={
+                    "parent": secret_path,
+                    "payload": {"data": updated_string.encode("UTF-8")}
+                }
+            )
+            
+            return "Secret updated successfully"
+        except SecretNotFoundException:
+            raise
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("update_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("update_secret", original_error=str(e))
+        except NotFound as e:
+            raise SecretNotFoundException("secret", vault_path, original_error=str(e))
+        except InvalidArgument as e:
+            raise SecretManagerServiceException("update_secret", original_error=str(e))
+        except json.JSONDecodeError as e:
+            raise SecretManagerServiceException("update_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("update_secret", original_error=str(e))
+    
+    def delete_secret(self, vault_path: str) -> str:
+        """Delete a secret.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            
+        Returns:
+            A success message.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Get the full path to the secret
+            name = self._get_secret_path(vault_path)
+            
+            # For git-ssh secrets, destroy without recovery
+            if "git-ssh" in vault_path:
+                # Get all versions to destroy them permanently
+                versions = self.client.list_secret_versions(request={"parent": name})
+                for version in versions:
+                    if version.state == secretmanager.SecretVersion.State.ENABLED:
+                        version_name = f"{name}/versions/{version.name.split('/')[-1]}"
+                        self.client.destroy_secret_version(request={"name": version_name})
+                
+                # Delete the secret itself
+                self.client.delete_secret(request={"name": name})
+            else:
+                # For regular secrets, use the default 7-day recovery window
+                self.client.delete_secret(request={
+                    "name": name,
+                    # In GCP, the recovery window is configured at the service level, 
+                    # not per API call, so we don't specify it here
+                })
+            
+            return "Secret deleted successfully"
+        except NotFound as e:
+            raise SecretNotFoundException("secret", vault_path, original_error=str(e))
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("delete_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("delete_secret", original_error=str(e))
+        except InvalidArgument as e:
+            raise SecretManagerServiceException("delete_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("delete_secret", original_error=str(e))
+    
+    def test_connection(self, vault_path: str) -> str:
+        """Test the connection to the secret manager by attempting to access a secret.
+        
+        Args:
+            vault_path: The path/name of the secret to test.
+            
+        Returns:
+            The status of the secret.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            secret = self.get_secret_by_key(vault_path)
+            return secret.get('status', 'Unknown')
+        except SecretNotFoundException:
+            raise
+        except (SecretManagerAuthException, SecretManagerServiceException):
+            raise
+        except Exception as e:
+            raise SecretManagerServiceException("test_connection", original_error=str(e))

dataflow/secrets_manager/service.py

@@ -117,27 +117,29 @@ class _BaseAccessor(ABC):
 # These classes implement the logic for building the vault path based on the context.
 # --------------------------------------------------------------------------
 class _RuntimeAccessor(_BaseAccessor):
-    def __init__(self, secret_manager: SecretManager, runtime_env: str, slug: str = None):
+    def __init__(self, secret_manager: SecretManager, org_id: str, runtime_env: str, slug: str = None):
         super().__init__(secret_manager)
+        self.org_id = org_id
         self.runtime_env = runtime_env
         self.slug = slug
 
     def _get_vault_path(self, secret_type: str, key: str) -> str:
         # Special case for git-ssh in runtime context
         if secret_type == "git-ssh":
-            return f"{self.runtime_env}-{secret_type}-{self.slug}"
+            return f"{self.org_id}-{self.runtime_env}-{secret_type}-{self.slug}"
 
         # Standard format for all other secret types
         context = self.slug if self.slug else "global"
-        return f"{self.runtime_env}-{context}-{secret_type}-{key}"
+        return f"{self.org_id}-{self.runtime_env}-{context}-{secret_type}-{key}"
 
 class _StudioAccessor(_BaseAccessor):
-    def __init__(self, secret_manager: SecretManager, user_name: str):
+    def __init__(self, secret_manager: SecretManager, org_id: str, user_name: str):
         super().__init__(secret_manager)
+        self.org_id = org_id
         self.user_name = user_name
 
     def _get_vault_path(self, secret_type: str, key: str) -> str:
-        return f"{self.user_name}-{secret_type}-{key}"
+        return f"{self.org_id}-{self.user_name}-{secret_type}-{key}"
 
 # --------------------------------------------------------------------------
 # PUBLIC INTERFACE CLASS
@@ -147,10 +149,10 @@ class SecretsService:
     def __init__(self, secret_manager: SecretManager):
         self._secret_manager = secret_manager
 
-    def runtime(self, env: str, slug: str = None) -> _RuntimeAccessor:
+    def runtime(self, org_id: int, env: str, slug: str = None) -> _RuntimeAccessor:
         """Sets the context to RUNTIME and returns the appropriate accessor."""
-        return _RuntimeAccessor(self._secret_manager, env, slug)
+        return _RuntimeAccessor(self._secret_manager, str(org_id), env, slug)
 
-    def studio(self, user: str) -> _StudioAccessor:
+    def studio(self, org_id: int, user: str) -> _StudioAccessor:
         """Sets the context to STUDIO and returns the appropriate accessor."""
-        return _StudioAccessor(self._secret_manager, user)
+        return _StudioAccessor(self._secret_manager, str(org_id), user)

dataflow/utils/get_current_user.py

@@ -1,37 +1,60 @@
-from fastapi import HTTPException, status
+from fastapi import HTTPException
 from sqlalchemy.orm import Session
-from dataflow.models import user as m_user  
-from dataflow.models import session as m_session
+from sqlalchemy import and_
+from dataflow.models import (
+    user as m_user,
+    session as m_session,
+    org_associations as m_org_associations,
+    role as m_role,
+    organization as m_organization
+)
 
 def get_user_from_session(session_id: str, db: Session):
     """
-    Retrieve a user based on session ID.
-    
-    Args:
-        session_id (str): The unique session identifier
-        db (Session): Database session
-        
-    Returns:
-        User: User object if found
-        
-    Raises:
-        HTTPException: If session is invalid or user not found
+    Retrieve user information based on the session ID.
     """
-    session_record = db.query(m_session.Session).filter(m_session.Session.session_id == session_id).first()
-    if not session_record:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid session")
+    user = (
+        db.query(
+            m_user.User,
+            m_org_associations.OrganizationUser.role_id,
+            m_role.Role.name,
+            m_role.Role.base_role,
+            m_org_associations.OrganizationUser.active_server_id,
+            m_org_associations.OrganizationUser.show_server_page,
+            m_org_associations.OrganizationUser.active_env_short_name,
+            m_org_associations.OrganizationUser.active_env_type,
+            m_org_associations.OrganizationUser.monthly_allocation,
+            m_organization.Organization.uid
+        )
+        .join(m_session.Session, m_session.Session.user_id == m_user.User.user_id)
+        .outerjoin(
+            m_org_associations.OrganizationUser,
+            and_(
+                m_org_associations.OrganizationUser.user_id == m_user.User.user_id,
+                m_org_associations.OrganizationUser.org_id == m_user.User.active_org_id
+            )
+        )
+        .outerjoin(m_role.Role, m_role.Role.id == m_org_associations.OrganizationUser.role_id)
+        .outerjoin(
+            m_organization.Organization,
+            m_organization.Organization.id == m_user.User.active_org_id  # join to Organization
+        )
+        .filter(m_session.Session.session_id == session_id)
+        .first()
+    )
 
-    user = db.query(m_user.User).filter(m_user.User.user_id == session_record.user_id).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
-
-    base_role = user.role_details.base_role
-    role_id = user.role_details.id
-    role_name = user.role_details.name
-    user.base_role = base_role
-    user.role = role_name
-    user.role_id = role_id
-    
-    return user
+        raise HTTPException(status_code=401, detail="Invalid session")
 
+    user_obj, role_id, role_name, base_role, active_server_id, show_server_page, active_env_short_name, active_env_type, monthly_allocation, uid = user
+    user_obj.role_id = role_id
+    user_obj.role = role_name
+    user_obj.base_role = base_role
+    user_obj.current_server_id = active_server_id
+    user_obj.show_server_page = show_server_page
+    user_obj.active_env = active_env_short_name
+    user_obj.active_env_type = active_env_type
+    user_obj.monthly_allocation = monthly_allocation
+    user_obj.org_uid = str(uid)
 
+    return user_obj

{dataflow_core-2.1.14rc1.dist-info → dataflow_core-2.1.15rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataflow-core
-Version: 2.1.14rc1
+Version: 2.1.15rc2
 Summary: Dataflow core package
 Author: Dataflow
 Author-email: 
@@ -11,6 +11,8 @@ Requires-Dist: pymysql
 Requires-Dist: requests
 Requires-Dist: azure-identity
 Requires-Dist: azure-keyvault-secrets
+Requires-Dist: google-auth
+Requires-Dist: google-cloud-secret-manager
 Dynamic: author
 Dynamic: requires-dist
 Dynamic: summary

{dataflow_core-2.1.14rc1.dist-info → dataflow_core-2.1.15rc2.dist-info}/RECORD

@@ -1,37 +1,38 @@
 authenticator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-authenticator/dataflowairflowauthenticator.py,sha256=Gp-QR83Dh3-z4kQ3EVBr6bY6FP88ICkok7QOO60pOPg,2467
-authenticator/dataflowhubauthenticator.py,sha256=wI9S-1pcav_WHUL4ibEn-HLhjOtZebQbqXTkcrXXFAA,13463
+authenticator/dataflowairflowauthenticator.py,sha256=gEdCiL2yJQ7lYvAwbrjcAkccVMfehoMJldw9eU7cc2s,2243
+authenticator/dataflowhubauthenticator.py,sha256=drs6M9tp0QFLzmj-eNaa6zefKat9cN0cJvwGLrSeYvQ,12531
 authenticator/dataflowsupersetauthenticator.py,sha256=NkAmDaIc-ui-qEolu4xz_UY7P_2g8111hwNjPvAOW1Q,2839
 dataflow/__init__.py,sha256=WTRg8HMpMWSgxYJ9ZGVldx4k07fAbta3mBmZ1hG9mWE,30
 dataflow/configuration.py,sha256=7To6XwH1eESiYp39eqPcswXWwrdBUdPF6xN6WnazOF0,663
 dataflow/database_manager.py,sha256=tJHMuOZ9Muskrh9t4uLRlTuFU0VkHAzoHlGP5DORIC4,899
-dataflow/dataflow.py,sha256=0kPDIpFgrEcK81QYeLQGb-rQTrAH-83gLpn566yvBGA,14004
+dataflow/dataflow.py,sha256=EzeOMtMCqG0WJ0vld6ArKbKNFAmA9sbjBqVJ8sd2sQw,13026
 dataflow/db.py,sha256=73ojGqpCTRVTlPszD73Ozhjih_BI2KTHmazqxxL6iWk,3780
-dataflow/environment.py,sha256=qiyuRRPpVLVWiYccRHXnGyWMr_ZBPWzixAyDtAzxQYE,28277
-dataflow/models/__init__.py,sha256=5Ai-sUHtT1dtc0l4nL1fuwVbx0GcwaGQg_LXqOzWb4c,981
-dataflow/models/app_types.py,sha256=yE_ZB13lhpK7AZ7PyBwnQlf0RlIHYs_-vdMKx7_RMlY,379
+dataflow/environment.py,sha256=7XiSojSIOnMOz5YVk-k6w1yQCKbBTTvUxv5cnn6cqJg,28830
+dataflow/models/__init__.py,sha256=UKaiCxJJLXvWOqZlHmDWr9fTwBncKbnyjSIsPWKvlVI,1167
+dataflow/models/app_types.py,sha256=NMHUHBoGnxYHbtlBVppNqQ6NW2T6pSedmQ6-T4t2JAc,640
 dataflow/models/blacklist_library.py,sha256=B2oi3Z8GcR_glhLAyinFk0W8c9txXvm3uOER6dY-q7I,991
-dataflow/models/connection.py,sha256=_VJL3KuIrm8t4lJmtunIL3-AXF9Yvi5wUolzdR3tE0E,1017
-dataflow/models/dataflow_zone.py,sha256=yFCvQXos5M1cU7ksbVSO338_RkT3hkdw2wr3kCJ_rec,769
-dataflow/models/environment.py,sha256=3W-Pvkuiufjw0MWy9F6uWSd0HDPjRNNJe3TnhpHxcGg,2920
+dataflow/models/connection.py,sha256=Kv0vo4V5z7EBfJUSnXWxKOB-AXPWIte9ttauNdM5lyk,1127
+dataflow/models/dataflow_zone.py,sha256=ScCM7963Rd5G4e4eFQGF0gNeg6abaWEwIgGOqoezfrg,719
+dataflow/models/environment.py,sha256=Pnma45hzDdr5jQ0k6mSAH6eZQGTQWm87AnebovtVBdU,3263
 dataflow/models/environment_status.py,sha256=lvPDNUsUoTW9D97B07aKqJQHRKp4LvPM28pQDMPH1ac,536
-dataflow/models/git_ssh.py,sha256=W15SDypxzGOz_aZkHEnVZ6DIMVsjAsbSIXVIEt2mPYU,694
+dataflow/models/git_ssh.py,sha256=xRkzK8lZ4Fa25zhE3Y9J78BiWv6xtd10YDBNf1XDKXE,797
+dataflow/models/org_associations.py,sha256=Kw1zK-Rg97GBV6U61O5V57sohPTHSchalMDAelo2hUQ,1915
+dataflow/models/organization.py,sha256=SGonZsaGRPu7Z9VLqFE32l68mwLdlki-OLxqdMpHtyU,3353
 dataflow/models/pinned_projects.py,sha256=I-XMQq7__XJJi2lyOdEvQEfhPRz8D6KHA6Cbavbf05o,606
 dataflow/models/pod_activity.py,sha256=4NQplUtckS4d2Uc-Iyi8PfgciblHiExbXo_VTMaukB8,751
 dataflow/models/pod_session_history.py,sha256=-O8DHtH1AtGLntJ1shI6eiciTJGL_vYvG3gfupvr0zY,778
-dataflow/models/project_details.py,sha256=iNb95L3UGjcC_Ws6FiUTDANCUFhYWpnsKraS6rmCyRU,1098
+dataflow/models/project_details.py,sha256=pjunEIjgFW66N7kP23cVtRU37LVOnKaqT8K7WBekAVg,1260
 dataflow/models/recent_project_studio.py,sha256=m12KGCsv453C1ijHjfVD8E7cJ7Og_0N8uc7_9VlfkYw,812
 dataflow/models/recent_projects.py,sha256=OFd5MSRXVRHs9UbvUNoJBBnh9rgsJ0lwE23wm5_Hc5w,321
-dataflow/models/role.py,sha256=0fgLjCx7aETRwCV5SW0-4PQBWzWddWO9a_ObJA14VOY,962
-dataflow/models/role_server.py,sha256=mMcfjsGX1cY8hOAOBBmrZgw8ozdfuvjKJoBlR6F0Kdc,689
+dataflow/models/role.py,sha256=LQoEWSc_Pm79IjNC1uFKGFfkhaZkhI3JSq6Sj6Xrm_g,1266
+dataflow/models/role_server.py,sha256=Qz9VqGSpVGvfLz9_lKITUfkiuR7pmVc8SIIfYrDPDso,547
 dataflow/models/role_zone.py,sha256=uH8JheWyzUWcRECRzYuzdphUAUXeU5zRVA1Bhuz3h9w,772
-dataflow/models/server_config.py,sha256=8ocKT8tPen9tedO8BLPEfkWxUEIHaqvA2L-qEhrFND0,1385
+dataflow/models/server_config.py,sha256=Npf4xP7zQ6eXp9kqwM9Owsm8C0e8Qw6jei2YX5k0in0,1646
 dataflow/models/session.py,sha256=c8TI6qXsM8utzp5vSQtAOXJSbgasnyu-a0qSAvA-rWs,459
-dataflow/models/team.py,sha256=fjkqF0N4PSwSYTgHjEQl9wuC7yumd0iOb5nNFePI6q4,488
-dataflow/models/user.py,sha256=-XEpulg7UAL-WDMyigPasDS61btna2mKtJPsanWA4lw,1108
-dataflow/models/user_environment.py,sha256=yI9NutULcLiwlycuEin6ROe6o1Sjdv_sgw2MEkJFeYg,568
-dataflow/models/user_team.py,sha256=r_fmKvf6JuGgiiI9TXWjVG2QZ3WOvDrOwYWVQ3r8oWo,659
-dataflow/models/variables.py,sha256=thWqX9KbR2x0oBI-bVcW5TV1eKf0TYNxgGmZWTUs2g4,1414
+dataflow/models/team.py,sha256=u5VKOxi-0wGgxssIhXr1Ydn3X9IEAHNWxz029KaVm5g,780
+dataflow/models/user.py,sha256=XSd3PuqMRzm4qglNaUF0S-9RjH_f016eZX4I0iDtq2Q,2856
+dataflow/models/user_team.py,sha256=vD6BsiMfx1iIMQiT8fpwhsQ8AGuPuBO83F22Cy7j-nU,524
+dataflow/models/variables.py,sha256=v6a1r5OgmKOAlyVdmOFM6Axre7DEBEsgrF4yTV5h3U0,1524
 dataflow/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/schemas/connection.py,sha256=ut2sqz06yOjmFKzHry92FEt7DN09Bj30GYse35__Cuw,2467
 dataflow/schemas/git_ssh.py,sha256=N1O7HM6ZbygIBZn2rKvNR0e7IM3ZJMAH6aJtjaghDr0,1283
@@ -40,18 +41,19 @@ dataflow/scripts/clone_environment.sh,sha256=Qy0GylsA3kUVUL_L1MirxIWujOFhT1tikKq
 dataflow/scripts/create_environment.sh,sha256=3FHgNplJuEZvyTsLqlCJNX9oyfXgsfqn80VZk2xtvso,828
 dataflow/scripts/update_environment.sh,sha256=2dtn2xlNi6frpig-sqlGE1_IKRbbkqYOCpf_qyMKKII,992
 dataflow/secrets_manager/__init__.py,sha256=idGqIDtYl0De2WIK9Obl-N7SDPSYtVM0D-wXfZjCiy4,559
-dataflow/secrets_manager/factory.py,sha256=k1sIyXBKtas1upWJpq8Mks2d8kjLAHU7CFvjeuMXXxs,2160
+dataflow/secrets_manager/factory.py,sha256=LblshkGG9q2C3RHYp0QykianUtpOOQz7sBdlerutyWY,2479
 dataflow/secrets_manager/interface.py,sha256=HhrKpQrprWIbDsVfU_qc59OXmSIuHXv106OXv6-Epqc,506
-dataflow/secrets_manager/service.py,sha256=SSWgTXJTAwVPqMIc76cB2hR6nghNVOoMpIN9M0i7Su0,7241
+dataflow/secrets_manager/service.py,sha256=A4PgiSS1bzlzXPi_GvsiepChULqAa5yONGkaU-d5MLM,7419
 dataflow/secrets_manager/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/secrets_manager/providers/aws_manager.py,sha256=16peXyKeuAjv2RVTMUjrzArPYENK9Zu7jREWVgMfScA,8671
 dataflow/secrets_manager/providers/azure_manager.py,sha256=sWOz-7ALnLt6vyM3lt14GBpzpmDnlH3hkdqtuApqkgU,9430
+dataflow/secrets_manager/providers/gcp_manager.py,sha256=AJgotHZRQraxtmfJX1Z8u2Gcr7KJLRJTN_qbth3A5Xk,13738
 dataflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/utils/exceptions.py,sha256=8GRFoYZ5dPGQckVm2znaHpPi0ZAs69fK-RGKukEsapk,4432
-dataflow/utils/get_current_user.py,sha256=4nSO3SPVMZhW-MsIgxR3f9ZzrFaIZIuyrM6hvfyE7PQ,1202
+dataflow/utils/get_current_user.py,sha256=iPyUpEpuxitdmFwvaPiRWIlII8JaaGoxUhQcmNWi0vI,2319
 dataflow/utils/logger.py,sha256=7BFrOq5Oiqn8P4XZbgJzMP5O07d2fpdECbbfsjrUuHw,1213
-dataflow_core-2.1.14rc1.dist-info/METADATA,sha256=akGTrwmInmlMGEyHbPlFx7lpwLE8l03du5zHb9UxEOc,373
-dataflow_core-2.1.14rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dataflow_core-2.1.14rc1.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
-dataflow_core-2.1.14rc1.dist-info/top_level.txt,sha256=SZsUOpSCK9ntUy-3Tusxzf5A2e8ebwD8vouPb1dPt_8,23
-dataflow_core-2.1.14rc1.dist-info/RECORD,,
+dataflow_core-2.1.15rc2.dist-info/METADATA,sha256=t8vhx-r4NQ9rhkLblo_9sZRH1nvOnaYH7UpkqBPUaCw,443
+dataflow_core-2.1.15rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dataflow_core-2.1.15rc2.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
+dataflow_core-2.1.15rc2.dist-info/top_level.txt,sha256=SZsUOpSCK9ntUy-3Tusxzf5A2e8ebwD8vouPb1dPt_8,23
+dataflow_core-2.1.15rc2.dist-info/RECORD,,

dataflow/models/user_environment.py

@@ -1,16 +0,0 @@
-from sqlalchemy import Column, Integer, String, DateTime
-from sqlalchemy.sql.schema import ForeignKey
-from sqlalchemy.sql.expression import func
-from dataflow.db import Base
-
-class UserEnvironment(Base):
-    """
-    Table USER_ENVIRONMENT
-    """
-
-    __tablename__ = 'USER_ENVIRONMENT'
-
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    user_id = Column(Integer, ForeignKey('USER.user_id', ondelete="CASCADE"), nullable=False)
-    env_name = Column(String)
-    timestamp = Column(DateTime, server_default=func.now(), onupdate=func.now())