NOTA: executar como root.

É um código criado para fazer instalações de programas pelo código fonte, assim como desinstalá-los.

Através dessas ações. o instalador conta com dois arquivos de requisito, um do programa e outro para seu local em disco. Outras informações estão no cabeçalho do código.

Modos de instalação:

1) Criando alias no arquivo /root/.bashrc. Exemplo:

alias sci-G-2.0='sh /home/$USER/source_code_installer_gamma.2.0'

2) Colocando o programa em um dos diretórios da variável PATH. Exemplo: /usr/bin

3) Adicionar o caminho onde se localiza o programa na variável PATH.

Requisitos:

a) dialog
b) make

Versão atual: GAMMA 2.0

Qualquer bug, reporte nos comentários e claro, diga sua opinião também!

Próximas versões vão vir com tela para interação, depois dessa, com opções na linha de comando.

Caso ache o código meio bruto é porque ainda estou aprendendo shell script.

• Download gamma.sh
• Enviar nova versão

Esconder código-fonte

#!/bin/bash
#
# NOTA: !!!!!! EXECUTAR O CÓDIGO LOGADO COMO ROOT !!!!!!!
# 
# Nome: Instalador de Código-Fonte G-2.0
# 
# Informação:
#
# AUTOR: Mac Brener
# NICK:  Skaylen Viva-o-linux
# LOCAL: /home/mac/script
#
# Descrição do programa:
#
# O programa Intalador de Código Fonte G-2.0, instala 0 programa 
# pelo seu código fonte.
 
# Já realizado o download do programa desejado, o Instalador faz a 
# cópia e envia o programa para uma pasta que é criada pelo usuário. 

# Enviado o progama para 'pasta', o Instalador realiza  uma análise 
# de qual tipo de compactação tem o arquivo e extrai. 

#Feita a extração,  o Instalador verifica a existência dos arquivos que tem as instruções 
# de compilação e instalação do programa que são os seguintes arquivos: 

# INSTALL, README, configure, Makefile, README.linux. Caso os arquivos 
# existam principalmente os: README, configure, Makefile, 

# O Instalador de Código-Fonte executa os comandos: 
# ./configure && make && make install && make clean, dentro da pasta do
# programa.

# Além disso, ele dispõe da opção de fazer mais de uma vez, 
# porém somente depois de ter feito todo o processo, retornando para a 
# cópia do arquivo comprimido.

# Arquivos de configuração:
# 
# 1) source_code_installer-gamma.log: 
# ==> Arquivo para o registro dos programas instalados com o nome,
#     versão e data/hora de instalação.
#
# 2) caminho_programa.log:
# ==> Arquivo que armazena o caminho do diretório do programa instalado.

#     Este documento é usado para a desinstalação.
#
# Versões: 
#
# <Versões>               <Modificações>
# 
#  ALPHA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
# ALPHA Versão 1.0 ==> Original.
# ALPHA Versão 1.1 ==> Incrementação dos comentários e explicações.
# ALPHA Versão 1.2 ==> Foi renomeado as variáveis e funções.
# ALPHA Versão 1.3 ==> Corresão da função criar_pasta.
# ALPHA Versão 1.4 ==> Corresão da função existencia.
# ALPHA Versão 1.5 ==> Criação da função log.
# ALPHA Versão 1.6 ==> Criação de títulos para as funções.
# ALPHA Versão 1.7 ==> Adição de linhas em branco.
# ALPHA Versão 1.8 ==> Releitura do código.
# ALPHA Versão 1.9 ==> Função desinstalar e correções.
# ALPHA Versão 2.0 ==> Correções.
# ALPHA Versão 2.1 ==> Correções de bugs.
# ALPHA Versão 3.0 ==> Adição da função registro.
# ALPHA Versão 4.0 ==> Adição da função deletar.
# ALPHA Versão 5.0 ==> Remoção da função user_comum. 
#                            ==> Na função deletar foi adionado resposta para
#                            ==> caso não ache o programa no arquivo caminho_programa.log 
#                            ==> com até 3 tentaticas.
# ALPHA Versão 6.0 ==> Remoção dos break do código.
#                            ==> Correção das variáveis de ambiente.
#                             ==> Alteações diversas.
#                             ==> Correção do bug na função desistalar.
#
#  BETA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
# BETA Versão 1.0  ==> Original, sem um programa de extração externo
# BETA Versão 2.0  ==> Correções. Alterações na função extrator.
#                            ==> Remoção do menu da função extrator.
#                              ==> Remoções de função de extração dos arquivos em tar.
#
#  GAMMA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
# GAMMA Versão 1.0 ==> Extrair os arquivos de forma independente do usuário.
#                              ==> Verificar os arquivos de configuração independente do usuário.
# GAMMA Versão 2.0 ==> Redução das opções da função do menu.
#                              ==> Processso continuo, sem retorno constante ao menu.
#
#

           ###################
# -> Menu que é exibido na tela do bash.
menu(){
# -> Limpa a tela para a execução do programa.
clear
            ###################
   echo
   echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "        Instalador de Código-Fonte G-2.0 "
   echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<" # -> Cabeçario do programa.
   echo 
   echo
   echo "         ------------------------------------------"
   echo "         |                 Menu                   |"
   echo "         ------------------------------------------"
   echo "         | [ 1 ] Iniciar                          |" # -> Função criar_pasta.
   echo "         | [ 2 ] Desistalar                       |" # -> Função desinstalar.
   echo "         | [ 3 ] Arquivos                         |" # -> Função registro
   echo "         | [ s ] Sair                             |" # -> Sair.
   echo "         ------------------------------------------"
   echo 
   echo -n "Digite o valor desejado: " 
   read num
           ###################
# -> Localiza as funções conforme a númeração.
 case $num in

   1) user_comum ;;
   2) desinstalar ;;
   3) registro ;;
   s) clear && exit ;;
   *) echo "Opção desconhecida."; menu ;;
   esac
 
}
           ###################
# -> Funções independentes <NÃO ALTERAR>.
           ###################
# -> Informa a pasta atual.
local_pasta(){
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo -n "Você se encontra em:  " 
   sleep 0.4 
   pwd             
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
}
           ###################
# -> Exibe três pontos.
pontos(){
x=1;
while [ "$x" -le 3  ]; do
   let x=x+1;
   echo -n "."
   sleep 0.5
   done

   read
}
           ###################
# -> Paralisa a operação, até que seja pressionada a tecla <ENTER> ou outra tecla.
enter(){
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo -n "Aperte <ENTER> para continuar"; pontos 
   #clear # -> Caso queira manter a tela mais limpa...                    
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
}
           ###################
# -> Deleta a pasta do programa que foi desinstalado, caso o usuário queira.
deletar(){
   read -p "Deseja deletar a pasta? [Sim(s) ou Não(n)]? " deletar

if [ "$deletar" != "${deletar#[Ss]}" ] ;then
   echo 
       cd $CAMINHO
   local_pasta   
   ls -la
   enter
   rm -dr $PASTA
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
   echo "Pasta deletada com sucesso!!!!"
   echo
   sleep 0.6
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   ls -la    
   sed -i '$d' /root/.bashrc  # -> Remove a última linha do arquivo .bashrc;
   sed -i '$d' /root/.bashrc  # -> Cuidado ao fazer CTRL+C, no terminal,
   menu             # pode fazer o Instalador enviar as mesmas variáveis 
else                # para o arquivo .bashrc, só removendo manualmente
    remover_variaveis
    clear 
    sleep 2
    exit
fi
}
           ###################
# -> Verifica se a variável LOG está no arquivo /root/.bashrc,
# caso não esteja cria ela.
variavel(){

LOG=log; # -> Usada para o caminho dos arquivos de log.

if grep LOG /root/.bashrc; then
      echo
      echo "Variável existente."
      echo
      criar_pasta
else
   echo "Variável inexistente."
   echo
   read -p "Digite o caminho para os arquivos de log: " log
   echo
   echo "export LOG=$log" >> /root/.bashrc
   criar_pasta
fi
}
           ###################
# -> Verifica o arquivo /root/.bashrc existe,
# caso contrário, é criado.
documento_log(){

if [ -f /root/.bashrc ]; then
   echo
   echo "Arquivo .bashrc existente."
   sleep 1
   echo
   variavel
else
   echo
   echo "Arquivo .bashrc inexistente." 
   sleep 1
   echo
   touch .bashrc   
   echo ".bashrc criado com sucesso."  
   echo
   variavel
fi
}
           ###################
# -> Salva o usuário comum par air na pasta Downloads.
user_comum(){
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Informe seu Usúario"
sleep 0.5
echo
   echo -n "Digite seu usuário comum: "
   sleep 1
   read usercm
   echo
   export usercm
   echo "Usuário salvo!!"
   echo
   local_pasta 
   enter
   sleep 1
   documento_log
}
           ###################
# -> Remove todas as variáveis do sistema que foram criadas.
remover_variaveis() { 
   unset usercm
   #unset caminho  # -> Não pode ser removido. 
   #unset pasta    # -> Não pode ser removido. 
   unset arquivo
   unset nome_arq
}
           ###################
# -> Aqui o programa exibe o que tem dentro da pasta Downloads,
# copia o arquivo e se dirige para a pasta criada pelo usuário. 
# Ainda verifica se o arquivo já foi copiado.
copiar_arquivo() { 
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "Direcionando para a pasta Downloads"
   sleep 0.5
   echo
   ls -l /home/$usercm/Downloads
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Copiar Arquivo"
   sleep 0.5
   echo
   echo -n "Digite o nome do arquivo que deseja extrair: " 
   read arquivo 
   export arquivo 
   cd $caminho/$pasta
if [ -e $arquivo ]; then
   echo
   echo "Arquivo já foi copiado."
   sleep 0.5
   echo
   enter
   extrator
else
   cd /
   echo
   echo "Arquivo inexistente."
   sleep 0.5
   echo
   echo "Copiando arquivo..."
   sleep 0.5
   echo
   sleep 1
   cp -v /home/$usercm/Downloads/$arquivo $caminho/$pasta && cd $caminho/$pasta
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
   echo "Arquivo copiado!!"
   sleep 0.5
   echo
   local_pasta
    enter
   extrator 
fi
}
           ###################
# -> Instala do programa sem o comando ./configure.
instalarx(){
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Instalar"
sleep 0.5
echo
   local_pasta
   enter
   make && make clean && make install 
   enter
   dialogo(){
   dialog --title 'ATENÇÃO!!!!!' \
   --msgbox 'Não apague a pasta do programa, ela 
é necessária para a desinstalação.' 6 40
   clear
}      
   dialogo   
   read -p "Deseja instalar mais um programa? [Sim(s) ou Não(n)] " sn
   
if [ "$sn" != "${sn#[Ss]}" ] ;then
   echo 
   copiar_arquivo
   
      else
       echo 
      remover_variaveis 
       clear 
      exit 
 fi  
}
           ###################
# Fim das funções independentes.
           ###################
# Abre os arquivos de log do Instalador.
registro(){

clear
   echo
   echo "         -------------------------------------------------"
   echo "         |         Arquivos de Registro                  |"
   echo "         -------------------------------------------------"
   echo "         | [ 1 ] Abrir install-code-source-alph.log      |" 
   echo "         |-[+++++++++++++++++++++++++++++++++++++++++++]-|" 
   echo "         | [ 2 ] Abrir caminho_programa.log              |" 
   echo "         |-[+++++++++++++++++++++++++++++++++++++++++++]-|" 
   echo "         | [ 3 ] Voltar                                  |" 
   echo "         -------------------------------------------------"
   echo 
   echo -n "Digite o valor desejado: " 
   read numero
   sleep 1
   echo
           ###################
 case $numero in
   # Caso queira mudar o endereço altere nos itens '1' e '2'.
   1) nano $LOG/source_code_installer-alph.log && registro;;
   2) nano $LOG/caminho_programa.log && registro ;;
   3) clear; menu ;;
   *) echo "Opção desconhecida."; registro ;;
   esac
 
}
           ###################
# -> Cria uma pasta com o nome desejado que será mandado o arquivo 
# comprimido. Além disso, ele salva o caminho para a pasta para 
# iniciar a extração, pórem antes verifica e a pasta existe no endeço infomado.
criar_pasta(){
          ###################
# Salva o nome do usuário, que servirá para entrar nas pastas
# mesmo estando como ROOT.
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Criar Pasta"
sleep 0.5
   echo
   echo -n "Digite o local para a criação: "
   read caminho 
   sleep 0.5
   echo
   echo -n "Digite o nome da pasta: " 
   read pasta 
   echo "export CAMINHO="$caminho"" >> /root/.bashrc # -> Exporta a variáriavel para o arquivo .bashrc.
   echo "export PASTA="$pasta"" >> /root/.bashrc     

  if [ -d "$caminho/$pasta" ]; then
   echo
   echo "$pasta existe."
   sleep 0.5                               # -> Caso a respota seja verdadeira 
   echo                          # a condicional chama a função   
   copiar_arquivo                    # copiar_arquivo.  
  else
   echo "Pasta inexistente."      # -> Caso a resposta seja falsa a condicional 
   echo          # cria a pasta e chama a função copiar_arquivo. 
   mkdir $caminho/$pasta
   echo "Pasta criada!!!"
   echo
   sleep 0.5
    enter
   copiar_arquivo
 fi

}


# -> O Instalar extrai de acordo com a extensão, de forma independente.
extrator() {
echo "               Extrator"
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo

   local_pasta
   cd  $caminho/$pasta
   local_pasta
   ls -la $nome_arquivo
   enter

# Variáveis para a comparação.
pesquisa=$(find -maxdepth 1 -iname "*.tar.gz" -o -iname "*.tar.bz" -o \
-iname "*.tar.bz2" -iname "*.tar.xz" -o -iname "*.zip" -o -iname "*.tar");
ext7=$(echo $pesquisa | rev | cut -c 1-7 | rev)
ext4=$(echo $pesquisa | rev | cut -c 1-4 | rev)

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

if [ "$ext7" == ".tar.gz" ]; then   
   echo
   ls -l 
   echo
   tar -xzvf $pesquisa
   rm $pesquisa
   echo
   echo "Extração concluida!!!"
   echo
   ls -l
   enter
   verificar_arquivos

elif [ "$ext7" == ".tar.bz" ]; then
   echo
   ls -l 
   echo
   tar -xjvf $pesquisa 
   rm $pesquisa
   echo
   echo "Extração concluida!!!"
   echo
   ls -l
   enter
   verificar_arquivos

elif [ "$ext7" == "tar.bz2" ]; then
   echo
   ls -l 
   echo
   tar -xjvf $pesquisa 
   rm $pesquisa
   echo
   echo "Extração concluida!!!"
   echo
   ls -l
   enter
   verificar_arquivos

elif [ "$ext7" == ".tar.xz" ]; then
   echo
   ls -l 
   echo
   tar -xJvf $pesquisa 
   rm $pesquisa
   echo
   echo "Extração concluida!!!"
   echo
   ls -l
   enter
   verificar_arquivos

elif [ "$ext4" == ".zip" ]; then
   echo
   ls -l 
   echo
   unzip -v $pesquisa
   rm $pesquisa 
   echo
   echo "Extração concluida!!!"
   echo
   ls -l
   enter
   verificar_arquivos

elif [ "$ext4" == ".tar" ]; then
   echo
   ls -l 
   echo
   tar -xvf $pesquisa 
   rm $pesquisa
   echo
   echo "Extração concluida!!!"
   echo
   ls -l
   enter
   verificar_arquivos

else 
   echo
   echo "Ouve algum erro!!!"
    echo
   echo " :("
   echo
   remover_variaveis
   exit 1

fi
}
           ###################
# -> O Instalador verifica a existência dos arquivos: 
# INSTALL, README, configure, Makefile, README.linux, 
# dependendo de qual seja ele segue para função instalar ou sai do programa.
verificar_arquivos() {
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Verificar Arquivos de Instalação"
sleep 0.5
echo
   local_pasta
   ls -la # Tenho que está no caminho /$caminho/&pasta.
   nome_arq=`ls`
   export nome_arq
   sleep 1
   echo
   enter
   # A função log faz o registro do programa instalado.
   log(){
      echo "#####################################################"
      echo
      echo "PROGRAMA: $nome_arq"
      echo "DATA: `date`"
      echo
}
   cd $caminho/$pasta/$nome_arq
   log >> /home/mac/script/log_scripts/source_code_installer-gamma.log
   echo "$caminho/$pasta/$nome_arq" >> /home/mac/script/log_scripts/caminho_programa.log
   ls -la # Estou na pasta que extrai, $nome_arq.
   echo
   enter
           ###################
#Variáveis dos arquivos.
install=INSTALL 
CONFIGURE=configure 
readme=README 
make=Makefile
read_linux=README.linux
           ###################
   documento(){
# Condicional verifica se os arquivos se encontra na pasta especificada.
if [ -e "$install" ]; then 
   echo
   echo "Arquivo $install se encontra."
   sleep 1
   echo
   nano $install
   sleep 0.5
   instalar
   elif [ -e "$readme" ]; then
   echo
   echo "Arquivo $readme se encontra."
   sleep 1
   echo
   nano $readme
   sleep 0.5
   instalar
   elif [ -e "$make]" ]; then
   echo
   echo "Arquivo $make se encontra."
   sleep 1
   echo
   sleep 0.5
   instalar   
   elif [ -e "$read_linux" ]; then
   echo
   echo "Arquivo $read_linux se encontra."
   sleep 1
   echo
   nano $read_linux
   sleep 0.5
   instalar
 else    # -> Caso não encontre os arquivos...
   echo   
   echo "Arquivos inexistentes."
   sleep 1 
   echo                                 
   xdg-open $caminho/$pasta/$nome_arq # -> Abre a pasta do programa. 
   remover_variaveis
   exit
fi
}
           ###################
# -> Condicional verifica se o arquivo configure existe,
# caso exista o programa pode execultar ./configure, 
# pelo contrário não poderá.
if [ -e "$CONFIGURE" ]; then
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
   echo "Arquivo $CONFIGURE se encontra."
   echo
   sleep 1
   documento
   instalar
else
   echo
   echo "Arquivo inexistente."
   echo
   sleep 1
   documento   
   instalarx
fi


}
           ###################
# -> Aqui é executado a compilação e a instalação do programa 
# pelo seu código fonte.
instalar() {
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Compilar & Instalar"
sleep 1
echo
   local_pasta
   enter
   ./configure && make && make clean && make install 
   echo 
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
   echo "Trabalho Concluido!!!!!"
   echo
   enter
   dialogo(){ 
   dialog --title 'ATENÇÃO!!!!!' \
   --msgbox 'Não apague a pasta do programa, ela 
é necessária para a desinstalação.' 6 40
   clear
}       
   dialogo     
   read -p "Deseja instalar mais um programa? [Sim(s) ou Não(n)] " sn
   
if [ "$sn" != "${sn#[Ss]}" ] ;then
   echo 
   copiar_arquivo
   
      else
       echo 
      remover_variaveis 
       clear 
      exit 
 fi  
}

           ###################
# -> Para desistalar o programa.
desinstalar(){
           ###################
   verificar(){
   
# -> Arquivos.
CONFIGURE=configure 
make=Makefile
           ###################
# -> Condicional verifica se os arquivos se encontra na pasta expecificada.
if [ -e "$CONFIGURE" ]; then
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo
   echo "Arquivo $CONFIGURE se encontra."
   sleep 1
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   ./configure && make uninstall && make clean # -> Executa a configuração e a desinstalação.
   enter
   deletar
   menu # -> Volta para o menu.
   elif [ -e "$make" ]; then
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "Arquivo $make se encontra."
   sleep 1
   echo
   make uninstall && make clean # Executa a desinstalação.
   deletar
   enter
   menu 
   
 else 
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "Arquivos inexistentes"
   sleep 1 
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "Impossível desinstalar"
   echo
   sleep 1   
   exit
fi
}
           ###################
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "        Desinstalar"
sleep 05
echo
# -> Variável.
x=1;
   cd $LOG/

# -> Procura o caminho no arquivo, caso não ache tem o número de até 3 tentativas,
# caso seja certo ele avisa e prossegue com o programa.
while [ $x -le 3 ]; do
   let x=x+1;
read -p "Digite o nome do programa que deseja desinstalar: " desinstalar
if grep -w "$desinstalar" caminho_programa.log; then
   echo
   echo -e  "Programa encontrado ${desinstalar}."
   read -p "Informe o caminho do programa: " programa
   cd $programa
   echo
   verificar
else
   echo
   echo -e  "Programa não encontrado ${desinstalar}."
   echo
   sleep 1
   echo
fi
           ###################
done
           ###################
}
           ###################
menu # -> A Função principal "menu" tem que está por 
     # último para leitura de todas as opções do programa.
# -> Código Finalizado.
           ###################

Limpando memória em cache do sistema!!!

iniciar squid automático

O que fazer após instalar o Debian 8 - versão em Shell Script

Criar pacotes .deb apartir de script

FTP Linux-Windows Baseado na Data Atual