Como saber em qual função estou dentro do shell script [RESOLVIDO]

1. Como saber em qual função estou dentro do shell script [RESOLVIDO]

AprendiNoLinux
(usa Ubuntu)

Enviado em 09/04/2012 - 23:31h

Aqui estou jô novamente rsrs.

Faz bastante tempo que precisei saber qual o nome da função que estou rodando dentro de um determinado script.
Acho que já tinha resolvido este problema mas procurando em meus alfarrábios só achei sobre a declare -f que lista tudo na tela. Todas as funções que já estão definidas. Eu queria perguntar na linha desejada qual a função estou rodando, exemplo:



#!/bin/bash

# file: loop_dataware.sh



function saida_com_erro0()

{



	Doc_Erro="$1"

        echo " Qual função estou rodando neste momento ??? comando iria aqui"



	echo "Estamos na rotina saida_com_erro e recebemos....: $Doc_Erro "

	

	if [ "$Doc_Erro" = "ERRO-CNC-LOCK" ]; then

		log_opera "ERRO-CNC-LOCK"

	fi



	if [ "$Doc_Erro" = "FALHA-CN..:" ]; then

		log_opera "FALHA-CN..:"

	fi



	if [ "$Doc_Erro" = "ERRO-PHP_1:" ]; then

		log_opera "ERRO-PHP_1:"

	fi



	if [ "$Doc_Erro" = "ERRO-FATAL-CRIAÇÃO:" ]; then

		log_opera "ERRO-FATAL-CRIAÇÃO:"

	fi



	if [ -f "$filename" ]; then

		rm "$filename" # Apagando o arquivo do canal. 

	fi	

	

		

}





function saida_com_erro1()

{

	Doc_Erro="$1"

        echo " Qual função estou rodando neste momento ??? comando iria aqui"



	echo "Estamos na rotina saida_com_erro e recebemos....: $Doc_Erro "

	

	if [ "$Doc_Erro" = "ERRO-CNC-LOCK" ]; then

		log_opera "ERRO-CNC-LOCK"

	fi



	if [ "$Doc_Erro" = "FALHA-CN..:" ]; then

		log_opera "FALHA-CN..:"

	fi



	if [ "$Doc_Erro" = "ERRO-PHP_1:" ]; then

		log_opera "ERRO-PHP_1:"

	fi



	if [ "$Doc_Erro" = "ERRO-FATAL-CRIAÇÃO:" ]; then

		log_opera "ERRO-FATAL-CRIAÇÃO:"

	fi



}



function saida_com_erro2()

{

	Doc_Erro="$1"

        echo " Qual função estou rodando neste momento ??? comando iria aqui"



	echo "Estamos na rotina saida_com_erro e recebemos....: $Doc_Erro "

	

	if [ "$Doc_Erro" = "ERRO-CNC-LOCK" ]; then

		log_opera "ERRO-CNC-LOCK"

	fi



	if [ "$Doc_Erro" = "FALHA-CN..:" ]; then

		log_opera "FALHA-CN..:"

	fi



	if [ "$Doc_Erro" = "ERRO-PHP_1:" ]; then

		log_opera "ERRO-PHP_1:"

	fi



	if [ "$Doc_Erro" = "ERRO-FATAL-CRIAÇÃO:" ]; then

		log_opera "ERRO-FATAL-CRIAÇÃO:"

	fi



}



# Meu códigos maluquetes vem após as funções....

# blá blá blá

# Em um certo momento, preciso saber qual a função que estou rodando.  Preciso do nome da função. 

# Eu ser humano em tese sei em que função estou, mas é que estou gerando documentação automática e preciso ter certeza. 

# Sei que tem uma forma e deve estar na minha cara e não acho. Já tentei ?0 mas ele retorna o script. 





echo " help-meeeeeeeeeeeeeeeeeeeeeeeeeee linuxers " 



#Ga_Tux



exit 1

Para ajudar pesquisadores encontrar a variável que guarda o nome da função em uso.

#FunçãoRodando - Qual função está rodando em shell script?

#FunçãoRodando - Como saber qual função está sendo usada em shell script?

#FunçãoRodando - Como pegar o nome da função que está em uso Shell Script ?

0 0

Quote

2. MELHOR RESPOSTA

rai3mb
(usa Outra)

Enviado em 10/04/2012 - 00:35h

Amigãoooo

obrigado pela sua dúvida ;-)

acebei descobrindo algo novo

veja:



#!/bin/bash



valeu() {

  echo "Eu sou a função: $FUNCNAME";

}



valeu

;-)

Abraços

1 0

Quote

3. Re: Como saber em qual função estou dentro do shell script [RESOLVIDO]

AprendiNoLinux
(usa Ubuntu)

Enviado em 10/04/2012 - 03:13h

rai3mb escreveu:

Amigãoooo

obrigado pela sua dúvida ;-)

acebei descobrindo algo novo

veja:



#!/bin/bash



valeu() {

  echo "Eu sou a função: $FUNCNAME";

}



valeu

;-)

Abraços

putz que las parantcha profs rai3mb ;) Tropecei nesta infeliz um monte de vezes e não achava rrs.

Ok, funcionou perfeitamente e agora já sei a função que está me lascando rsrs

Com a danada em mãos, chama outra função para fazer uma saída controlada, mas a infeliz executa tudo que está dento da função mas insiste em retornar para todas as outras funções. Já tente exit, exit 1, exit 0 e nada. Dentro da maledeta não funfa.

Já tentei com várias outras funções e funciona, só nesta que não. Já descobri o motivo, mas não consigo me livrar dele.

O problema:

Em algum momento eu preciso chamar a função assim myvar=$(myfunction "param1" "param2" param3" param4")
Dentro de myfunction estou chamando outra função myvarnova=$(myfunction2 "param1" "param2" "param3")

Dentro de myvarnova estou chamando outra function e seria esta maledeta que preciso fazer a saída.

Dentro de myfunction2 estou chamando outra função myvardagota=$(myfunction3 "param1" "param2" "param3")

Dentro de myfunction3 tem um teste.



if [ $bizonho = "SIM" ]; then

   rm "$Arq_Bizonho" # apagando arquivo do bizonho. 

   rm $Arq_Temp" # Apagando temporário. 

fi

GrvLog="Gravando o log com infos de problemas"

echo $GrvLog $Myproblem1 $Myproblem2 $Myproblem3 >> $GrvLogUser



exit

ou

exit 0

ou 

exit 1

ou 

SaiPeloAmorDeDeus

O problema é que ela volta para myfunction2, myfunction.
Detalhe. Outro problema é que existem 2 while na myfunction e por ultimo na myfunction2
Na myfunction3 não tem rotinas de loop usando while.

Está parecendo algum problema entre a saída do while + quando uma função é chamada assim: myvar=$(myfunction)
Embora se eu chamar a função direta passando os parâmetros também não funfa, ex:

myfunction "$param1" "$param2"

Tudo leva a crer que o problema é ocasionado quando se usa 2 whiles em funções diferentes.
Lembrando: Todos os retornos das funções quando não for a modalidade aborto estão funcionando.
Para contornar estou pegando o nome da função e salvando como retorno.
Venho com o retorno até o 1 while e somente ali faço um teste se o valor que desejo de uma função está setado e mando apagar os arquivos e sair.
Desta forma funciona, após o profs rai3mb dar a dica para pegar o nome da função usando $FUNCNAME.
Eu só acho muita boquetagem se este for a forma certa. Ficar controlando o retorno de todas funções encadeadas até chegar em um nível mais baixo.

Detalhe: Eu testei fazendo 5 níveis de entradas em funções umas dentro das outras e deu certo usar o exit. Saiu direto. O problema é que não tinha nenhum while nestas outras funções.

Não sei se deu para entender o problema. De qualquer forma, vou batendo lata por aqui e encontrando a solução envio. Só queria escapar de fazer mais uma POG. kkkkk

Obrigado profs Raimundo :)

oops eu sou o Rolando lero kkkkk

0 0

Quote

4. Re: Como saber em qual função estou dentro do shell script [RESOLVIDO]

AprendiNoLinux
(usa Ubuntu)

Enviado em 10/04/2012 - 06:07h

Conseguiiiiiiiiiiiiiiiiiiiiiiiii

Ainda não sei como foi kkkk, mas quando tirar as POGs mando o código aqui ;)

Acho que foi a transpiração desta canção enviada pelo crf-rafa http://vivaolinux.com.br/topico/Off-Code-Cafe/Acordando-com-Led-Zeppelin?pagina=16&num_por_pagin...

Era um garoto que como eu amava os beatles e os rolling stones ou qualquer tipo de rockkkkkkkkkkkkkk

0 0

Quote

5. Re: Como saber em qual função estou dentro do shell script [RESOLVIDO]

AprendiNoLinux
(usa Ubuntu)

Enviado em 21/05/2012 - 23:43h

Conforme prometido, o conjunto de funções que controla os status e faz de forma controlada a saída de funções mesmo quando temos while e loops em funções secundárias.
Tem um monte de textos que não serão claros mas serve como exemplo de como está sendo feito a "bagaça"
Está repleta de Debugs mas não aparecem na execução e só mantenho nos testes.
Na produção estou tentando montar um script que vai retirar do código no diretório do install todos os comentários e debugs para não atrasar os processamentos.
Código ainda muito sujo, mas já tem algumas técnicas legais.



###############################################################################

## @param1	"${FOLDER_NAME_SERVICE}" Nome do serviço = diretório.

## @param2	"${TIPO_SERVICO}" START e futuramente Stop Monitor, etc...

## @param3	"${TAREFA}" Apelido da tarefa.Geralmente nome do script.sh

## @param4	"${STR_ORIGEM}" 00,02,07, etc...

## @param5	"${ARQ_TAREFA}" - Nome geral do arquivo desta tarefa.

## @param6	"${TAREFA_INICIAL}" - Não pode ser zero. Número dos canais.

## @param7	"${TAREFA_FINAL}" - Pode ser zero ou nula. Número de canais.

## Dependências:

########	Vars públicas:

########	Retorno......: NADA.

## Chamada por: gserv.sh 

#-----------------------------------------------------------------------------#

function CheckGeralDoServico()

{



Debug 3 "Iniciando a func CheckGeralDoServico conferindo parâmetros de chegada $LINENO $FUNCNAME $0"

Debug 2 "param1 lc_name_service:$1 L:$LINENO"

Debug 2 "param1 lc_check:$2 L:$LINENO"

Debug 2 "param2 lc_nome_da_tarefa_do_servico:$3 L:$LINENO"

Debug 2 "param3 lc_origem:$4 L:$LINENO"

Debug 2 "param6 lc_arq_tarefa:$5 "

Debug 2 "param4 lc_tarefa_inicial:$6 L:$LINENO"

Debug 2 "param5 lc_tarefa_final:$7 L:$LINENO"



	local lc_name_service=${1:-"ERRO IRRECUPERÁVEL"}

	local lc_check=${2:-"START"}

	local lc_nome_da_tarefa_do_servico=${3:-"INDEFINIDO"}

	local lc_origem=${4:-"ERRO-ORIGEM"} #Futuramente poderá não ser informado.

	local lc_arq_tarefa=${5:-"NENHUMA TAREFA"} #End+Nome arq. da tarefa.

	local lc_inicial=${6:-0} # Força pelo menos 1(uma) tarefa.

	local lc_final=${7:-0} # Pode ser opcional.



	lc_tarefa_inicial=$(expr $lc_inicial + 0)

	lc_tarefa_final=$(expr $lc_final + 0)



	Debug 1 "Conferindo: lc_tarefa_inicial [$lc_tarefa_inicial] e lc_tarefa_final [$lc_tarefa_final] [F: $FUNCNAME L:$LINENO] gserv.sh"



	if [ "${lc_tarefa_inicial}" -gt "${lc_tarefa_final}" -a "${lc_tarefa_final}" -ge "2" ]; then

		Debug 5 "Não sabe o que fez quando informou as tarefas. [F: $FUNCNAME L:$LINENO] "

		Debug 5 "${lc_tarefa_inicial} > que final: ${lc_tarefa_final} [F: $FUNCNAME L:$LINENO]"

		StartTarefaInicialMenorQueFinal # Problema grave.

	fi





	if [ ${lc_check} == "START" ]; then



		# Verifica se o serviço já está no ar.

		# Se estiver retorna sem fazer nada.

		# Se a solicitação for de uma tarefa apenas e existir, ABORTA.



		Debug 3 "Antes de carregar CheckStartedServico, conferindo parâmetros "

		Debug 1 "CheckStartedServico param1 lc_check:${lc_check} L:$LINENO"

		Debug 2 "CheckStartedServico param2 lc_arq_tarefa:${lc_arq_tarefa} L:$LINENO"

		Debug 1 "CheckStartedServico param3 lc_nome_da_tarefa_do_servico:${lc_nome_da_tarefa_do_servico} L:$LINENO"



		CheckStartedServico \

			"${lc_check}" \

			"${lc_arq_tarefa}" \

			"${lc_nome_da_tarefa_do_servico}"



		Debug 3 "Retornou do CheckStartedServico.. [F:$FUNCNAME][L:$LINENO]"



		# Se o serviço está liberado para ser inicializado, preciso criar as tarefas.

		# A partir de agora passaremos o comando para a função PreparaStartDeTarefas.



		Debug 2 "Serviço: ${lc_name_service} será inicializado "

		Debug 2 " agora. [F:$FUNCNAME][L:$LINENO] "



#		CriandoArqStartTarefa $lc_arq_tarefa



		Debug 3 "Antes de carregar PreparaStartDeTarefas, conferindo parâmetros "

		Debug 1 "PreparaStartDeTarefas param1 lc_check:${lc_check} L:$LINENO"

		Debug 2 "PreparaStartDeTarefas param2 lc_nome_da_tarefa_do_servico:${lc_nome_da_tarefa_do_servico} L:$LINENO"

		Debug 1 "PreparaStartDeTarefas param3 lc_origem:${lc_origem} L:$LINENO"

		Debug 2 "PreparaStartDeTarefas param4 lc_tarefa_inicial:${lc_tarefa_inicial} L:$LINENO"

		Debug 1 "PreparaStartDeTarefas param5 lc_tarefa_final:${lc_tarefa_final} L:$LINENO"

		Debug 2 "PreparaStartDeTarefas param6 lc_arq_tarefa:${lc_arq_tarefa} "



		PreparaStartDeTarefas \

			"${lc_check}" \

			"${lc_nome_da_tarefa_do_servico}" \

			"${lc_origem}" \

			"${lc_tarefa_inicial}" \

			"${lc_tarefa_final}" \

			"${lc_arq_tarefa}"



		Debug 3 "Retornou do PreparaStartDeTarefas... [F:$FUNCNAME L:$LINENO]"



	fi



}



###############################################################################

## @param1	"${lc_check}" START e futuramente Stop Monitor, etc...

## @param2	"${lc_arq_tarefa}" Nome geral do arquivo desta tarefa

## @param3	"${lc_nome_da_tarefa_do_servico}" Nome do apelido do serviço.

## Dependências:

########	Vars públicas:

########	Retorno......: NADA.

## Chamada por: CheckGeralDoServico()

#-----------------------------------------------------------------------------#

function CheckStartedServico()

{

	local lc_check="$1" lc_arq_tarefa="$2" lc_nome_da_tarefa_do_servico="$3"



	Debug 2 "Entrei na função:[$FUNCNAME L:$LINENO] "

	Debug 2 "Parâmetros $* "



	# Só pode entrar nesta função se a opção for START

	# Recebe o nome do arquivo de tarefa para fazer a conferência.



	if [ -f "${lc_arq_tarefa}" -a "${lc_check}" == "START" ]; then # Existe o arquivo de tarefa.

		Debug 2 "Serviço: ${lc_nome_da_tarefa_do_servico} em operação. ABORTANDO !!!! "

		Debug 5 " TENTOU ACESSO simultâneo no Serviço"

		Debug 5 " ${lc_arq_tarefa} [F:$FUNCNAME][L:$LINENO]"

        # Saindo do serviço de forma controlada

		FN_encerra_gserv "TENTOU ACESSO simultâneo no Serviço" "gserv" "$LINENO"

		exit 1

	else

		Debug 2 "Serviço: ${TAREFA} pode ser inicializado agora. !!!! [F:$FUNCNAME][L:$LINENO] "

	fi

}





function CriandoArqStartTarefa()

{

	local lc_tarefa="$1"



	Debug 2 "Entrei na função:[$FUNCNAME L:$LINENO] "

	Debug 2 "Parâmetros $* "



	Debug 3 "Criando arquivo do Serviço: ${lc_tarefa} [F:$FUNCNAME][L:$LINENO] "



	touch "${lc_tarefa}" # Criando o arquivo de serviço.

}



###############################################################################

## @param1	"${lc_check}" START e futuramente Stop Monitor, etc...

## @param2	"${lc_nome_da_tarefa_do_servico}" Apelido da tarefa.Geralmente nome do script.sh

## @param3	"${lc_origem}" 00,02,07, etc...

## @param4	"${lc_tarefa_inicial}" - Não pode ser zero. Número dos canais.

## @param5	"${lc_tarefa_final}" - Pode ser zero ou nula. Número de canais.

## @param6	"${lc_arq_tarefa} - End. + arq da tarefa.

## Dependências:

########	Vars públicas:

########	Retorno......: NADA.

## Chamada por: CheckGeralDoServico()

#-----------------------------------------------------------------------------#

function PreparaStartDeTarefas()

{



Debug 3 "Dentro da PreparaStartDeTarefas .[F:$FUNCNAME L:$LINENO] gserv.sh"

Debug 4 "param1 lc_check $1 "

Debug 4 "param2 lc_nome_da_tarefa_do_servico $2 "

Debug 4 "param3 lc_origem $3 "

Debug 4 "param4 lc_tarefa_inicial $4 "

Debug 4 "param5 lc_tarefa_final $5 "

Debug 4 "param6 lc_arq_tarefa $6 "



local lc_check=${1:-"START"} # Força default.

local lc_nome_da_tarefa_do_servico=${2:-"INDEFINIDO"} # Força default.

local lc_origem=${3:-"ERRO-ORIGEM"} #Futuramente poderá não ser informado.

local lc_inicial=${4:-0}

local lc_final=${5:-0}

local lc_arq_tarefa=${6:-"NENHUMA TAREFA"} #End+Nome arq. da tarefa.



	Debug 2 "Entrei na função:[$FUNCNAME L:$LINENO] gserv.sh"



	# Quando o serviço é inicializado, precisa gerar os arquivos de tarefas.

	# Arquivos de tarefas servirão para futura retirada do serviço do ar.

	# Arquivos de tarefas indicam quem está trabalhando no momento.

	# Gerar arquivos de tarefas devem ser executados antes que as tarefas

	# entrem no ar.

	# Somente o dono do serviço pode ler o arquivo do start tarefas.

	# Recebe parâmetros.

	#-------------------------------------------------------------------------#

	#	1 - Tipo de verificação.lc_check

	#		[START]		-	Incializa o serviço.

	#						Delega a ação ao PreparaStartDeTarefas para realizar

	#						a inicialização dos arquivos de tarefas.

	#		[STOP]		-	Para o serviço.

	#		[PAUSE]		-	Pause as tarefas.

	#		[RESTART]	-	Reinicia as tarefas suspensas.

	#	2 - Nome do serviço.

	#		TAREFA="${PROGNAME}_${ORIGEM}_${HOSTNAME}.srv"

	# 		Nome do serviço no momento.

	#		Leva em consideração o nome do script, origem e a máquina.

	#	3 - ORIGEM

	#	4 - Número da tarefa inicial.

	#	5 - Número da tarefa final.



	if [ "${lc_check}" == "START" ]; then



		Debug 1 "Verifica parâmetros iniciais e finais de canais."

		Debug 1 "Preparando tarefas. [F:$FUNCNAME L:$LINENO] "



		# Verifica se a tarefa final eh igual a zero ou igual a final.



        lc_tarefa_inicial=$(expr $lc_inicial + 0)

        lc_tarefa_final=$(expr $lc_final + 0)



		Debug 2 " Conferindo: lc_tarefa_inicial e lc_tarefa_final: [$lc_tarefa_inicial]-[$lc_tarefa_final] $LINENO gserv.sh"



		if [ "${lc_tarefa_final}" == "0" -o "${lc_tarefa_inicial}" -eq "${lc_tarefa_final}" ]; then

            #Igualando a tarefa final para ser igual a tarefa inicial.

			lc_tarefa_final="${lc_tarefa_inicial}"

    		Debug 3 "Vai executar a StartTarefaUnica .[F:$FUNCNAME L:$LINENO]"

    		Debug 4 "param1 lc_check ${lc_check} "

    		Debug 4 "param2 lc_tarefa_inicial ${lc_tarefa_inicial} "

    		Debug 4 "param3 lc_tarefa_final ${lc_tarefa_final} "

    		Debug 4 "param4 lc_origem ${lc_origem} "

    		Debug 4 "param5 lc_arq_tarefa ${lc_arq_tarefa} "



			StartTarefaUnica	\

				"${lc_check}" \

				"${lc_tarefa_inicial}" \

				"${lc_tarefa_final}" \

				"${lc_origem}" \

				"${lc_arq_tarefa}"



    		Debug 3 "ANTES de executar função: actions_do_servico  [F:$FUNCNAME L:$LINENO]"

    		Debug 4 "param1 lc_check ${lc_check} "

    		Debug 4 "param2 lc_tarefa_inicial ${lc_tarefa_inicial} "

    		Debug 4 "param3 lc_tarefa_final ${lc_tarefa_final} "

    		Debug 4 "param4 lc_origem ${lc_origem} "

    		Debug 4 "param5 lc_arq_tarefa ${lc_arq_tarefa} "



			actions_do_servico	\

				"${lc_check}" \

				"${lc_tarefa_inicial}" \

				"${lc_tarefa_final}" \

				"${lc_origem}" \

				"${lc_arq_tarefa}"



		else

			# A tarefa inicial é menor que a tarefa final.

			#Precisa gerar várias linhas no arquivo do serviço que está entrando no ar.

			# Chamando a função que vai popular o arquivo de serviço.

			Debug 1 "Vou chamar a função AdicionaLinhasNoArqTarefas passando: "

			Debug 1 " I:${lc_tarefa_inicial} F: é ${lc_tarefa_final} [f: $FUNCNAME L: $LINENO]"



			# Ainda passando os parâmetros usando variáveis GLOBAIS.

			# Após estabilizar, usar variáveis LOCAIS. FIXME

			# Somente o lc_check usa variável local.



			AdicionaLinhasNoArqTarefas	\

				"${lc_tarefa_inicial}" \

				"${lc_tarefa_final}" \

				"${lc_check}" \

				"${lc_origem}" \

				"${lc_arq_tarefa}"



			Debug 1 "Retornei da AdicionaLinhasNoArqTarefas passando: "

			Debug 1 "${lc_tarefa_inicial} é ${lc_tarefa_final} [F:$FUNCNAME L:$LINENO]"



			# Chamar função que vai olhar o arquivo de serviço para gerar LOCKS de atividade.

			# Passa tarefa inicial e final só para confirmar.

			# Um ponto a ser mudado se cada linha for feita corretamente.

			# Quando dominar melhor a técnica vou mudar este ponto.



			Debug 1 "Carregando actions_do_servico [F:$FUNCNAME L:$LINENO]"

			actions_do_servico	\

				"${lc_check}" \

				"${lc_tarefa_inicial}" \

				"${lc_tarefa_final}" \

				"${lc_origem}" \

				"${lc_arq_tarefa}"



		fi

		# Chegou a hora de disparar as tarefas.

		# Já sabemos quantas tarefas podemos efetivamente colocar no ar.

		# É possível que um erro humano posso ter escolhido tarefas que foram

		# preparadas em outro serviço para outro máquina.

		# Caso este infeliz ERRO tenha acontecido, não há tarefas.

		# Pequeno teste não faz mal a ninguém.

		if [ -f ${lc_arq_tarefa} ]; then

			#Chegou a hora de executar o aplicativo. Ele será parametrizado.



			PreparaEXECdeTarefas	\

				"${lc_check}" \

				"${lc_tarefa_inicial}" \

				"${lc_tarefa_final}" \

				"${lc_origem}" \

				"${lc_arq_tarefa}"



		else

            TodasTarefasEmUsoFatalERRO

		fi



	fi



}



###############################################################################

## @param1	"${lc_check}" START e futuramente Stop Monitor, etc...

## @param2	"${lc_tarefa_inicial}" - Não pode ser zero. Número dos canais.

## @param3	"${lc_tarefa_final}" - Pode ser zero ou nula. Número de canais.

## @param4	"${lc_origem}" 00,02,07, etc...

## @param5	"${lc_arq_tarefa} - End. + arq da tarefa.

## Dependências: FEITO BOKETAGEM PARA QUEBRAR O GALHO. :FIXME:

########	Vars públicas:

########	Retorno......: NADA.

#-----------------------------------------------------------------------------#



function TodasTarefasEmUsoFatalERRO()

{

    #Só usa variáveis públicas.

	# TODO 	- 	Precisa ser desenvolvido uma função para enviar este tipo

	# 			de erro fatal por e-mail. É um caso muito grave.

    # Aparentemente este problema pode ocorrer quando a mesma tarefa

    # for disparada em outra máquina com os mesmos canais.

	Debug 5 "ERRO FATAL. Não há tarefas a disparar entre ${TAREFA_INICIAL} e ${TAREFA_FINAL} [F:$FUNCNAME L:$LINENO]"

	Debug 5 "SERVIÇO VAI ENCERRAR COM LOG DE FATAL ERRO NAS TAREFAS ${TAREFA_INICIAL} e ${TAREFA_FINAL} [F:$FUNCNAME L:$LINENO]"

	msgfatal="SERVIÇO ENCERRADO PORQUE AS TAREFAS ${TAREFA_INICIAL} e ${TAREFA_FINAL} JÁ ESTAVAM EM USO. "

	ArqErroFatal="${FOLDER_ROOT_SERVICO}/ERRO_fatal_${TAREFA}_${STR_ORIGEM}_${HOSTNAME}_$$.log"

	LUG_GravaArquivoTexto "${msgfatal}" "${ArqErroFatal}"

	FN_encerra_gserv "SAIR" "gserv" "$LINENO" # Encerrando e limpando o que for possível.

}





###############################################################################

## @param1	"${lc_check}" START e futuramente Stop Monitor, etc...

## @param2	"${lc_tarefa_inicial}" - Não pode ser zero. Número dos canais.

## @param3	"${lc_tarefa_final}" - Pode ser zero ou nula. Número de canais.

## @param4	"${lc_origem}" 00,02,07, etc...

## @param5	"${lc_arq_tarefa} - End. + arq da tarefa.

## Dependências:

########	Vars públicas:

########	Retorno......: NADA.

#-----------------------------------------------------------------------------#

function StartTarefaUnica()

{



Debug 3 "Dentro da StartTarefaUnica .[F:$FUNCNAME L:$LINENO]"

Debug 1 "Parâmetros: $* "

Debug 4 "param1 lc_check $1 "

Debug 4 "param2 lc_tarefa_inicial $2 "

Debug 4 "param3 lc_tarefa_final $3 "

Debug 4 "param4 lc_origem $4 "

Debug 4 "param5 lc_arq_tarefa $5 "



	local lc_check="$1" lc_tarefa_inicial="$2" lc_tarefa_final="$3"

	local lc_origem="$4" lc_arq_tarefa="$5"





	# Se existe apenas uma tarefa a ser criada, já podemos gravar no arquivo ${ARQ_TAREFA}

	# Não será necessário chamar a função que vai lançar várias tarefas.

	# Antes preciso montar o número da tarefa com zeros a esquerda.

	lc_str_canal=$(_strzero "${lc_tarefa_inicial}" 3)	# Nº do canal com zeros a esquerda.

	# Gravando a tarefa.

	lc_tarefa_unica="SIM" #Só para gravar arquivo diferente.



    Debug 3 "Antes de entrar CheckTarefaIniciada ainda dentro da:[F:$FUNCNAME L:$LINENO]"

    Debug 4 "param1 lc_str_canal ${lc_str_canal} "

    Debug 4 "param2 lc_arq_tarefa ${lc_arq_tarefa} "

    Debug 4 "param3 lc_tarefa_unica ${lc_tarefa_unica} "



	CheckTarefaIniciada	\

            "${lc_str_canal}" \

            "${lc_arq_tarefa}" \

            "${lc_tarefa_unica}"



}



#############################################################################

## @param1	"${lc_str_canal}" - Não pode ser zero. Número dos canais.

## @param2	"${lc_arq_tarefa} - End. + arq da tarefa.

## @param3	"${lc_tarefa_unica}" "SIM" ou "NÃO"

## Dependências:

########	Vars públicas: ${FOLDER_ORIGEM_SERVICE_LOGS}

########							${TAREFA}

########							${STR_ORIGEM}

########	Retorno......: NADA.

#---------------------------------------------------------------------------#

function CheckTarefaIniciada()

{



    Debug 3 "Dentro da CheckTarefaIniciada :[F:$FUNCNAME L:$LINENO]"

    Debug 4 "param1 lc_str_canal $1 "

    Debug 4 "param2 lc_arq_tarefa $2 "

    Debug 4 "param3 lc_tarefa_unica $3 "



	local lc_str_canal="$1" lc_arq_servico="$2" lc_tarefa_unica="$3"

#	STR_ORIGEM=$(_strzero $ORIGEM 2)	#Número da origem com zeros a esquerda.



	# 1º vamos investigar se 1 ou outro existe.

	# 2º Se existir, NÃO podemos gravar na lista de tarefa.

	#		pouco importa se é uma tarefa unitária ou não.

	#		A diferença é que na tarefa unitária, vamos abortar o sistema.

	# FIXME - Arrumar nome lock_insere_contas_origem_ porque não é genérico.

	# FIXME - Precisa ser lock+name_da_tarefa_do_servico__${STR_ORIGEM}_canal_${lc_str_canal}.txt"

	# FIXME - Precisa ser Start_+name_da_tarefa_do_servico__${STR_ORIGEM}_canal_${lc_str_canal}.trf"



	lc_nome_arq_tarefa_lock="lock_${TAREFA}_origem_${STR_ORIGEM}_canal_${lc_str_canal}.txt"

	lc_arq_tarefa_ativa_check="${FOLDER_ORIGEM_SERVICE_LOGS}/${lc_nome_arq_tarefa_lock}"



	lc_nome_arq_tarefa_start="Start_${TAREFA}_${STR_ORIGEM}_canal_${lc_str_canal}.trf"

	lc_arq_tarefa_start_check="${FOLDER_START}/${lc_nome_arq_tarefa_start}"



	Debug 2 "Conferindo TAREFA ativa lc_arq_tarefa_ativa_check: "

	Debug 2 "$lc_arq_tarefa_ativa_check [F:$FUNCNAME L:$LINENO]"

	Debug 2 "Conferindo TAREFA START lc_arq_tarefa_start_check: "

	Debug 2 "$lc_arq_tarefa_start_check  [F:$FUNCNAME L:$LINENO]"



	if [ -f "${lc_arq_tarefa_ativa_check}" -o -f "${lc_arq_tarefa_start_check}" ]; then

		# Encontrou o lock ou uma versão START no ar em carregamento.

		# Não vamos gravar a lista de tarefa e iremos retornar.

		# Se é uma farefa única, ABORTAR.

		if [ -f "${lc_arq_tarefa_ativa_check}" ]; then

			Debug 4 "TAREFA do CANAL ativa:$lc_arq_tarefa_ativa_check [F:$FUNCNAME L:$LINENO]"

		fi

		if [ -f "${lc_arq_tarefa_start_check}" ]; then

			Debug 4 "TAREFA do START existe:${lc_arq_tarefa_start_check} [F:$FUNCNAME L:$LINENO]"

		fi

		if [ "${lc_tarefa_unica}" == "SIM" ]; then

			Debug 5 "SERVIÇO EXISTE !!! Por ser TAREFA ÚNICA, abortando serviço [F:$FUNCNAME L:$LINENO] "

            # Encerrando e limpando o que for possível.

			FN_encerra_gserv "TAREFA ÚNICA mas SERVIÇO EXISTE !!!" "gserv" "$LINENO"

		fi

	else

		if [ ${lc_tarefa_unica} == "SIM" ]; then

			Debug 2 "TAREFA ÚNICA será gravada para o canal: "

			Debug 2 "$lc_str_canal em: ${lc_arq_servico} [F:$FUNCNAME L:$LINENO] "

			# Se for tarefa única, grava diferente.

			LUG_GravaArquivoTexto "$lc_str_canal" "${lc_arq_servico}"

		else

			Debug 2 "TAREFA será gravada para o canal: "

			Debug 2 "$lc_str_canal em: ${lc_arq_servico} [F:$FUNCNAME L:$LINENO] "

			LUG_GravaLinhaArquivoTexto "$lc_str_canal" "${lc_arq_servico}"



		fi

	fi

}



###############################################################################

## @param1	"${lc_check}" START e futuramente Stop Monitor, etc...

## @param2	"${lc_tarefa_inicial}" - Não pode ser zero. Número dos canais.

## @param3	"${lc_tarefa_final}" - Pode ser zero ou nula. Número de canais.

## @param4	"${lc_origem}" 00,02,07, etc...

## @param5	"${lc_arq_tarefa} - End. + arq da tarefa.

## Dependências:

########	Vars públicas: ${FOLDER_ORIGEM_SERVICE_LOGS}

########							${TAREFA}

########							${STR_ORIGEM}

#-----------------------------------------------------------------------------#

function actions_do_servico()

{

Debug 3 "DEPOIS já na função: actions_do_servico  [F:$FUNCNAME L:$LINENO] gserv.sh"

Debug 2 "Parâmetros $* "

Debug 4 "param1 lc_check $1 "

Debug 4 "param2 lc_tarefa_inicial $2 "

Debug 4 "param3 lc_tarefa_final $3 "

Debug 4 "param4 lc_origem $4 "

Debug 4 "param5 lc_arq_tarefa $5 "





	local lc_check="$1" lc_ini="$2" lc_fim="$3" lc_origem="$4" lc_arq_servico="$5"

	local lc_str_canal  lc_remover_erros lc_arq_tarefa lc_linha



	# O correto amanhã é que esta função receba o nome do arquivo de serviço.





	# Recebe parâmetros

	#	1 - Tipo de atividade.

	#		[START] - Incializa o serviço.

	#		[STOP]	- Para o serviço.

	#		[PAUSE] - Pause as tarefas.

	#		[RESTART] - Reinicia as tarefas suspensas.



	lc_remover_erros="0" #Fla que irá controlar se tem ou não erro.



	Debug 1 "Lendo o que veio no arquivo de serviço lc_linha: $lc_linha [F:$FUNCNAME L:$LINENO]"



	if [ "${lc_check}" == "START" ]; then



		lc_linha=

		cont_temp=0



		while read lc_linha;do



			Debug 1 "Dentro do while == START [F:$FUNCNAME L:$LINENO]"



		    lc_str_canal=$(_strzero "${lc_linha}" 3)	# Nº do canal com zeros a esquerda.



			lc_nome_arq_tarefa_start="Start_${TAREFA}_${STR_ORIGEM}_canal_${lc_str_canal}.trf"

			lc_arq_tarefa_start_check="${FOLDER_START}/${lc_nome_arq_tarefa_start}"



			let cont_temp++



			Debug 2 "Jogou no Arq. da tarefa: $lc_arq_tarefa [F:$FUNCNAME L:$LINENO]"



			# Tenho o nome do arquivo pronto e vou gravar as informações.

			if ! [ -f "${lc_arq_tarefa_start_check}" ]; then

				# Tudo parece estar normal. O arquivo de tarefa não existe.

				# Vamos gravar o arquivo da tarefa.

				GravaArqStartTarefaIndividual "${lc_str_canal}" "${lc_arq_tarefa_start_check}"



			else



				lc_remover_erros="1" # Precisamos tratar e avisar sobre erros.



			fi



		done < "${lc_arq_servico}" # Usa arquivo do serviço.



		Debug 1 "Saindo do while [Função:$FUNCNAME Linha:$LINENO]"



	fi

}

###############################################################################

## @param1	"${lc_linha}" Canal usado no momento.

## @param2	"${lc_arq_tarefa_start_check}" - End. + arq. de Start no momento.

## Dependências:

########	Vars públicas:

#-----------------------------------------------------------------------------#

function GravaArqStartTarefaIndividual()

{

	local lc_linha="$1" lc_arq_tarefa="$2"



	Debug 2 "Entrei na função:[$FUNCNAME L:$LINENO] "

	Debug 2 "Parâmetros $* "



	# Só pode entrar nesta função se o arquivo de tarefa individual não existe.



	Debug 3 "Gravando Arquivo da tarefa: $lc_arq_tarefa [F:$FUNCNAME L:$LINENO]"



#	echo "${lc_linha}" >> ${lc_arq_tarefa}

	LUG_GravaLinhaArquivoTexto "${lc_linha}" "${lc_arq_tarefa}"



}