Aula14 ComandosInternos

Prévia do material em texto

Programação	
  para	
  Servidores	
  
Aula	
  14	
  
Sumário	
  
•  Comandos	
  internos;	
  
•  Exercícios.	
  
2	
  
Comandos	
  
•  O	
  shell	
  reconhece	
  três	
  Dpos	
  de	
  comandos:	
  
– Comandos	
  internos	
  ou	
  embuDdos:	
  são	
  aqueles	
  que	
  o	
  
próprio	
  shell	
  executa,	
  por	
  exemplo,	
  test,	
  echo	
  e	
  read.	
  
São	
  criados	
  internamente	
  por	
  questões	
  de	
  desempenho	
  
ou	
  acesso	
  a	
  informações	
  internas	
  ao	
  shell;	
  
– Funções	
  do	
  shell:	
  são	
  trechos	
  de	
  código	
  escritos	
  na	
  própria	
  
linguagem	
  do	
  shell	
  e	
  invocados	
  da	
  mesma	
  forma	
  que	
  um	
  
comando	
  (veremos	
  este	
  assunto	
  mais	
  adiante	
  no	
  curso);	
  
– Comandos	
  externos:	
  são	
  os	
  comandos	
  e	
  aplicaDvos	
  do	
  
sistema	
  operacional	
  que	
  o	
  shell	
  executa	
  através	
  da	
  criação	
  
de	
  um	
  processo	
  separado.	
  Exemplos:	
  ls,	
  cat,	
  cp	
  e	
  
date.	
  
3	
  
Comandos	
  internos	
  
•  Atuam	
  sobre	
  variáveis:	
  
– let:	
  executa	
  operações	
  matemáDcas	
  sobre	
  variáveis	
  e	
  
expressões;	
  
– set:	
  imprime	
  o	
  valor	
  da	
  variáveis	
  internas	
  do	
  shell;	
  
– unset:	
  remove	
  o	
  valor	
  de	
  uma	
  variável	
  interna	
  do	
  shell	
  
(atribui	
  o	
  valor	
  null);	
  
– export:	
  insere	
  uma	
  variável	
  no	
  ambiente,	
  ou	
  seja,	
  torna	
  
seu	
  escopo	
  global	
  de	
  forma	
  que	
  ela	
  pode	
  ser	
  acessada	
  por	
  
qualquer	
  instância	
  “filha”	
  do	
  shell	
  corrente;	
  
4	
  
Comandos	
  internos	
  
•  Exemplo:	
  
– o	
  script	
  abaixo	
  concatena	
  o	
  valor	
  atual	
  da	
  variável	
  PATH	
  
com	
  “:$HOME/novaPasta”	
  e	
  em	
  seguida	
  salva	
  o	
  novo	
  valor	
  
no	
  ambiente:	
  
PATH=$PATH:$HOME/novaPasta 
export PATH 
5	
  
Comandos	
  internos	
  
•  Comandos	
  que	
  afetam	
  o	
  comportamento	
  do	
  script:	
  
– source:	
  tem	
  a	
  mesma	
  funcionalidade	
  do	
  comando	
  ponto	
  
(.),	
  importa	
  um	
  arquivo	
  que	
  pode	
  ter	
  textos,	
  declarações	
  
de	
  variáveis	
  e	
  funções	
  ou	
  mesmo	
  comandos;	
  
•  Se	
  o	
  arquivo	
  Dver	
  permissão	
  de	
  execução,	
  seus	
  comandos	
  serão	
  
executados	
  localmente,	
  inclusive	
  com	
  a	
  possibilidade	
  de	
  passagem	
  
de	
  argumentos.	
  Exemplo:	
  
source $filename $arg1 $arg2 
– exit:	
  encerra	
  a	
  execução	
  do	
  script;	
  
– exec:	
  subsDtui	
  o	
  processo	
  corrente	
  pelo	
  programa	
  ou	
  
comando	
  passado	
  como	
  parâmetro.	
  
6	
  
Comandos	
  internos	
  
•  Exemplo	
  source:	
  
– o	
  script	
  abaixo	
  executa	
  os	
  comandos	
  que	
  esDverem	
  no	
  
arquivo	
  “comandos.txt”	
  e	
  em	
  seguida	
  imprime	
  na	
  tela	
  a	
  
palavra	
  “fim”:	
  
source ./comandos.txt 
echo "fim" 
Ou,	
  de	
  forma	
  equivalente,	
  
. ./comandos.txt 
echo "fim" 
7	
  
Comandos	
  internos	
  
•  Exemplo	
  exec:	
  
– o	
  script	
  abaixo	
  imprime	
  uma	
  mensagem	
  na	
  tela	
  usando	
  o	
  
comando	
  exec	
  e	
  em	
  seguida	
  termina:	
  
# Script para ilustação do exec 
exec echo "Saindo de \"$0\" na linha $LINENO." 
# A linha abaixo nunca será executada. 
echo "Esta mensagem nunca será exibida." 
exit 99 
# Verifique seu status de saída: 
#echo $? 
8	
  
Comandos	
  internos	
  
•  Exemplo	
  exec:	
  
– o	
  script	
  abaixo	
  imprime	
  mensagens	
  na	
  tela,	
  espera	
  1s	
  e	
  
depois	
  executa	
  ele	
  próprio	
  novamente	
  usando	
  o	
  comando	
  
exec:	
  
echo "Esta linha aparece só uma vez." 
echo "O PID desta instância é $$." 
echo "========= Pressione Ctl-C ==========" 
sleep 1 
exec $0 
echo "Esta linha nunca deve aparecer!" 
9	
  
Comandos	
  internos	
  
•  Comandos	
  para	
  controle	
  de	
  jobs:	
  
– jobs 	
  lista	
  os	
  jobs	
  executando	
  em	
  segundo	
  plano	
  no	
  
shell,	
  fornecendo	
  o	
  número	
  do	
  job;	
  
– ps 	
  lista	
  os	
  processos	
  em	
  execução;	
  
– $! retorna	
  o	
  número	
  do	
  processo	
  que	
  acaba	
  de	
  ser	
  
criado	
  (usado	
  com	
  o	
  comando	
  kill	
  para	
  “matar”	
  o	
  
processo);	
  
10	
  
Comandos	
  internos	
  
•  Comandos	
  para	
  controle	
  de	
  jobs	
  (cont.):	
  
– wait 	
  aguarda	
  o	
  final	
  da	
  execução	
  dos	
  jobs	
  que	
  estão	
  em	
  
segundo	
  plano.	
  Se	
  passarmos	
  como	
  argumento	
  o	
  ID	
  de	
  um	
  
job,	
  aguarda	
  este	
  job	
  especificamente;	
  
•  Exemplos:	
  wait	
   (aguarda	
  todos	
  os	
  processos	
  em	
  BG)	
  
 wait 2134 (aguarda	
  o	
  processo	
  2134) 
– kill 	
  força	
  o	
  encerramento	
  de	
  um	
  processo	
  enviando	
  ao	
  
processo	
  um	
  código	
  de	
  encerramento.	
  
•  Exemplo:	
  	
  
sleep 1200 & 
idProcesso=$! 
kill $idProcesso (“mata”	
  o	
  processo	
  sleep) 
11	
  
Comandos	
  internos	
  
•  Exemplo:	
  
– o	
  script	
  abaixo	
  aguarda	
  pela	
  execução	
  de	
  um	
  comando	
  em	
  
background:	
  
echo -n "Aguarde uma coisa importante... " 
echo "Isto pode demorar alguns minutos." 
sleep 10 & 
echo -n -e "\nVeja: o script poderia continuar," 
echo "mas agora ele vai esperar..." 
wait 
# O restante só será executado ao final do sleep 
echo -e "\n-----\nfim.\n-----" 
12	
  
Comandos	
  internos	
  
•  Outros	
  comandos:	
  
– true:	
  sempre	
  retorna	
  um	
  código	
  de	
  saída	
  de	
  sucesso	
  (0);	
  
– false:	
  sempre	
  retorna	
  um	
  código	
  de	
  saída	
  sem	
  sucesso;	
  
– help:	
  fornece	
  uma	
  tela	
  de	
  ajuda	
  sobre	
  a	
  uDlização	
  de	
  
comandos	
  internos.	
  
13	
  
Comandos	
  internos	
  
•  Exemplo:	
  
– o	
  script	
  abaixo	
  imprime	
  na	
  tela	
  os	
  números	
  de	
  1	
  a	
  10:	
  
cont=1 
while true; do 
 echo $cont 
 ((cont++)) 
 if [ $cont -gt 10 ]; then 
 break 
 fi 
done 
14	
  
Exercícios	
  
1.  Escreva	
  um	
  script	
  chamado	
  entrada.sh	
  que:	
  
1.  Leia	
  o	
  nome	
  e	
  o	
  ano	
  de	
  nascimento	
  do	
  usuário;	
  
2.  Armazene	
  estas	
  informações	
  nas	
  variáveis	
  nome	
  e	
  data;	
  
2.  Escreva	
  um	
  script	
  denominado	
  saida.sh	
  que	
  uDlize	
  o	
  comando	
  
source	
  para	
  “importar”	
  o	
  script	
  entrada.sh	
  e	
  imprimir	
  na	
  tela	
  o	
  
nome	
  e	
  a	
  idade	
  do	
  usuário;	
  
3.  Reescreva	
  o	
  script	
  entrada.sh	
  do	
  exercício	
  anterior	
  de	
  forma	
  a:	
  	
  
1.  UDlizar	
  o	
  comando	
  export	
  para	
  tornar	
  global	
  os	
  valores	
  das	
  variáveis	
  nome	
  e	
  data;	
  
2.  Executa	
  o	
  script	
  saida.sh	
  para	
  usar	
  essas	
  variáveis	
  globais	
  e	
  imprimir	
  na	
  tela	
  o	
  
nome	
  e	
  a	
  idade	
  do	
  usuário.	
  	
  
4.  Reescreva	
  o	
  script	
  saida	
  removendo	
  o	
  comando	
  source.	
  Neste	
  caso,	
  
este	
  script	
  somente	
  funcionará	
  adequadamente	
  se	
  as	
  variáveisnome	
  e	
  
data	
  já	
  exisDrem	
  no	
  ambiente;	
  
15	
  
Exercícios	
  
5.  Escreva	
  um	
  script	
  que	
  uDlize	
  os	
  comandos	
  wait	
  e	
  kill.	
  
Pro	
  exemplo,	
  inicialize	
  um	
  processo	
  em	
  background	
  e	
  depois	
  
de	
  alguns	
  segundos	
  “mate”	
  esse	
  processo	
  (kill).	
  Depois,	
  
inicialize	
  outro	
  processo	
  em	
  background	
  e	
  espere	
  o	
  seu	
  
término	
  (wait);	
  
6.  UDlizando	
  o	
  comando	
  true,	
  escreva	
  um	
  script	
  que	
  repita	
  o	
  
processo	
  abaixo	
  até	
  que	
  o	
  usuário	
  digite	
  a	
  palavra	
  “quit”:	
  
a)  Leia	
  o	
  nome	
  de	
  um	
  arquivo	
  digitado	
  pelo	
  usuário;	
  
b)  Leia	
  um	
  caminho	
  digitado	
  pelo	
  usuário;	
  
c)  Copie	
  o	
  arquivo	
  solicitado	
  para	
  o	
  caminho	
  dado.	
  Se	
  o	
  arquivo	
  ou	
  o	
  
diretório	
  não	
  exisDr,	
  imprima	
  uma	
  mensagem	
  de	
  erro	
  e	
  conDnue	
  o	
  
processo.	
  
16