PoolJobs_runProcess

Inicia uma nova Job Thread em um dos AppServers/Slaves configurados no POOL Job Threads que deve ter sido inicializado pela rotina principal a partir da chamada da função PoolJobs_init.

Sintaxe

_ADVPL_PoolJobs_runProcess( < cPoolMainName >, < cProcess >, < nLimitProcess >, < nWait >, < cCompany >, < cUser > ) => SMALLINT

Parâmetros

Nome	Tipo	Obrigatório?	Descrição
cPoolMainName	`CHAR`	Não	Nome principal do POOL de AppServers. Quando não informado, assumirá o nome do POOL com o nome do programa em execução. Este nome de POOL poderá ser utilizado para configurar a lista de AppServers no PROFILE para a chave jobServers.
cProcess	`CHAR`	Não	Nome da função (processo) em processamento no POOL Exemplo: Se iniciar um processo no POOL usando a funcao abc0001_process() e esta função está desenvolvida no fonte abc00001.4gl, o programa registrado no POOL será "abc0001" e o processo será "abc0001_process"
nLimitProcess	`SMALLINT`	Não	Quantidade limite de execuções paralelas do processo (função) no POOL de appservers. Quando não informado, considera quantidade limite de processos paralelos como 1. Quando for informado o valor 0, não irá impor limites de processos paralelos para o processo (função) informada no POOL de appservers JOB.
nWait	`SMALLINT`	Não	Indicador para aguardar o término da execução do JOB/processo antes de continuar. TRUE - Aguardar o término do processamento da thread/processo. FALSE - (PADRÃO) Não irá aguardar o término do processamento da thread/processo.
cCompany	`CHAR`	Não	Código da empresa para processamento. Quando não informado, utiliza a empresa atual conectada no Logix.
cUser	`CHAR`	Não	Código do usuário para processamento. Quando não informado, utiliza o usuário atual conectado no Logix.

Retorno

Tipo

Descrição

SMALLINT

Código de STATUS de execução.

0 - Falha ao iniciar processo
1 - Processo iniciado com sucesso
2 - Processo já em execução na quantidade limite de processos em paralelo definido.

Exemplo

DATABASE logix

GLOBALS
   DEFINE p_cod_empresa LIKE empresa.cod_empresa
END GLOBALS

DEFINE m_pooljob_name CHAR(30)
DEFINE m_count        INTEGER

#-----------------------------------#
 FUNCTION PoolJobs_runProcess_test()
#-----------------------------------#
  DEFINE l_repete SMALLINT

  IF LOG_initApp("PADRAO") <> 0 THEN
     RETURN
  END IF

  #Nome do POOL de processamentos JOB para a empresa que estiver realizando o processamento.
  #Neste exemplo foi optado criar o nome do POOL com o código da empresa para permitir controlar um a execução das rotinas por empresa 
  #e não de forma geral pra todas empresas.
  LET m_pooljob_name = "pool_",p_cod_empresa

  #Verificar se existe algum processo JOB em andamento para esse nome de POOL Job Threads
  IF _ADVPL_PoolJobs_getCountProcess(m_pooljob_name) > 0 THEN
     CALL conout("Processo não iniciado. Este processo já está em andamento para a empresa "||p_cod_empresa)
     RETURN
  END IF

  #Inicializar o POOL Job Threads, onde fará leitura de chaves de profile e identificará lista 
  #de appservers válidos (ativos e com conexão de banco de dados válida)
  IF NOT _ADVPL_PoolJobs_init(m_pooljob_name) THEN
     CALL conout("PoolJobs não iniciado. Appservers do POOL não foram detectados ou houve falha de conexão.")
     RETURN
  END IF

  #Ativar o modo JOB (Não apresentar telas de mensagens durante o processamento. Somente considerada para funções de mensagens padrões Logix)
  CALL LOG_setJobMode(1)

  LET l_repete = 1
  WHILE l_repete
     LET l_repete = PoolJobs_runProcess_test_process()
     CALL conout("LOOP - REPETE >> "||l_repete)
  END WHILE
 END FUNCTION

#-------------------------------------------#
 FUNCTION PoolJobs_runProcess_test_process()
#-------------------------------------------#
  DEFINE l_repete SMALLINT

  CALL conout("[POOL] INICIO.....--------------------- iniciando JOBS --------------------")

  #Iniciando Job Thread para função pool1_main()
  #A função pool1_main() precisa existir compilada no RPO em um código fonte .4GL 
  CASE _ADVPL_PoolJobs_runProcess(m_pooljob_name,"pool1_main")
  WHEN 1
     LET m_count = m_count + 1
     CALL conout("[POOL] Processo pool_01 iniciado..."||m_count)
  WHEN 2
     CALL conout("[POOL] Processo pool_01 está em andamento..."||m_count)
  WHEN 0
     CALL conout("[POOL] Ocorreu falha ao iniciar o processo pool_01..."||m_count)
  END CASE

  #Iniciando Job Thread para função pool2_main()
  CASE _ADVPL_PoolJobs_runProcess(m_pooljob_name,"pool2_main")
  WHEN 1
     LET m_count = m_count + 1
     CALL conout("[POOL] Processo pool_02 iniciado..."||m_count)
  WHEN 2
     CALL conout("[POOL] Processo pool_02 está em andamento..."||m_count)
  WHEN 0
     CALL conout("[POOL] Ocorreu falha ao iniciar o processo pool_02..."||m_count)
  END CASE

  #Iniciando Job Thread para função pool3_main()
  CASE _ADVPL_PoolJobs_runProcess(m_pooljob_name,"pool3_main")
  WHEN 1
     LET m_count = m_count + 1
     CALL conout("[POOL] Processo pool_03 iniciado..."||m_count)
  WHEN 2
     CALL conout("[POOL] Processo pool_03 está em andamento..."||m_count)
  WHEN 0
     CALL conout("[POOL] Ocorreu falha ao iniciar o processo pool_03..."||m_count)
  END CASE

  #Iniciando Job Thread para função pool4_main()
  CASE _ADVPL_PoolJobs_runProcess(m_pooljob_name,"pool4_main")
  WHEN 1
     LET m_count = m_count + 1
     CALL conout("[POOL] Processo pool_04 iniciado..."||m_count)
  WHEN 2
     CALL conout("[POOL] Processo pool_04 está em andamento..."||m_count)
  WHEN 0
     CALL conout("[POOL] Ocorreu falha ao iniciar o processo pool_04..."||m_count)
  END CASE

  #Iniciando Job Thread para função pool5_main()
  CASE _ADVPL_PoolJobs_runProcess(m_pooljob_name,"pool5_main")
  WHEN 1
     LET m_count = m_count + 1
     CALL conout("[POOL] Processo pool_05 iniciado..."||m_count)
  WHEN 2
     CALL conout("[POOL] Processo pool_05 está em andamento..."||m_count)
  WHEN 0
     CALL conout("[POOL] Ocorreu falha ao iniciar o processo pool_05..."||m_count)
  END CASE

  CALL conout("[POOL] FIM.....--------------------- processos iniciados ("||m_count||") --------------------")

  ##Após cada bloco de START de processos Job é realizada pausa de 5 segundos 
  ##antes da execução do próximo ciclo de execução de processos Job.
  SLEEP 5 

  #Exemplo foi desenvolvido para que após iniciar com sucesso 20 Jobs, o programa principal será finalizado
  RETURN (m_count < 20) 
 END FUNCTION

#-----------------------------#
 FUNCTION pool1_main()
#-----------------------------#
   DEFINE l_cont SMALLINT

   CALL conout("[pool_01] inicio.........................")
   WHILE l_cont < 30
      SLEEP 1
      LET l_cont = l_cont + 1
      CALL conout("[pool_01] processando "||l_cont||".........................")
   END WHILE
   CALL conout("[pool_01] fim............................")
 END FUNCTION

#-----------------------------#
 FUNCTION pool2_main()
#-----------------------------#
   DEFINE l_cont SMALLINT

   CALL conout("[pool_02] inicio.........................")
   WHILE l_cont < 180
      SLEEP 1
      LET l_cont = l_cont + 1
      CALL conout("[pool_02] processando "||l_cont||".........................")
   END WHILE
   CALL conout("[pool_02] fim............................")
 END FUNCTION

#-----------------------------#
 FUNCTION pool3_main()
#-----------------------------#
   DEFINE l_cont SMALLINT

   CALL conout("[pool_03] inicio.........................")
   WHILE l_cont < 80
      SLEEP 1
      LET l_cont = l_cont + 1
      CALL conout("[pool_03] processando "||l_cont||".........................")
   END WHILE
   CALL conout("[pool_03] fim............................")
 END FUNCTION

#-----------------------------#
 FUNCTION pool4_main()
#-----------------------------#
   DEFINE l_cont SMALLINT

   CALL conout("[pool_04] inicio.........................")
   WHILE l_cont < 100
      SLEEP 1
      LET l_cont = l_cont + 1
      CALL conout("[pool_04] processando "||l_cont||".........................")
   END WHILE
   CALL conout("[pool_04] fim............................")
 END FUNCTION

#-----------------------------#
 FUNCTION pool5_main()
#-----------------------------#
   DEFINE l_cont SMALLINT

   CALL conout("[pool_05] inicio.........................")
   WHILE l_cont < 120
      SLEEP 1
      LET l_cont = l_cont + 1
      CALL conout("[pool_05] processando "||l_cont||".........................")
   END WHILE
   CALL conout("[pool_05] fim............................")
 END FUNCTION

Informações

Fontes: log1200.prw

Veja também

PoolJobs_init

PoolJobs_getCountProcess

Observações

Para saber outras informações de como implementar o uso de POOL de Jobs acesse LGX - Exemplo de uso POOL Job Threads.

Páginas filhas