PHP, MVC e hello world!

Neste post, vamos abordar a implementação da arquitetura MVC, com um exemplo prático, em PHP do clássico programa Hello World, para iniciantes.
Em artigo anterior, expliquei os conceitos básicos da arquitetura de projetos de software MVC (MODEL — VIEW — CONTROLLER). Agora, o objetivo é mesclar a teoria com a prática.

O que é a arquitetura MVC?

Embora possamos traduzir “model, view, controller” para “modelo, visão, controlador”, vou optar, neste post por mantê-los na forma original, para enriquecer um pouco o vocabulário do artigo.
A implementação original do MVC, na linguagem Smalltalk-80, com algumas variações, contém conceitos que se descrevem assim:

MODEL

Na sua forma mais simples, o MODEL armazena dados que serão acessados pelo VIEW e escritos pelo CONTROLLER.
É a parte mais complexa do sistema e contém toda a lógica específica da aplicação e é onde as entidades de domínio (domain entities), relativas aos conceitos do mundo real são armazenadas — tais como “um usuário” ou “uma ordem”).
É a parte da aplicação que recebe dados e os processa.
Além disto, lida com todos os acessos e armazenamento de dados — e não tem conhecimento dos CONTROLLERS ou VIEWS que fazem uso dele (o MODEL).

MODELS são aqueles componentes do sistema que realmente fazem o trabalho.

Por exemplo, no PHP, o MODEL pode representar um “usuário”, no sistema.
Ele pode tomar conta de todas as operações relacionadas aos usuários — gravando registros, recuperando-os, validando-os etc.
O que o MODEL NÃO É:

  • um simples ponto de acesso a dados;
  • uma classe chamada “model” que representa uma tabela dentro do banco de dados.

O VIEW

O view contém toda a lógica do display.
No PHP, esta é a parte da aplicação que gera o HTML.
Tem acesso direto ao MODEL e pode inquiri-lo para obter seus dados.
O VIEW pode criar callbacks para seu CONTROLLER — como um botão que, ao ser clicado, inicia uma ação).
No MVC, o VIEW interpela o MODEL para obter dados, diretamente.
Para evitar erros de interpretação, o VIEW NÃO É:

  • ausente de lógica;
  • receptor de dados do CONTROLLER.

O QUE É CALLBACK

Literalmente, callback quer dizer “chame de volta”.
Em computação, é uma porção de código executável, passado como parâmetro a outra porção de código.
Quando apropriado, a callback pode ser invocada e executada.

O CONTROLLER

O CONTROLLER recebe as entradas do usuário e atualiza o MODEL onde requerido.
Quando não houver interação humana direta, não há necessidade do CONTROLLER.
Em função disto, é importante que se diga, que não se trata de um mediador ou passagem entre qualquer uma das duas outras entidades.
O CONTROLLER acessa o MODEL, mas não contém qualquer lógica de display — tudo o que ele faz é responder às entradas do usuário.

CONTROLLERS são usados para enviar mensagens ao MODEL e prover uma interface entre este e os VIEWS associados a ele (p. ex., teclado, mouse etc.)
Cada VIEW deve ser pensado como sendo associado a um CONTROLLER cada qual com seu próprio MODEL. Mas este último, podendo ter muitos pares de VIEW/CONTROLLER.

Cada CONTROLLER está ligado a uma única instância de um VIEW e a uma única instância de um MODEL.
Coisas que o CONTROLLER NÃO É:

  • encarregado de instanciar o MODEL ou o VIEW — ele os enxerga, mas a flexibilidade é reduzida nas implementações que o forçam a selecionar qual VIEW ou MODEL está sendo usado;
  • uma passagem ou mediador entre o MODEL e o VIEW;
  • local onde os VIEWS são inicializados com base no estado de um MODEL. O CONTROLLER está ligado a uma única classe VIEW (embora possa ser atribuído a múltiplas instâncias) e responde a ações relacionadas.
    Uma lista de produtos constituiria uma única VIEW.

O fluxo do programa

O fluxo típico de um programa sob os padrões MVC, segue estes passos:

  • Inicialização do MODEL, do VIEW e do CONTROLLER.
  • O VIEW obtém dados do MODEL e é exibido ao usuário.
  • O usuário interage com o VIEW (clicando em algo, por exemplo), o que dispara uma ação do CONTROLLER.
  • O CONTROLLER atualiza o MODEL, de alguma forma.
  • O VIEW é renovado para exibir os dados atualizados do MODEL.

Hello World!

Já vimos um bom tanto de teoria.
Faz sentido ver como tudo isto se aplica à “vida real”, em uma pequena aplicação PHP.
Me acompanhe!

class Model {
     public $text;
     public function __construct() {
         $this->text = 'Hello world!';
     }        
} 

class View 
     private $model;
     private $controller;

     public function __construct(Controller $controller, Model $model) {
         $this->controller = $controller;
         $this->model = $model;
     }

     public function output() {
         return '<h1>' . $this->model->text .'</h1>';
     }
}
class Controller {
     private $model;

     public function __construct(Model $model) {
         $this->model = $model;
     }
}
// aqui inicia a triade
$model = new Model();
// eh importante que o CONTROLLER e o VIEW compartilhem o MODEL
$controller = new Controller($model);
$view = new View($controller, $model);
echo $view->output();

Os aplicativos “hello world!” não costumam ter interação com o usuário — pelo menos, este aqui, não tem.
Portanto, como ele só exibe dados, o CONTROLLER não faz nada aqui.

Interação do usuário

Se você ficou frustrado pelo fato de o CONTROLLER não ter sido relevante no exemplo anterior, vamos usar outra abordagem que preveja este tipo de interação.
Interação com o usuário é o primeiro problema da arquitetura MVC, na web — não há como criar uma callback pro CONTROLLER diretamente.
Além disto, toda a página tem que ser recarregada — o que ainda não é um grande problema, mas precisamos adicionar código que direcione a ação de volta ao CONTROLLER certo.
No nosso próximo exemplo, vamos adicionar ao código anterior algumas linhas que fazem com que a string “Hello world” seja seja substituída por “Texto Atualizado”, quando clicada.
Primeiro adicione um link pro VIEW. Você pode fazer isto adicionando uma callback ao CONTROLLER a partir do VIEW.
Em aplicações GUI, o CONTROLLER poderia ser apenas outro objeto na memória e a callback poderia ser uma simples chamada de função.
Na web, isto não é uma opção — uma requisição HTTP é a única maneira de acessar o CONTROLLER.

class View {
     private $model;
     private $controller;
     public function __construct(Controller $controller, Model $model) {
         $this->controller = $controller;
         $this->model = $model;
     }
     public function output() {
         return '<a href="mvc.php?action=textclicked">' . $this->model->text . '</a>';
     }
}

Na segunda requisição (callback), todos os componentes precisam ser reinicializados. Algum código precisa ser adicionado para direcionar a ação de volta ao CONTROLLER. Veja como:

$model = new Model();
//Eh importante que o CONTROLLER e o VIEW compartilhem o MODEL
$controller = new Controller($model);
$view = new View($controller, $model);
if (isset($_GET['action'])) $controller->{$_GET['action']}();
echo $view->output(); 

Tudo o que este código faz é chamar a ação do CONTROLLER — especificada por $_GET['action'], baseado na interação do usuário.
Enfim, uma ação do CONTROLLER, que lide com o evento, precisa ser adicionada ao código:

class Controller {
     private $model;
     public function __construct(Model $model) {
         $this->model = $model;
     }
     public function textClicked() {
         $this->model->text = 'Texto Atualizado';
     } 
}

Agora, quando a página for visitada, ela vai dizer “Hello World” e, quando o link for clicado, o texto muda para “Texto Atualizado”.
Pegue o código completo abaixo:

<?php
class Model {
	public $text;
	
	public function __construct() {
		$this->text = 'Hello world!';
	}		
}

class View {
	private $model;
	private $controller;
	
	public function __construct(Controller $controller, Model $model) {
		$this->controller = $controller;
		$this->model = $model;
	}
	
	public function output() {
		return '<a href="mvc.php?action=textclicked">' . $this->model->text . '</a>';
	}
	
}

class Controller {
	private $model;

	public function __construct(Model $model) {
		$this->model = $model;
	}

	public function textClicked() {
		$this->model->text = 'Texto Atualizado';
	}
}


$model = new Model();
//It is important that the controller and the view share the model
$controller = new Controller($model);
$view = new View($controller, $model);
if (isset($_GET['action'])) $controller->{$_GET['action']}();
echo $view->output();
?>

Leia mais sobre o assunto

Outros textos sobre a arquitetura MVC, neste site.
Outros textos sobre programação PHP, neste site.

http://www.siliconinfo.com/open-source-web-application/mvc-development.html

https://coderwall.com/p/l-a79g
https://r.je/mvc-in-php.html
Wikipedia
Leia mais sobre as definições usadas neste texto:
http://pt.wikipedia.org/wiki/Callback

Os princípios do MVC para desenvolvedores PHP

Os conceitos por trás do MVC, remontam à década de 60 e influenciaram linguagens de programação orientadas a objetos, como o Smalltalk-80 e incontáveis projetos, como o Apple Macintosh.
Sigla para Model-View-Controller ou Modelo-Visão-Controlador, o MVC pode ser definido como uma arquitetura de software ou padrão de projetos (design patterns).
diagrama da arquitetura MVC
Se isto fizer alguém se sentir mais seguro e confiante, não estamos falando de conceitos que “surgiram ontem” aqui.
Quando me pediram para escrever sobre o MVC (Model-View-Controller), tal como Marc Plotz, tive a percepção de que há muito pouco escrito sobre o assunto, que se possa chamar de relevante (eu sei, isto é apenas uma opinião) — alguns termos carecem de uma definição mais aprofundada.
Mas, quem deseja se aprofundar mais sobre um determinado assunto, deve procurá-lo em livros, enquanto meios mais adequados e confortáveis para se explorar conceitos.
Neste artigo, vou procurar expor o que sei sobre MVC, da maneira mais simples possível e sob a ótica de um programador PHP – onde reside boa parte da minha experiência enquanto desenvolvedor.

Vantagens do MVC

Para ser objetivo:

  • robusto;
  • escalável;
  • enxuto e muito bem escrito.

Quando eu era adolescente, meu pai, doutor em matemática, me deu alguns conselhos sobre como programar melhor. Um deles dizia “seu código não deve ultrapassar o tamanho de uma tela”.
Pode parecer bobagem, mas seguindo este princípio, nos anos 90, antes de ter qualquer formação acadêmica, eu já aplicava alguns dos conceitos da boa programação de que vamos falar aqui.
Ao seguir este princípio, sou obrigado a pensar o meu código para ser enxuto e livre de redundâncias.

O que é o MVC

A arquitetura de software MODEL – VIEW – CONTROLLER, usada na engenharia de softwares tem como princípio fundamental a idéia de que a lógica de uma aplicação deve estar separada de sua apresentação — ou seja, o MVC é uma maneira melhor de separar a lógica de construção da sua aplicação do modo como ela é vista.
Sua fundamentação é separar a aplicação em 3 partes principais, conhecidas como o Modelo, a Visão e o Controlador.
Observe o diagrama:

  • As linhas contínuas representam as associações diretas
  • As linhas tracejadas representam as associações inferidas

Estas últimas, são associações visíveis pelo ponto de vista do usuário, mas que não representam necessariamente a realidade do projeto de software.

Design patterns - MVC - padrões de projeto de software
Clique, para ampliar.

Uma das formas de pensar o MVC é considerar as seguintes situações:

  • Um usuário interage com o view, clicando em um link ou enviando dados em um formulário.
  • O Controller manipula os dados fornecidos pelo usuário e os transfere ao Model.
  • O Model recebe a informação e atualiza seu estado — o que significa realizar um cálculo envolvendo os dados fornecidos, adicioná-los a um banco de dados, pra citar alguns exemplos.
  • O View verifica o estado do Model e responde — listando os dados, fornecendo o resultado de um cálculo etc.
  • O View aguarda uma nova interação vinda do usuário.

Em termos práticos, o MVC representa uma boa filosofia de projetos.
A ideia de separar a ĺógica do display não é nova — mas o MVC consegue apresentá-la de uma forma mais amigável.
A apresentação e o layout são mais simples — e, como consequência, seu aplicativo pode ter uma manutenção mais fácil.
O View fica entre os arquivos de view, a lógica dentro do modelo (template) e o Controller manipula tudo.

A lógica de negócios

O termo, em inglês, é Business Logic.
O conceito é simples: lógica de negócios é o processo de calcular os processos lógicos de uma aplicação.
Exemplo: no caso de um calendário, a lógica de negócios consistiria em calcular a data atual, em que dia da semana estamos, quantos dias já se passaram desde o início do ano ou do mês etc.
Não se deixe confundir por termos bonitinhos — em uma aplicação a lógica de negócios se refere ao processamento das informações — simplesmente.

São rotinas que realizam entradas de dados, consultas aos dados, geração de relatórios e mais especificamente todo o processamento que se realiza por trás da aplicação visível para o utilizador (Backoffice). (Wikipedia)

Modelos

O termo, em inglês (para facilitar sua busca, caso deseje pesquisar mais sobre o assunto) é templates.
É comum frameworks MVC usarem algum tipo de sistema de modelos, para enfatizar o princípio DRY (veja abaixo), tornando mais fácil reusar código já pronto.
Há frameworks que rodam sobre o Smarty ou seus próprios mecanismos de modelos – ou nenhum.
Especialistas avisam que alguns mecanismos de modelos (template engines) possuem sintaxe um tanto complicada — o trabalho de aprendizagem pode não valer a pena. Se informe antes de começar a aprender uma nova linguagem, que pode servir apenas para renderizar páginas.

DRY

A palavra dry, em inglês, que dizer “seco” ou “enxuto” — isto pode ajudar a memorizar.
No contexto de que estamos tratando, tem outro significado: Don’t Repeat Yourself — ou seja, não se repita ou não seja redundante.
A ideia é que você escreva código uma vez apenas e o reuse sempre que for necessário.

Na engenharia de software, o princípio DRY (não seja redundante) é usado para evitar repetição de informações e de trabalho.
“Cada peça de conhecimento deve ter uma única e não ambígua representação autoritativa dentro do sistema”. (Dave Thomas, 2003).
O princípio foi formulado pelos autores do livro “The pragmatic programmer“, Andy Hunt e Dave Thomas.
Sua aplicação inclui esquemas de bancos de dados, planos de testes, documentação etc.

A correta implementação deste princípio, implica que alterar um elemento dentro do sistema, não afeta outros elementos não-relacionados.

Programação por convenção

Este é um paradigma de projeto de software, que busca reduzir o número de decisões que os desenvolvedores precisam tomar — tornando o processo mais simples mas, nem por isso, menos flexível.
Assim, o programador só precisa especificar aspectos não convencionais da aplicação.
Por exemplo: havendo uma classe Vendas, dentro do modelo, a tabela correspondente, dentro do banco de dados, vai se chamar também “vendas”, por padrão.
Código “extra” relacionado a estes nomes, só vai precisar ser escrito, se alguém usar um nome diferente pra tabela.
Se pensar bem, é muito simples.
Leve em consideração um formulário:

  • ele tem elementos que sempre são requeridos;
  • estes elementos têm estados que, comumente, são os mesmos;
  • Um formulário, em meio ao código HTML, tem uma tag <form> que especifica uma ação a ser tomada, um método, um nome, uma id etc.
    Se você não precisa alterar nada, é mais fácil obter logo o nome do form, seu id, ação etc. direto da url.

Aplicar esta ideia a todos os elementos torna a construção deste tipo de aplicação muito fácil, rápida e simplificada.

Conclusão

O assunto não se esgota neste artigo — e pretendo retomá-lo em outros posts.
Tal como foi dito, até aqui, o MVC é uma maneira de começar a produzir de maneira limpa, escalável e robusta — e escrever código rápido, no menor espaço de tempo possível, com o mínimo de esforço.
Alguns frameworks MVC possuem apenas um ou dois destes recursos. O conselho é experimentar até encontrar um que te sirva.
Como sempre, sinta-se à vontade para comentar e compartilhar sua experiência comigo e com os outros leitores.

Leia mais

http://c2.com/cgi/wiki?BusinessLogicDefinition
http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software

Como configurar teclas de atalho no Ubuntu

As teclas de atalhos, ou hot keys, são a forma mais rápida de iniciar a execução de programas, scripts etc.
O usuário pode disparar um conjunto complexo de tarefas (contidas em um script), com o pressionamento de uma ou duas teclas pré-programadas.
Vou ensinar, neste post, como associar um programa ou script a uma combinação de teclas.

Configurar teclas de atalho no Ubuntu

Os atalhos de teclado no Ubuntu são configuradas em um painel apropriado. Pra chegar lá, siga o caminho abaixo:

  • Abra o Dash, com a tecla Super
  • Encontre o item de “configuração de Teclado
  • Dentro do painel de configuração de teclado, selecione a aba Atalhos de aplicativos

Atalhos de teclado no Ubuntu
Clique para ampliar

A partir deste painel, é possível editar cada item ou adicionar novos.

MAIS DETALHES

Se você tiver dificuldades em configurar as teclas de atalho, sugiro ler
este artigo
, onde o processo é um pouco mais detalhado.

Ao selecionar um item, é possível alterá-lo com um duplo clique do mouse ou pressionando o botão Editar, no painel.

Configuração das teclas de atalho no Xubuntu

Os dois sistemas, embora usem ambientes gráficos diferentes, têm processos quase idênticos.
Para chegar ao painel, no Xubuntu, siga o procedimento abaixo:

  • Pressione a combinação de teclas Super + R
  • Em seguida, digite configuração, na caixa de pesquisa
  • Selecione o Gerenciador de configurações
  • Dentro do gerenciador, selecione o painel de configuração de Teclado

Painel de configuração de atalhos de teclado no Xubuntu
Clique para ampliar

Ao selecionar a aba Atalhos de aplicativos, dentro do painel, você terá acesso à lista de hot keys pré-configuradas do sistema — e tudo pode ser alterado.

Como criar um novo atalho de teclado

Dentro do painel de atalhos de teclado, há uma lista de comandos e hot keys já associadas um ao outro.
Para incluir um novo atalho:

  • Clique em Adicionar
  • Em seguida, informe o nome do aplicativo ou a sua localização — você clicar no botão de busca (com um ícone de uma pasta), para encontrar e informar o local exato do aplicativo ou script.
    Clique Ok, quando estiver pronto.
    Comando associado a uma tecla de atalho no subuntu
    Clique, para ampliar.
  • Em seguida pressione as teclas que você deseja que fiquem programadas para executar aquele script ou aplicativo, quando acionadas
    teclas de atalho no xubuntu xfce
    Clique para ampliar.

Agora, feche o painel e experimente o seu novo atalho de teclado.
Se você pretende criar muitos atalhos de teclado, pode ser interessante anotar ou imprimir para ter uma referência, até memorizar tudo.

Sysstat: exemplos práticos de uso do comando sar

O SAR é um programa de monitoramento da performance do sistema Linux.
Neste post, vamos mostrar como o aplicativo funciona, através de exemplos práticos, que podem ser usados no dia a dia do sysadmin, para obter dados sobre processamento, E/S, desempenho do armazenamento na memória etc.
Uma vez instalado, é simples fazer o monitoramento da performance do Linux e levantar estatísticas de uso do sistema, com o uso de alguns comandos no terminal.
monitoramento linux sar sysstat
O sar faz parte do pacote de aplicativos de monitoramento SYSSTAT, desenvolvidos em C, pelo programador francês Sebastien Godard.
O fato de ser desenvolvido em linguagem C, implica em um programa leve, rápido e que interfere muito pouco nas atividades do sistema, durante sua execução.

Uso básico do sar

O sar pode ser executado direto na linha de comando, por qualquer usuário, sem privilégios especiais. Veja:

sar -V

este comando serve para mostrar a versão do sar, em execução:

sysstat versão 10.2.0
(C) Sebastien Godard (sysstat <at> orange.fr)

Uma vez que você tenha o sar instalado e funcionando, pode executar mais alguns comandos com ele.
O exemplo, abaixo, mostra as estatísticas referentes ao uso da CPU do seu computador, com 1 segundo de intervalo, 5 vezes:

sar 1 5

Este foi o resultado no meu computador:

Linux 3.13.0-32-generic (VoYag3r) 	29-07-2014 	_i686_	(2 CPU)

17:04:49        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:04:50        all     23,62      0,00      1,51      0,00      0,00     74,87
17:04:51        all     43,72      0,00      2,01      0,00      0,00     54,27
17:04:52        all     28,50      0,00      2,50      0,00      0,00     69,00
17:04:53        all     33,00      0,00      2,00      0,00      0,00     65,00
17:04:54        all     30,77      0,00      1,03      0,00      0,00     68,21
Média:         all     31,92      0,00      1,81      0,00      0,00     66,26

Alguns exemplos práticos de uso do sar, na linha de comando

Há 2 maneiras básicas de invocar o sar, na linha de comando:

  • acompanhado por uma opção (sem especificar um arquivo de dados saXX).
    Isto fará o aplicativo procurar pelos dados contidos no arquivo saXX do dia atual e exibir os dados gravados até aquele momento.
  • acompanhado de uma opção e especificando o arquivo saXX, através do parâmetro -f.
    Isto o fará exibir os dados referentes à performance obtida até a data especificada no arquivo.

Nota: o XX, usado acima, se refere ao dia do mês.
Nos exemplos que seguem, vou explicar como obter dados da performance do sistema no dia de hoje.
Se quiser se referir a uma data especial, basta adicionar o parâmetro -f /var/log/sysstat/saXX ao final da linha de comando do sar.
Toda vez em que você executar o comando sar, ele irá mostrar, na primeira linha, um texto semelhante a este:

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

Esta linha de texto mostra:

  • A versão do kernel Linux do sistema: 3.13.0-32-generic.
  • O hostname a que os dados se referem: VoYag3r.
  • A data a que se referem os dados 01-08-2014.
  • A arquitetura do sistema: _i686_.
  • O número de CPUs disponíveis no sistema: 2 CPU.

Em tempo, o comando sar -u, serve para mostrar o uso cumulativo, em tempo real, de todas as unidades de processamento do sistema.
Se você usar o parâmetro ALL, vai ver mais informações. Experimente:

sar -u ALL

Você pode usar as opções -P ALL para ver estatísticas de uso de todos os núcleos das CPUs separados:

sar -P ALL 1 2

O resultado, abaixo, mostra as estatísticas dos núcleos (0 e 1) da CPU, com 1 segundo de intervalo, 2 vezes:

Linux 3.13.0-32-generic (VoYag3r) 01-08-2014 _i686_ (2 CPU)

17:00:03        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:00:04        all     58,88      0,00      1,02      0,00      0,00     40,10
17:00:04          0     17,17      0,00      3,03      0,00      0,00     79,80
17:00:04          1    100,00      0,00      0,00      0,00      0,00      0,00

17:00:04        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:00:05        all     54,00      0,00      1,00      0,00      0,00     45,00
17:00:05          0      8,16      0,00      1,02      0,00      0,00     90,82
17:00:05          1    100,00      0,00      0,00      0,00      0,00      0,00

Média:         CPU     %user     %nice   %system   %iowait    %steal     %idle
Média:         all     56,42      0,00      1,01      0,00      0,00     42,57
Média:           0     12,69      0,00      2,03      0,00      0,00     85,28
Média:           1    100,00      0,00      0,00      0,00      0,00      0,00

Como obter estatísticas individuais de um dos núcleos (cores)

Se você tem um processador, com vários núcleos, pode obter valores individuais do uso de cada um, com o parâmetro -P.
Se eu quiser ver apenas os resultados do segundo núcleo, eu uso o parâmetro -P 1 (lembrando que a contagem dos núcleos começa em 0).
No exemplo, abaixo, o sar vai mostrar as estatísticas do segundo núcleo, com 1 seg. de intervalo, 5 vezes. Veja como fica:

sar -P 1 1 5
Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

17:07:19        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:07:20          1     15,84      0,00      3,96      0,00      0,00     80,20
17:07:21          1     43,00      0,00      5,00      0,00      0,00     52,00
17:07:22          1     19,39      0,00      2,04      0,00      0,00     78,57
17:07:23          1    100,00      0,00      0,00      0,00      0,00      0,00
17:07:24          1    100,00      0,00      0,00      0,00      0,00      0,00
Média:           1     55,71      0,00      2,20      0,00      0,00     42,08

Tutoriais Linux - Clique para ler mais.

Estatísticas de uso de memória

Vamos deixar os números das CPUs de lado por um momento.
No exemplo, que segue, vou mostrar como usar o sar para obter dados do uso da memória do sistema.
A coluna kbmemfree se refere à memória livre. kbmemused, se refere a memória em uso. Os valores estão em kilobytes.
O comando sar -r 1 3 mostra as estatísticas gerais de uso da memória, com 1 segundo de intervalo, 3 vezes:

sar -r 1 3

veja o resultado:

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

17:29:16    kbmemfree kbmemused  %memused kbbuffers  kbcached  kbcommit   %commit  kbactive   kbinact   kbdirty
17:29:17       304296   1747916     85,17     13572    710340   3142020     44,73    792276    870516       168
17:29:18       303924   1748288     85,19     13572    710340   3142020     44,73    791900    870516       168
17:29:19       303212   1749000     85,23     13572    710340   3142020     44,73    792796    870516       168
Média:        303811   1748401     85,20     13572    710340   3142020     44,73    792324    870516       168

Experimente outras variações do comando:

  • sar -r
  • sar -r 1 5
  • sar -r 1 3 -f /var/log/sysstat/sa30

Como acompanhar o uso da memória swap

O parâmetro -S pode ser usado para acompanhar o uso da memória swap no sistema.
Este comando pode ser usado para determinar se o seu sistema está fazendo uso do swapping ou não — se as colunas kbswpused e %swpused estiverem com valores zerados, então o sistema não está usando a memória swap.
O comando, abaixo, mostra as estatísticas de uso do swap, com intervalo de 1 segundo, 5 vezes:

sar -S 1 5

Como você pode ver, no meu sistema, está havendo uso do swapping:

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

17:54:43    kbswpfree kbswpused  %swpused  kbswpcad   %swpcad
17:54:44      4970576      2020      0,04         0      0,00
17:54:45      4970576      2020      0,04         0      0,00
17:54:46      4970576      2020      0,04         0      0,00
17:54:47      4970576      2020      0,04         0      0,00
17:54:48      4970576      2020      0,04         0      0,00
Média:       4970576      2020      0,04         0      0,00

E no seu?

Outras maneiras úteis de usar o sar

Você pode experimentar também estas outras variações de uso do sar:

  • sar -S
  • sar -S -f /var/log/sysstat/sa30 — vai buscar os dados do dia 30 (sa30).
  • sar -R — para identificar o número de páginas de memória liberadas, usadas e em cache a cada segundo, no sistema.
  • sar -H — para identificar as hugepages (em KB) em uso ou disponíveis.
  • sar -B — para gerar estatísticas (em KB) de dados paginados em relação ao disco por segundo.
  • sar -W — para gerar estatísticas de swap de páginas por segundo.

Como acompanhar o fluxo (Entrada/Saída) de dados

O comando, abaixo, mostra as estatísticas de fluxo de entrada e saída de dados (E/S), a cada 1 segundo e 3 vezes:

sar -b 1 3
Linux 3.13.0-32-generic (VoYag3r) 	04-08-2014 	_i686_	(2 CPU)

21:43:48          tps      rtps      wtps   bread/s   bwrtn/s
21:43:49         0,00      0,00      0,00      0,00      0,00
21:43:50         1,00      0,00      1,00      0,00    328,00
21:43:51         0,00      0,00      0,00      0,00      0,00
Média:          0,33      0,00      0,33      0,00    109,33

Significado dos campos

  • tpsTransactions per second ou transações por segundo (leitura e gravação incluídas).
  • rtpsRead transactions per second ou transações de leitura por segundo.
  • wtpsWrite transactions per second ou transações de escrita por segundo.
  • bread/sBytes read per second ou bytes lidos por segundo.
  • bwrtn/sBytes written per second ou bytes escritos por segundo.
sysstat comando sar Linux terminal
Clique para detalhes.

Monitorando atividades de dispositivos de E/S

O comando sar -d, para sermos objetivos aqui, pode ser usado para monitorar as atividades individuais de dispositivos de bloco e identificar atividades específicas de cada dispositivo.

Entenda o que são: Dispositivos de bloco ou block devices

Sistemas operacionais podem suportar um segundo tipo de dispositivo de disco conhecido como block device — dispositivos para os quais o kernel provê caching. (FreeBSD handbook).
É um arquivo que representa um dispositivo de hardware. Um arquivo especial de bloco, se distingue de outros por oferecer acesso ao dispositivo de hardware de forma a que suas características (a do hardware) não sejam visíveis ao sistema. (OpenGroup).

Veja um exemplo, na imagem abaixo:

monitoramento com sysstat - comando sar
Clique pra ampliar.

Para entender melhor a imagem acima, a coluna DEV é a que mostra os dispositivos.
Os nomes dos dispositivos podem vir acompanhados de uma numeração indicadora da quantidade possível de dispositivos conectáveis.
Tomemos o seguinte exemplo: dev20-1.
A numeração que sucede o nome do dispositivo quer dizer que ele aceita a conexão de 1 até 20 outros dispositivos: dev1, dev2, dev3... dev20.
Eu acho mais fácil entender esta listagem, com o uso do parâmetro -p -d. Assim:

sar -p -d 1 1
Linux 3.13.0-32-generic (VoYag3r) 	05-08-2014 	_i686_	(2 CPU)

19:23:44          DEV       tps  rd_sec/s  wr_sec/s  avgrq-sz  avgqu-sz     await     svctm     %util
19:23:45          sda      0,00      0,00      0,00      0,00      0,00      0,00      0,00      0,00

Média:           DEV       tps  rd_sec/s  wr_sec/s  avgrq-sz  avgqu-sz     await     svctm     %util
Média:           sda      0,00      0,00      0,00      0,00      0,00      0,00      0,00      0,00

Com o uso do parâmetro -p é possível ter nomes mais detalhados, como sda, sdb, sda1, sda2, sdc1, etc.
Experimente mais algumas variantes do comando:

  • sar -d -f /var/log/sysstat/sa>XX — substitua o XX pelo dia do mês, cujos dados você deseja ver.
  • sar -p -d 1 10

Determine os valores do context switching por segundo

O parâmetro -w vai exibir a quantidade total de processos criados por segundo, na primeira coluna, e o número de chaveamentos realizados por segundo (cswch/s), na outra coluna.
Veja como:

sar -w 1 3
Linux 3.13.0-32-generic (VoYag3r) 	06-08-2014 	_i686_	(2 CPU)

14:12:17       proc/s   cswch/s
14:12:18         0,00    492,00
14:12:19         0,00    650,00
14:12:20         0,00    619,00
Média:          0,00    587,00

Definição de context switch

O termo context switch ou process switching, em inglês, pode ser traduzido como “troca de contexto”, em uma tradução literal. Eu prefiro a palavra chaveamento. Leia mais na Wikipedia.
O context switching, ou chaveamento, pode ser descrito, mais especificamente, como uma das seguintes ações do kernel, em relação a processos e threads:

  • suspensão da progressão de um processo e armazenamento do estado da CPU — ou seja o contexto deste processo, em algum lugar da memória;
  • recuperação do contexto de outro processo armazenado na memória e sua reintegração nos registros da CPU e
  • retorno ao contador do programa (ou seja, à linha de código em que o processo anterior foi interrompido) para retomá-lo.

(The Linux Information Project).

Nas minhas palavras, chaveamento é quando o kernel suspende a execução de um processo ou thread na CPU e retoma a execução de qualquer outro processo, que já havia sido suspenso anteriormente — sendo que um processo é, por definição, a instância de um programa em execução.

Experimente outras variações do exemplo dado:

  • sar -w
  • sar -w 1 5
  • sar -w -f /var/log/sysstat/saXX

Tutoriais Linux - Clique para ler mais.

Como ver estatísticas de rede com o sar

O comando sar, em conjunto com o parâmetro -n, pode ser usado para obter informações sobre o desempenho de diversos aspectos do uso da rede no seu sistema — o que inclui o número de pacotes recebidos/transmitidos através da interface de rede, número de falhas etc.
Além do parâmetro -n, é necessário dizer o dispositivo de rede do qual se deseja recolher as informações.
Veja no quadro informativo abaixo:

  • DEV – Exibe estatísticas vitais para dispositivos de rede eth0, eth1, wlan0 etc.
  • EDEV – Exibe números das falhas referentes aos dispositivos de rede.
  • NFS – Mostra as atividades dos clientes do sistema de arquivos de rede (Network File System).
  • NFSD – Mostra as atividades dos servidores NFS.
  • SOCK – Lista os sockets do IPv4 em uso.
  • IP – Exibe o tráfego na rede IPv4.
  • EIP – Mostra os erros na rede IPv4.
  • ICMP – Mostra o tráfego na rede ICMPv4.
  • EICMP – Exibe erros na rede ICMPv4.
  • TCP – Exibe o tráfego na rede TCPv4.
  • ETCP – Exibe erros na rede TCPv4.
  • UDP – Mostra o tráfego de rede UDPv4.
  • as opções SOCK6, IP6, EIP6, ICMP6, UDP6 são equivalentes às anteriores, só que voltadas para redes IPv6.
  • ALL – Exibe todas as informações dos itens anteriores. A saída deste comando é bastante extensa.

Exemplo de uso:

sar -n IP 1 2
Linux 3.13.0-32-generic (VoYag3r) 	06-08-2014 	_i686_	(2 CPU)

17:51:58       irec/s  fwddgm/s    idel/s     orq/s   asmrq/s   asmok/s  fragok/s fragcrt/s
17:51:59         3,00      0,00      3,00      0,00      0,00      0,00      0,00      0,00
17:52:00         0,00      0,00      0,00      0,00      0,00      0,00      0,00      0,00
Média:          1,50      0,00      1,50      0,00      0,00      0,00      0,00      0,00

Relacione os dados obtidos pelo sar, usando start time

Ao analisar os dados do histórico, contido no arquivo /var/log/sysstat/saXX, com o uso da opção sar -f, é possível observar todos os dados exibidos a começar pelo horário de 12:00 a.m ou 00:00:00.
Você pode mudar a hora do início do relatório.
O parâmetro -s hh:mi:ss permite especificar um horário personalizado para o sistema usar como horário de início do relatório.
Veja como indicar o início do relatório de média de carga, para as 06 da manhã:

sar -q -f /var/log/sysstat/sa05 -s 06:00:00

Como não há meios (até a versão que eu estou usando) de estabelecer uma hora limite pro relatório, é necessário lançar mão de “outros artifícios”.
No exemplo abaixo, a saída do comando é filtrada pelo comando head:

sar -q -f /var/log/sysstat/sa05 -s 06:00:00 | head
Linux 3.13.0-32-generic (VoYag3r) 	05-08-2014 	_i686_	(2 CPU)

06:05:01      runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15   blocked
06:15:01            0       303      0,27      0,23      0,13         0
06:25:01            0       334      0,25      0,31      0,27         0
06:35:01            0       336      0,35      0,20      0,22         1
06:45:01            0       333      0,04      0,15      0,20         0
06:55:01            0       334      0,12      0,13      0,16         0
07:05:01            0       333      0,25      0,25      0,19         0
07:15:01            0       333      0,09      0,15      0,15         0

O comando head

A função do comando head é exibir a primeira parte de cada arquivo enviado para ele.
Como padrão, o comando exibe as primeiras 10 linhas do arquivo.

No exemplo, abaixo, usei o comando grep para filtrar as saídas que ocorrem aos 15 minutos de cada hora. Veja como ficou:

sar -q -f /var/log/sysstat/sa05 -s 06:00:00 | grep -i ":15:01"
06:15:01            0       303      0,27      0,23      0,13         0
07:15:01            0       333      0,09      0,15      0,15         0
08:15:01            0       338      0,04      0,11      0,14         0
09:15:01            2       336      0,25      0,16      0,15         0
10:15:01            0       337      0,16      0,19      0,16         0
11:15:01            0       337      0,09      0,17      0,24         0
12:15:01            0       343      0,52      0,54      0,79         0
13:15:01            0       334      0,06      0,07      0,12         0
14:15:01            3       351      0,94      0,77      0,63         0
15:15:01            0       349      0,40      0,50      0,50         0
16:15:01            0       345      0,42      0,39      0,42         0
17:15:01            5       390      3,79      2,93      2,08         0
18:15:01            0       356      0,21      0,32      0,94         0
19:15:01            0       359      0,46      0,65      0,71         0
20:15:01            0       364      0,75      0,49      0,61         0
21:15:01            1       362      0,74      0,45      0,47         0
22:15:01            2       362      0,28      0,39      0,48         0
23:15:01            4       362      0,43      0,46      0,54         0

Fila de execução e média de carga

No exemplo anterior, mostrei o uso da opção -q (mas não expliquei para que servia…) 😉
Esta opção informa o comprimento da fila e a média da carga, nos últimos intervalos de 1, 5 e 15 minutos.
Veja no quadro abaixo, os significados dos cabeçalhos de cada coluna.

significado do relatório

O parâmetro -q retorna valores, em 6 colunas:

  • runq-sz — comprimento da fila (número de tarefas esperando sua hora de execução).
  • plist-sz — Número de itens na lista de tarefas.
  • ldavg-1 — Média de carga (de trabalho) do sistema, no último minuto.
    A média da carga é computada a partir da quantidade média de tarefas que estejam ou que possam estar em execução (R state) e o número de tarefas em “dormência” ininterrupta (D state) dentro do intervalo especificado (1 minuto).
  • ldavg-5 — Média de carga do sistema nos últimos 5 minutos.
  • ldavg-15 — Média de carga do sistema nos últimos 15 minutos.
  • blocked — Número momentâneo de tarefas bloqueadas, esperando a conclusão do fluxo de E/S.

Veja um exemplo:

sar -q 1 5
Linux 3.13.0-32-generic (VoYag3r) 	07-08-2014 	_i686_	(2 CPU)

15:39:02      runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15   blocked
15:39:03            1       322      0,42      0,56      0,68         0
15:39:04            1       321      0,38      0,55      0,67         0
15:39:05            3       321      0,38      0,55      0,67         0
15:39:06            1       321      0,38      0,55      0,67         0
15:39:07            4       321      0,38      0,55      0,67         0
Média:             2       321      0,39      0,55      0,67         0

Conclusão

Há inúmeras outras formas de aplicação do sar, que irão surgir com o uso e as necessidades.
Combinar o programa com outros comandos Linux é uma forma de multiplicar suas possibilidades.

Leia outros artigos, sobre este assunto, para aumentar seus conhecimentos:

Como instalar o sysstat e o sar no seu sistema.
Blackmoreops: Exemplos de uso do sar. (english)
Crybit: Monitoramento de carga e memória com o SAR. (english)
O comando grep.

Comandos para ajustar o brilho da tela.

É possível controlar o brilho da tela através de alguns comandos do teclado. Isto pode ser útil quando as teclas de controle específicas não estão funcionando no seu notebook, por exemplo.
As teclas de controle padrão, em laptops, costumam ser acessíveis através do pressionamento conjunto de uma tecla de função.

Teclas especiais ajuste brilho notebook
Clique para ampliar.

No meu meu caso, para regular o brilho da tela do meu laptop, eu uso a combinação Fn + F11 (para reduzir o brilho) e Fn + F12 (para aumentar).
Se você tiver dúvidas, consulte o manual do seu notebook.
Neste post, vou mostrar 3 métodos para controlar brilho do seu monitor. Se você conhece ou prefere outras formas, contribua nos comentários.

Use o xbacklight para regular o brilho da tela

O programa xbacklight tem a função de ajustar o brilho da tela, através de uma extensão do (outro programa) RandR.
Em outros textos, já mostrei como usar o RandR para alterar a resolução e instalar mais monitores no seu sistema.
O uso básico do xbacklight é este:

  • Para aumentar o brilho em 10%: xbacklight --inc 10.
  • Para reduzir o brilho em 10%: xbacklight --dec 10.

O aplicativo xbacklight permite mais ajustes, inclusive regular a escala e a gradatividade — para evitar o incômodo causado pelas mudanças bruscas: Leia mais sobre o xbacklight e suas opções de uso, aqui.

Use o redshift

Recentemente, escrevi sobre o x.flux (ou f.lux) e sobre o redshift. — A principal função deles não é ajustar o brilho da tela, mas a temperatura das cores da sua tela.
Ambos são projetados para rodar em background e, automaticamente, fazer ajustes de acordo com a hora do dia.
Com isto, o f.lux e o redshift contribuem para o maior conforto do usuário que precisa usar o computador à noite — além disto, pode prevenir a dificuldade que muitas pessoas têm de pegar no sono, após horas exaustivas de trabalho no PC.
O redshift, especificamente, pode ser usado para regular o brilho também.
Ao indicar a latitude de sua localização, é possível informar também a intensidade da luz emitida pelo backlight do seu visor. Veja:

redshift -b DAY:NIGHT

No caso, troque as variáveis DAY e NIGHT pelos valores de brilho que você deseja obter de dia e à noite.
Os valores vão de 0.1 a 1.0.

» Leia mais sobre o redshift.

A solução, pelo redshift, pode ser a indicada para quem deseja algo definitivo, sem a necessidade de ficar arrumando as configurações do monitor, toda vez que for usar o computador — o redshift ajusta o seu monitor, assim que você der login.

Use o xfpm-power-backlight-helper

Esta solução é voltada para quem usa o XFCE, como ambiente desktop. Este é o caso do Xubuntu.
Apesar do nome grande, a solução não é complicada. Você pode copiar e colar os comandos em um terminal.

O xfpm-power-backlight-helper faz parte do pacote de aplicativos de gestão de energia do ambiente desktop XFCE. Por isto, você provavelmente não irá encontrá-lo no Ubuntu padrão, cujo desktop é comandado pelo Unity.

Para verificar o valor do brilho atual do seu monitor, use o comando assim:

xfpm-power-backlight-helper --get-brightness

Para verificar o valor máximo do brilho atual…

xfpm-power-backlight-helper --get-max-brightness

Para alterar o valor, contudo, você precisará ser root e precisa rodar o programa de dentro do pkexec. Veja como alterar o valor do brilho para 80:

pkexec --user root xfpm-power-backlight-helper --set-brightness 80

Se você pretende diminuir o brilho da tela, faça isto gradativamente, para não acabar com uma tela totalmente preta e sem saber o que está acontecendo.

Leia mais sobre “brilho da tela do monitor” na sessão de busca do site.