Example #1
0
 def execute(self, context: "Context"):
     hook = DataprocMetastoreHook(
         gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain
     )
     self.log.info("Deleting Dataproc Metastore service: %s", self.project_id)
     operation = hook.delete_service(
         region=self.region,
         project_id=self.project_id,
         service_id=self.service_id,
         retry=self.retry,
         timeout=self.timeout,
         metadata=self.metadata,
     )
     hook.wait_for_operation(self.timeout, operation)
     self.log.info("Service %s deleted successfully", self.project_id)
Example #2
0
 def execute(self, context: "Context") -> dict:
     hook = DataprocMetastoreHook(
         gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain
     )
     self.log.info("Creating Dataproc Metastore service: %s", self.project_id)
     try:
         operation = hook.create_service(
             region=self.region,
             project_id=self.project_id,
             service=self.service,
             service_id=self.service_id,
             request_id=self.request_id,
             retry=self.retry,
             timeout=self.timeout,
             metadata=self.metadata,
         )
         service = hook.wait_for_operation(self.timeout, operation)
         self.log.info("Service %s created successfully", self.service_id)
     except HttpError as err:
         if err.resp.status not in (409, '409'):
             raise
         self.log.info("Instance %s already exists", self.service_id)
         service = hook.get_service(
             region=self.region,
             project_id=self.project_id,
             service_id=self.service_id,
             retry=self.retry,
             timeout=self.timeout,
             metadata=self.metadata,
         )
     DataprocMetastoreLink.persist(context=context, task_instance=self, url=METASTORE_SERVICE_LINK)
     return Service.to_dict(service)
Example #3
0
    def execute(self, context: dict) -> dict:
        hook = DataprocMetastoreHook(
            gcp_conn_id=self.gcp_conn_id,
            impersonation_chain=self.impersonation_chain)
        self.log.info("Creating Dataproc Metastore backup: %s", self.backup_id)

        try:
            operation = hook.create_backup(
                project_id=self.project_id,
                region=self.region,
                service_id=self.service_id,
                backup=self.backup,
                backup_id=self.backup_id,
                request_id=self.request_id,
                retry=self.retry,
                timeout=self.timeout,
                metadata=self.metadata,
            )
            backup = hook.wait_for_operation(self.timeout, operation)
            self.log.info("Backup %s created successfully", self.backup_id)
        except HttpError as err:
            if err.resp.status not in (409, '409'):
                raise
            self.log.info("Backup %s already exists", self.backup_id)
            backup = hook.get_backup(
                project_id=self.project_id,
                region=self.region,
                service_id=self.service_id,
                backup_id=self.backup_id,
                retry=self.retry,
                timeout=self.timeout,
                metadata=self.metadata,
            )
        return Backup.to_dict(backup)
    def execute(self, context: "Context"):
        hook = DataprocMetastoreHook(
            gcp_conn_id=self.gcp_conn_id,
            impersonation_chain=self.impersonation_chain)
        self.log.info("Creating Dataproc Metastore metadata import: %s",
                      self.metadata_import_id)
        operation = hook.create_metadata_import(
            project_id=self.project_id,
            region=self.region,
            service_id=self.service_id,
            metadata_import=self.metadata_import,
            metadata_import_id=self.metadata_import_id,
            request_id=self.request_id,
            retry=self.retry,
            timeout=self.timeout,
            metadata=self.metadata,
        )
        metadata_import = hook.wait_for_operation(self.timeout, operation)
        self.log.info("Metadata import %s created successfully",
                      self.metadata_import_id)

        DataprocMetastoreDetailedLink.persist(context=context,
                                              task_instance=self,
                                              url=METASTORE_IMPORT_LINK,
                                              resource=self.metadata_import_id)
        return MetadataImport.to_dict(metadata_import)
Example #5
0
 def execute(self, context: "Context") -> None:
     hook = DataprocMetastoreHook(
         gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain
     )
     self.log.info("Deleting Dataproc Metastore backup: %s", self.backup_id)
     operation = hook.delete_backup(
         project_id=self.project_id,
         region=self.region,
         service_id=self.service_id,
         backup_id=self.backup_id,
         request_id=self.request_id,
         retry=self.retry,
         timeout=self.timeout,
         metadata=self.metadata,
     )
     hook.wait_for_operation(self.timeout, operation)
     self.log.info("Backup %s deleted successfully", self.project_id)
Example #6
0
    def execute(self, context: 'Context'):
        hook = DataprocMetastoreHook(
            gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain
        )
        self.log.info("Updating Dataproc Metastore service: %s", self.service.get("name"))

        operation = hook.update_service(
            project_id=self.project_id,
            region=self.region,
            service_id=self.service_id,
            service=self.service,
            update_mask=self.update_mask,
            request_id=self.request_id,
            retry=self.retry,
            timeout=self.timeout,
            metadata=self.metadata,
        )
        hook.wait_for_operation(self.timeout, operation)
        self.log.info("Service %s updated successfully", self.service.get("name"))
Example #7
0
    def execute(self, context: "Context"):
        hook = DataprocMetastoreHook(
            gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain
        )
        self.log.info("Updating Dataproc Metastore service: %s", self.service.get("name"))

        operation = hook.update_service(
            project_id=self.project_id,
            region=self.region,
            service_id=self.service_id,
            service=self.service,
            update_mask=self.update_mask,
            request_id=self.request_id,
            retry=self.retry,
            timeout=self.timeout,
            metadata=self.metadata,
        )
        hook.wait_for_operation(self.timeout, operation)
        self.log.info("Service %s updated successfully", self.service.get("name"))
        DataprocMetastoreLink.persist(context=context, task_instance=self, url=METASTORE_SERVICE_LINK)
Example #8
0
 def execute(self, context: 'Context'):
     hook = DataprocMetastoreHook(
         gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain
     )
     self.log.info("Creating Dataproc Metastore metadata import: %s", self.metadata_import_id)
     operation = hook.create_metadata_import(
         project_id=self.project_id,
         region=self.region,
         service_id=self.service_id,
         metadata_import=self.metadata_import,
         metadata_import_id=self.metadata_import_id,
         request_id=self.request_id,
         retry=self.retry,
         timeout=self.timeout,
         metadata=self.metadata,
     )
     metadata_import = hook.wait_for_operation(self.timeout, operation)
     self.log.info("Metadata import %s created successfully", self.metadata_import_id)
     return MetadataImport.to_dict(metadata_import)