Como alterar a propriedade de um determinado diretório antes de reiniciar um serviço

Question

Estou tentando escrever um script que colocarei no cron job.

O script vai checar a cada 5 minutos se o processo estiver rodando se não tiver que iniciar o processo, mas meu problema é que enquanto o processo é iniciado, ele é de propriedade root e altera alguns arquivos em um diretório específico. Eu queria fazer o script iniciar o serviço e esperar 10 segundos e parar o serviço, depois disso ele iria para o diretório específico e mudaria a propriedade de todos os arquivos desse diretório e então o script iniciaria o serviço novamente. / p>

Espero que minha explicação faça sentido.

Aqui está o que eu criei até agora. O script funciona para iniciar e parar o serviço, mas o tempo limite cai quando o serviço é interrompido e não altera nenhuma propriedade no diretório fornecido

#!/bin/bash
exec_start="sudo systemctl start new-service"
exec_stop="sudo systemctl stop new-service"
check1=/root/testing/
username="user1"
process="new-service"

changing_ownership () {
cd $check1 && /usr/bin/chown $username:$username *
}

startAndStop(){
/usr/bin/sudo su - user1 && $exec_start &
 sleep 10 && $exec_stop &
 sleep 2 && exit
}

startAgain(){
/usr/bin/sudo su - user1 && $exec_start &
sleep 5 && exit
}

if ps ax | grep -v grep | grep $process > /dev/null
then
 echo "running"
 exit

else
 echo "Not running...Going to start the service"
 startAndStop
 changing_ownership
 startAgain
fi

exit

Aqui está o conteúdo de / root / testing /

[root@server2 ~]# cd -
/root/testing
[root@server2 testing]# ll
total 0
-rw-r--r--. 1 root root 0 Sep 24 21:34 file1
-rw-r--r--. 1 root root 0 Sep 24 21:34 file2
-rw-r--r--. 1 root root 0 Sep 24 21:34 file3
-rw-r--r--. 1 root root 0 Sep 24 21:39 file8888

Obrigado

    

Answer 1

Problemas de casal que vejo.

Eu fiz um script de teste simples:

#!/bin/bash
startAndStop(){
        echo "Start 1" &
        echo "Sleep 2" && echo "Stop 3"
        echo "Sleep 4" && exit
}
startAndStop
echo "Rest of Script"

Isso simula a função startAndStop do seu programa.

Aqui está a saída:

$ bash test.sh
Sleep 2
Stop 3
Sleep 4
Start 1

Dois pontos sobre essa função:

1. As coisas são executadas fora de ordem. O único & origina a tarefa inicial. Tem certeza de que queria fazer isso? Você não gostaria de esperar que o processo fosse concluído, começando a pará-lo? Eu sei que você coloca sleep s, mas esperar que saia é melhor, eu acho. As coisas podem ficar muito estranhas se o comando não terminar a tempo.

2. Observe como não foi impressa Rest of Script . O comando exit não sai da função, ele sai do script inteiro.

Você tem /usr/bin/sudo su - user1 && $exec_start . Eu não acho que é isso que você queria fazer. Você define exec_start="sudo systemctl start new-service" . Então, o que você acaba fazendo é mudar para user1 e, em seguida, elevando para permissões de root para iniciar o serviço. Novo script, na minha máquina. $(pwd) imprimirá o diretório atual.

#!/bin/bash
sudo su - user1 && /usr/bin/sudo echo $(pwd)

Vamos executá-lo:

[root]$ bash test.sh
[user1]$

Eu tenho uma concha! O && aguarda a conclusão do comando anterior - a saber, sudo su - , que fornece um shell de root. O comando echo não foi executado até eu sair do shell:

[user1]$ exit
logout
/root
[root]$

Mesmo assim, ele forneceu o diretório /root , não /home/user1 . Isso definitivamente não é o que você queria. Que tal adicionar este script ao crontab para rodar como usuário ? Esta seria a linha crontab do root:

 */5      *       * * *   user1    /home/user1/new-service-watch.sh

Dessa forma, você não teria que mexer com o usuário do switch duplo. O script será iniciado por cron as user1 , então você só precisa sudo para poder executar systemctl e manter todo o resto como usuário.

Aqui está uma ideia rápida. Por favor, não use como está !!!!

edit: alterando o script para iniciar o serviço como usuário1, por solicitação. removeu $sudo_cmd das definições exec_start e exec_stop .

* edit2: chowning deve usar sudo caso os arquivos sejam de propriedade de root. Além disso, parar o serviço deve usar sudo apenas no caso de root ter iniciado o processo. '

#!/bin/bash
sudo_cmd="/usr/bin/sudo" # these are just my paths, change as needed
chown_cmd="$sudo_cmd /usr/bin/chown" # added sudo
systemctl_cmd="/bin/systemctl"
date_cmd="/bin/date"
# if define process before exec_start & exec_stop, 
# you can use it in your exec_start & exec_stop definitions
process="new-service"
exec_start="$systemctl_cmd start $process" # don't sudo so it runs as user1
exec_stop="$sudo_cmd $systemctl_cmd stop $process" # added sudo
check1="/root/testing"
username="user1"
log_file="/var/log/new-service-watch.log" # why not log things? :)

# putting the entirety of the execution in 
# braces lets you pipe it somewhere easily
{ # start_brace
changeOwnership()
{
    echo "$($date_cmd) Changing ownership"
    # there is no need to change directory
    # because we will use '-R' to be recursive
    $chown_cmd -R $username:$username $check1
}

startService()
{
    echo "$($date_cmd) Starting $process"
    $exec_start
    sleep 5
}

stopService()
{
    echo "$($date_cmd) Stopping $process"
    $exec_stop
    sleep 5
}

if ps ax | grep -v grep | grep $process > /dev/null
then
    echo "$($date_cmd) Running...No action needed."
else
    echo "$($date_cmd) Not running...Going to start the service."
    startService
    stopService
    changeOwnership
    startService
fi
} >> "$log_file" # end_brace