PHP e Design Pattern

Conectando com servidor remoto via SSH

2010-03-13T14:38:00.007-03:00

Um dos padrões de projeto mais legais é o State, com ele, um objeto pode mudar seu comportamento em tempo de execução dependendo do estado corrente e cada implementação de estado preocupa-se apenas com o que deve fazer, deixando assim um código limpo e totalmente reutilizável.

Cada ConcreteState implementa um comportamento específico permitindo, dessa forma, que novos comportamentos sejam anexados.

No caso de uma conexão SSH:

Nosso contexto inicia-se como SSHStateClosed, assim que executamos o método open() nosso estado passa a ser SSHStateEstabilished e podemos verificar a assinatura do host e autenticar; Assim que autenticado o estado passa à SSHStateListen para que possamos enviar comandos ao servidor remoto.

Como uma autenticação pode ser de várias formas, deixamos a implementação separada em um objeto específico, dessa forma, podemos autenticar com usuário e senha ou, se for o caso, utilizando certificados digitais (entre outras).

Um comando deveria ser implementado da mesma forma, porém, para simplificar as coisas, vamos trabalhar com strings mesmo:

com/ssh/auth/SSHAuthenticatePassword.php

<?php
/**
 * @author   João Batista Neto
 * @package  ssh
 * @category ssh, state, design pattern
 */
namespace com\ssh\auth;

/**
 * @see ISSHAuthentication
 */
use com\ssh\interfaces\ISSHAuthentication;

/**
 * Implementa uma autenticação utilizando nome de usuário e senha
 * @author   João Batista Neto
 * @final
 * @package  ssh
 * @category ssh, state, authentication, design pattern
 */
final class SSHAuthenticatePassword implements ISSHAuthentication {
        /**
         * @var string
         */
        private $user;
 
        /**
         * @var string
         */
        private $pswd;
 
        /**
         * Constroi o objeto de autenticação
         * @param string $user
         * @param string $pswd
         */
        public function __construct( $user , $pswd ){
                $this->user =& $user;
                $this->pswd =& $pswd;
        }
 
        /**
         * Efetua a autenticação
         * @param resource $resource
         * @throws InvalidArgumentException se o recurso não for válido
         */
        public function authenticate( &$resource ){
                if ( is_resource( $resource ) ){
                        return \ssh2_auth_password( $resource , $this->user , $this->pswd );
                } else {
                        throw new \InvalidArgumentException( 'Recurso inválido.' );
                }
 
                return false;
        }
 
        /**
         * Recupera o nome do usuário
         * @return string
         */
        public function getUser(){
                return $this->user;
        }
}

com/ssh/interfaces/AbstractSSHState.php

<?php
/**
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
namespace com\ssh\interfaces;

/**
 * Interface para um estado de conexão
 * @abstract
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   sh, state, design pattern
 */
abstract class AbstractSSHState implements ISSHState {
        /**
         * @var resource
         */
        protected $resource;
 
        /**
         * Autentica o usuário
         * @param ISSHAuthentication $auth
         * @param ISSHConnection $context
         * @return boolean
         * @throws BadMethodCallException se o estado não implementar o método authenticate
         */
        public function authenticate( ISSHAuthentication $auth , ISSHConnection $context ){
                throw new \BadMethodCallException( sprintf( '%s não implementa o método %s' , get_class( $this ) , __METHOD__ ) );
        }
 
        /**
         * Executa um comando no servidor remoto
         * @param string $command
         * @param ISSHConnection $context
         * @return boolean
         * @throws BadMethodCallException se o estado não implementar o método execute
         */
        public function execute( $command , ISSHConnection $context ){
                throw new \BadMethodCallException( sprintf( '%s não implementa o método %s' , get_class( $this ) , __METHOD__ ) );
        }
 
        /**
         * Recupera a fingerprint do servidor
         * @param ISSHConnection $context
         * @return string
         * @throws BadMethodCallException se o estado não implementar o método execute
         */
        public function getFingerprint( ISSHConnection $context ){
                throw new \BadMethodCallException( sprintf( '%s não implementa o método %s' , get_class( $this ) , __METHOD__ ) );
        }
 
        /**
         * Abre uma nova conexão
         * @param string $host
         * @param integer $port
         * @param ISSHConnection $context
         * @return boolean
         * @throws BadMethodCallException se o estado não implementar o método open
         */
        public function open( $host , $port = 22 , ISSHConnection $context ){
                throw new \BadMethodCallException( sprintf( '%s não implementa o método %s' , get_class( $this ) , __METHOD__ ) );
        }
 
        /**
         * Define o recurso da conexão
         * @param resource $resource
         * @throws InvalidArgumentException se o recurso não for válido
         */
        public function setResource( &$resource ){
                if ( !is_resource( $resource ) ){
                        throw new \InvalidArgumentException( 'Recurso inválido.' );
                } else {
                        $this->resource =& $resource;
                }
        }
}

com/ssh/interfaces/ISSHAuthentication.php

<?php
/**
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
namespace com\ssh\interfaces;

/**
 * Interface para autenticação SSH
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
interface ISSHAuthentication {
        /**
         * Efetua a autenticação do usuário
         * @param resource $resource
         */
        public function authenticate( &$resource );
 
        /**
         * Recupera o nome do usuário
         * @return string
         */
        public function getUser();
}

com/ssh/interfaces/ISSHConnection.php

<?php
/**
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
namespace com\ssh\interfaces;

/**
 * Interface para uma conexão SSH
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
interface ISSHConnection {
        /**
         * Autentica um usuário
         * @param ISSHAuthentication $auth
         * @return boolean
         */
        public function authenticate( ISSHAuthentication $auth );
 
        /**
         * Executa um comando no servidor remoto
         * @param string $command
         * @return boolean
         */
        public function execute( $command );
 
        /**
         * Recupera a fingerprint do servidor
         * @return string
         */
        public function getFingerprint();
 
        /**
         * Abre uma nova conexão
         * @param stirng $host
         * @param integer $port
         * @return boolean
         */
        public function open( $host , $port );
 
        /**
         * Modifica o estado da conexão
         * @param ISSHState $state
         */
        public function changeState( ISSHState $state );
}

com/ssh/interfaces/ISSHState.php

<?php
/**
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
namespace com\ssh\interfaces;

/**
 * Interface para um estado de conexão
 * @author     João Batista Neto
 * @package    ssh
 * @subpackage interfaces
 * @category   ssh, state, design pattern
 */
interface ISSHState {
        /**
         * Autentica o usuário
         * @param ISSHAuthentication $auth
         * @param ISSHConnection $context
         */
        public function authenticate( ISSHAuthentication $auth , ISSHConnection $context );
 
        /**
         * Executa um comando no servidor remoto
         * @param string $command
         * @param ISSHConnection $context
         */
        public function execute( $command , ISSHConnection $context );
 
        /**
         * Recupera a fingerprint do servidor
         * @param ISSHConnection $context
         * @return string
         */
        public function getFingerprint( ISSHConnection $context );
 
        /**
         * Abre uma nova conexão
         * @param string $host
         * @param integer $port
         * @param ISSHConnection $context
         */
        public function open( $host , $port = 22 , ISSHConnection $context );
 
        /**
         * Define o recurso da conexão
         * @param resource $resource
         */
        public function setResource( &$resource );
}

com/ssh/state/SSHStateClosed.php

<?php
/**
 * @author   João Batista Neto
 * @package  ssh
 * @category ssh, state, design pattern
 */
namespace com\ssh\state;

/**
 * @see AbstractSSHState
 */
use com\ssh\interfaces\AbstractSSHState;

/**
 * @see ISSHConnection
 */
use com\ssh\interfaces\ISSHConnection;

/**
 * Implementa o estado para uma conexão fechada
 * @author   João Batista Neto
 * @final
 * @package  ssh
 * @category ssh, state, design pattern
 */
final class SSHStateClosed extends AbstractSSHState {
        /**
         * @staticvar
         * @var ISSHConnection
         */
        static private $context;
 
        /**
         * Abre uma nova conexão
         * @param string $host
         * @param integer $port
         * @param ISSHConnection $context
         * @return boolean
         * @throws RuntimeException se não for possível estabelecer a conexão
         * @uses SSHStateEstabilished
         */
        public function open( $host , $port = 22 , ISSHConnection $context ){
                $resource = \ssh2_connect( $host , $port , array(
                        'disconnect'    => array( 'SSHStateClosed' , 'disconnect' )
                ) );
 
                if ( !is_resource( $resource ) ){
                        throw new \RuntimeException( 'Não foi possível estabelecer a conexão.' );
                } else {
                        $estabilished = new SSHStateEstabilished();
                        $estabilished->setResource( $resource );
 
                        self::$context =& $context;
                        self::$context->changeState( $estabilished );
                }
 
                return true;
        }
 
        /**
         * Muda o estado da conexão para SSHStateClosed caso o servidor envie um disconnect
         * @static
         */
        static public function disconnect(){
                self::$context->changeState( new SSHStateClosed() );
        }
}

com/ssh/state/SSHStateEstabilished.php

<?php
/**
 * @author   João Batista Neto
 * @package  ssh
 * @category ssh, state, design pattern
 */
namespace com\ssh\state;

/**
 * @see AbstractSSHState
 */
use com\ssh\interfaces\AbstractSSHState;

/**
 * @see ISSHConnection
 */
use com\ssh\interfaces\ISSHConnection;

/**
 * @see ISSHAuthentication
 */
use com\ssh\interfaces\ISSHAuthentication;

/**
 * Implementa o estado para uma conexão estabelecida
 * @author   João Batista Neto
 * @final
 * @package  ssh
 * @category ssh, state, design pattern
 */
final class SSHStateEstabilished extends AbstractSSHState {
        /**
         * Efetua a autenticação do usuário
         * @param ISSHAuthentication $auth
         * @param ISSHConnection $context
         * @return boolean
         * @throws RuntimeException se não for possível autenticar o usuário
         * @uses SSHStateAuthenticated
         */
        public function authenticate( ISSHAuthentication $auth , ISSHConnection $context ){
                if ( !$auth->authenticate( $this->resource ) ){
                        throw new RuntimeException( sprintf( 'Não foi possível autenticar o usuário %s.' , $auth->getUser() ) );
                } else {
                        $authenticated = new SSHStateListen();
                        $authenticated->setResource( $this->resource );
                        $context->changeState( $authenticated );
                }
 
                return true;
        }
 
        /**
         * Recupera o hash da chave do servidor da conexão ativa
         * @return string
         * @throws LogicException se o estado não implementar o método execute
         */
        public function getFingerprint( ISSHConnection $context ){
                return \ssh2_fingerprint( $this->resource , \SSH2_FINGERPRINT_MD5 | \SSH2_FINGERPRINT_HEX );
        }
}

com/ssh/state/SSHStateListen.php

<?php
/**
 * @author              João Batista Neto
 * @package             ssh
 * @category    ssh, state, design pattern
 */
namespace com\ssh\state;

/**
 * @see AbstractSSHState
 */
use com\ssh\interfaces\AbstractSSHState;

/**
 * @see ISSHConnection
 */
use com\ssh\interfaces\ISSHConnection;

/**
 * Implementa o estado para uma conexão autenticada
 * @author   João Batista Neto
 * @final
 * @package  ssh
 * @category ssh, state, design pattern
 */
final class SSHStateListen extends AbstractSSHState {
        /**
         * @var resource
         */
        private $shell;
 
        /**
         * Executa um comando no servidor remoto
         * @param string $command
         * @param ISSHConnection $context
         * @return string A saída do servidor remoto
         * @throws RuntimeException se não for possível executar o comando
         */
        public function execute( $command , ISSHConnection $context ){
                $ret = null;
 
                $stream = \ssh2_exec( $this->resource , $command );
 
                if ( is_resource( $stream ) ){
                        \stream_set_blocking( $stream , true );
 
                        while ( ( $line = \fgets( $stream , 4096 ) ) !== false ){
                                $ret .= $line;
                        }
                } else {
                        throw new \RuntimeException( 'Não foi possível executar o comando.' );
                }
 
                return $ret;
        }
}

com/ssh/SSHConnection.php

<?php
/**
 * @author   João Batista Neto
 * @package  ssh
 * @category ssh, state, design pattern
 */
namespace com\ssh;

/**
 * @see ISSHConnection
 */
use com\ssh\interfaces\ISSHConnection;

/**
 * @see ISSHAuthentication
 */
use com\ssh\interfaces\ISSHAuthentication;

/**
 * @see ISSHState
 */
use com\ssh\interfaces\ISSHState;

/**
 * @see SSHStateClosed
 */
use com\ssh\state\SSHStateClosed;

/**
 * Implementa uma conexão com um servidor remoto via SSH
 * @author   João Batista Neto
 * @final
 * @package  ssh
 * @category ssh, state, design pattern
 */
class SSHConnection implements ISSHConnection {
        /**
         * @var ISSHState
         */
        private $state;
 
        /**
         * Cria o objeto de conexão
         */
        public function __construct(){
                $this->state = new SSHStateClosed();
        }
 
        /**
         * Faz a autenticação no servidor
         * @param ISSHAuthentication $auth
         * @return boolean
         */
        public function authenticate( ISSHAuthentication $auth ){
                return $this->state->authenticate( $auth , $this );
        }
 
        /**
         * Executa um comando no servidor
         * @param string $command
         * @return boolean
         */
        public function execute( $command ){
                return $this->state->execute( $command , $this );
        }
 
        /**
         * Recupera a fingerprint do servidor
         * @return string
         */
        public function getFingerprint(){
                return $this->state->getFingerprint( $this );
        }
 
        /**
         * Abre uma conexão com um servidor remoto
         * @param string $host
         * @param integer $port
         * @return boolean
         */
        public function open( $host , $port = 22 ){
                return $this->state->open( $host , $port , $this );
        }
 
        /**
         * Modifica o estado da conexão
         * @param ISSHState $state
         */
        public function changeState( ISSHState $state ){
                $this->state =& $state;
        }
}

Agora, para conectar em um servidor remoto via PHP é simples:

<?php
use com\ssh\SSHConnection;
use com\ssh\auth\SSHAuthenticatePassword;

$teste = new SSHConnection();
$teste->open( '127.0.0.1' );
$teste->authenticate( new SSHAuthenticatePassword( 'usuario' , 'senha' ) );

echo $teste->execute( 'ls -l /var/www/html/xxx/com/ssh' );

No meu caso, a saída foi:

total 16
drwxr-xr-x. 3 neto apache 4096 Mar 11 18:18 auth
drwxr-xr-x. 3 neto apache 4096 Mar 11 18:18 interfaces
-rw-r--r--. 1 neto apache 1681 Mar 11 18:17 SSHConnection.php
drwxr-xr-x. 3 neto apache 4096 Mar 12 06:35 state

Colaboração de elementos com Mediator

2010-02-27T10:45:00.002-03:00

É comum termos elementos na interface de usuário que colaboram entre si, ou que uma ação de um elemento causa uma reação em outro elemento. Para abstrair a complexabilidade dessa colaboração dos elementos em si, podemos utilizar um design pattern chamado Mediator.

O Mediator, como o nome sugere, irá mediar essa colaboração, encapsulando toda a complexabilidade do comportamento conjunto em um objeto mediator.

Um exemplo dessa colaboração é um sistema de auto-completar onde o usuário digita os termos em um campo de texto e um outro elemento vai recebendo as dicas, assim que o input tem seu estado modificado (evento onchange) ele avisa o seu mediator que fará o trabalho e repassará para o seu outro objeto que seria uma lista com as sugestões:

Utilizando Javascript para coordenar a interface de usuário, teríamos o seguinte:

index.html

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pt-br" lang="pt-br">
        <head>
                <title>Mediator</title>
 
                <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
                <link rel="stylesheet" href="public/css/style.css" type="text/css" />
        </head>
        <body onload="main();">
                <form id="fMediator" action="" method="post" onsubmit="return false; void(0);">
                        <fieldset>
                                <label for="iNome">
                                        <span>Nome: </span>
                                        <input type="text" id="iNome" name="iNome" />
                                </label>
                                <ul id="lTips"></ul>
                        </fieldset>
                </form>
                <script type="text/javascript" src="public/js/Ajax.js"></script>
                <script type="text/javascript" src="public/js/AbstractColleague.js"></script>
                <script type="text/javascript" src="public/js/InputColleague.js"></script>
                <script type="text/javascript" src="public/js/ListColleague.js"></script>
                <script type="text/javascript" src="public/js/Mediator.js"></script>
                <script type="text/javascript">
                        function main(){
                                var server = new Mediator( 'test.php' );
                                var input = new InputColleague( document.getElementById( 'iNome' ) );
                                var list = new ListColleague( document.getElementById( 'lTips' ) );
 
                                input.setMediator( server );
                                list.setMediator( server );
 
                                server.add( input );
                                server.add( list );
                        }
 
                        function muda( nome ){
                                document.getElementById( 'iNome' ).value = nome;
                                document.getElementById( 'lTips' ).innerHTML = '';
                        }
                </script>
        </body>
</html>

AbstractColleague.js

/**
 * Interface para implementação de um Colleague
 * @constructor
 */
function AbstractColleague(){}; 
/**
 * Template method para envio de uma mensagem para o mediator
 * @param String message A mensagem que será enviada para o mediator
 */
AbstractColleague.prototype.send = function( message ){
        this.mediator.send( message , this );
}; 
/**
 * Template method para definição do Mediator
 * @param Mediator mediator
 */
AbstractColleague.prototype.setMediator = function( mediator ){
        if ( mediator instanceof Mediator ){
                this.mediator = mediator;
        } else {
                throw 'Opz, precisamos de um Mediator';
        }
}; 
/**
 * Template method para recuperação do Mediator
 * @return Mediator
 */
AbstractColleague.prototype.getMediator = function(){
        return this.mediator;
}; 
/**
 * Recebe a notificação do mediator caso um Colleague tenha seu estado modificado.
 * Precisa ser implementado nos Colleagues
 * @param String message
 */
AbstractColleague.prototype.notify = function( message ){};

InputColleague.js

/**
 * Implementação de do input
 * @param input Objeto do input onde o usuário irá digitar
 * @constructor
 */
function InputColleague( input ){
        var obj = this;
        var $_ = {
                onfocus : function(){
                        this.onkeydown = function( evt ){
                                if ( evt.keyCode >= 60 ){
                                        if ( this.timer ) clearInterval( this.timer );
                                        this.timer = setInterval( function( temp ){
                                                clearInterval( temp.timer );
                                                obj.getMediator().send( input.value , obj );
                                        } , 10 , this );
                                }
                        }
                },
                onblur : function(){
                        delete this.onkeydown;
                }
        };
       
        input.onfocus = $_.onfocus;
        input.onblur = $_.onblur;
       
        this.input = input;
}; 
InputColleague.prototype = new AbstractColleague(); 
/**
 * Recebe a notificação do mediator que seu Colleague teve seu estado modificado
 * @param String message
 */
InputColleague.prototype.notify = function( message ){
        this.input.value = message;
};

ListColleague.js

/**
 * Implementação da listagem de sugestões
 * @param input Objeto do UL que receberá as LIs
 * @constructor
 */
function ListColleague( list ){
        this.list = list;
}; 
ListColleague.prototype = new AbstractColleague(); 
/**
 * Recebe a notificação do mediator que seu Colleague teve seu estado modificado
 * @param String message
 */
ListColleague.prototype.notify = function( message ){
        this.list.innerHTML = message;
};

Com todos os Colleagues definidos, vamos definir agora o Mediator para um auto completar:

Mediator.js

/**
 * Mediator
 * @param String url A URL que será usada para recuperar as sugestões do banco de dados
 * @construct
 */
function Mediator( url ){
        this.ajax = new Ajax();
        this.colleagues = new Array();
        this.url = url;
}; 
/**
 * Adiciona um Colleague que será mediado pelo Mediator
 * @param Colleague colleague
 */
Mediator.prototype.add = function( colleague ){
        if ( colleague instanceof AbstractColleague ){
                this.colleagues.push( colleague );
        } else {
                throw 'Opz, precisamos de um Colleague';
        }
}; 
/**
 * Usado pelos Colleagues para notificar uns aos outros sobre suas mudanças de estado
 * @param String message
 * @param Colleague colleague
 */
Mediator.prototype.send = function( message , colleague ){
        if ( colleague instanceof AbstractColleague ){
                var $this = this;
               
                message = [ 'message' , escape( message ) ].join( '=' );
               
                this.ajax.open( 'POST' , this.url , true );
                this.ajax.send( message );
                this.ajax.onreadystatechange = function(){
                        if ( this.readyState == 4 ){
                                for ( var obj in $this.colleagues ){
                                        if ( $this.colleagues[ obj ] !== colleague ){
                                                $this.colleagues[ obj ].notify( this.responseText );
                                        }
                                }
                        }
                }
               
        } else {
                throw 'Opz, precisamos de um Colleague';
        }
};

Para a parte do servidor usaremos um PHP bem simples que apenas receberá a requisição e retornará um conjunto de <li> que representará as sugestões:

test.php

<?php
$headers = getallheaders(); 
if ( isset( $headers[ 'X-Requested-With' ] ) && ( $headers[ 'X-Requested-With' ] == 'XMLHttpRequest' ) ){
        if ( ( $_SERVER[ 'REQUEST_METHOD' ] == 'POST' ) && isset( $_POST[ 'message' ] ) ){
                $message = sprintf( '%s%%' , $_POST[ 'message' ] );
                $pdo = new PDO( 'mysql:host=127.0.0.1;dbname=test' , 'usuario' , 'senha' );
                $stm = $pdo->prepare( 'SELECT `u`.`usuariosNome` FROM `Usuarios` AS `u` WHERE `u`.`usuariosNome` LIKE :nome;' );
                $stm->bindParam( ':nome' , $message );
 
                if ( $stm->execute() ){
                        $i = 0;
 
                        foreach ( $stm->fetchAll( PDO::FETCH_OBJ ) as $row ){
                                printf( '<li><a href="#" onclick="muda(\'%s\');">%s</a></li>' , $row->usuariosNome , $row->usuariosNome );
                        }
                } else {
                        header( sprintf( '%s 500 Internal Server Error' , $_SERVER[ 'SERVER_PROTOCOL' ] ) );
                        var_dump( $stm->errorInfo() );
                }
        } else {
                header( sprintf( '%s 400 Bad Request' , $_SERVER[ 'SERVER_PROTOCOL' ] ) );
        }
} else {
        header( sprintf( '%s 400 Bad Request' , $_SERVER[ 'SERVER_PROTOCOL' ] ) );
}

Para esse exemplo foi utilizado um banco de dados MySQL com uma tabela de usuários com a seguinte estrutura:

CREATE SCHEMA IF NOT EXISTS `test`;
 CREATE TABLE IF NOT EXISTS `test`.`Usuarios` (
 `idUsuarios` MEDIUMINT(8) UNSIGNED NOT NULL AUTO_INCREMENT,
 `usuariosNome` VARCHAR(45) NOT NULL,
 PRIMARY KEY(`idUsuarios`),
 INDEX `usuarios`(`usuariosNome` ASC)
) ENGINE = MyISAM DEFAULT CHARACTER SET = utf8 COLLATE = utf8_general_ci;

E os seguinte dados:

INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Joao');
INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Joao Batista');
INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Joao Batista Neto');
INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Joao Neto');
INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Jose');
INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Juliano');
INSERT INTO `test`.`Usuarios` (`idUsuarios`, `usuariosNome`) VALUES (NULL, 'Julio');

E para deixar a interface de usuário mais amigável a seguinte folha de estilos:

style.css

* {
        margin                  : 0;
        padding                 : 0;
        border                  : none;
        text-decoration : none;
}
 
body, html {
        margin                  : 10px;
        font-family             : Arial, Helvetica;
        font-size               : 14px;
}
 
form input#iNome {
        width                   : 160px;
        border                  : 1px solid #dadada;
        *margin                 : 0px 0px 0px 4px;
}
 
form label span {
        display                 : inline-block;
        width                   : 50px;
        text-align              : right;
}
 
ul#lTips {
        border                  : 1px solid #dadada;
        width                   : 160px;
        max-height              : 100px;
        overflow                : auto;
        margin                  : 0px 0px 0px 54px;
        *height                 : 0px;
}
 
ul#lTips li a {
        display                 : block;
        width                   : 100%;
        line-height             : 24px;
        height                  : 24px;
        color                   : #333333;
}
 
ul#lTips li a:hover {
        color                   : #FF0000;
}

Agora, sempre que o usuário digitar alguma coisa no input text o Mediator será avisado, enviará a requisição ao servidor e recuperará a lista de sugestões, essa lista é repassada ao outro Colleague responsável por montar a lista de sugestões.

;)

Gerando arquivos .INI com Composite Design Pattern e PHP

2010-02-26T20:11:00.007-03:00

Analisando um arquivo .ini é possível perceber que se trata de uma composição de comentários e seções onde cada seção possui um ou mais parâmetros e cada parâmetro é composto pelo par nome=valor.

Para criar esse tipo de arquivo é possível utilizar um padrão de projeto chamado composite:

Apesar de termos conhecimento de que o arquivo .ini é de fato uma composição, cada item dessa composição possui regras próprias e, para que não tenhamos que conhecer essas regras em um único objeto deixamos com que cada item da composição faça seu trabalho permitindo que tratemos todos os elementos de uma forma comum.

Para o nosso arquivo .ini os participantes são:

Comentários e valor de um parâmetro -> Leaf -> São elementos finais, que não possuem nós filhos.
Nome de um parâmetro, seção e o próprio arquivo.ini -> Composite -> Possuem um ou mais nós filhos.

Uma implementação simples em PHP ficaria assim:

INIFormat.php

<?php
 /**
 * Define a interface do Component
 */
interface INIFormat extends IteratorAggregate {
        /**
         * Adiciona um nó filho ao componente
         * @param INIFormat $leaf
         */
        public function add( INIFormat $leaf );
       
        /**
         * Grava o componente no arquivo
         * @param IFileObject $fo
         * @param string $eol Delimitador de fim de linha
         */
        public function write( IFileObject $fo , $eol = PHP_EOL );
}

AbstractINIComposite.php

<?php
 /**
 * Define a interface da composição
 * @abstract
 */
abstract class AbstractINIComposite implements INIFormat {
        private $leafs;

        /**
         * Inicializa o objeto da composição
         */
        public function __construct(){
                $this->leafs = new ArrayIterator();
        }

        /**
         * Adiciona um nó filho ao componente
         * @param INIFormat $leaf
         */
        public function add( INIFormat $leaf ){
                $this->leafs[] = $leaf;
        }

        /**
         * Recupera um Iterator com os nós filhos da composição
         * @return ArrayIterator
         */
        public function getIterator(){
                return $this->leafs;
        }
}

AbstractINILeaf.php

<?php
 /**
 * Define a interface para os nós que não possuem filhos
 * @abstract
 */
abstract class AbstractINILeaf implements INIFormat {
        /**
         * @param INIFormat $leaf
         * @throws LogicException Como uma folha não pode ter nós filhos, sempre dispara um LogicException
         */
        public function add( INIFormat $leaf ){
                throw new LogicException( 'Um nó final não pode ter nós filhos.' );
        }

        /**
         * Como uma folha não pode ter nós filhos, sempre retorna um Iterator vazio
         * @return ArrayIterator
         */
        public function getIterator(){
                static $iterator = null;

                if ( $iterator == null ) $iterator = new ArrayIterator();

                return $iterator;
        }
}

INIParameter.php

<?php
/**
 * Parâmetro de uma seção
 */
class INIParameter extends AbstractINIComposite {
        /**
         * @var string
         */
        private $name;

        /**
         * Constroi um novo parâmetro de seção
         * @param string $name O nome do parâmetro
         */
        public function __construct( $name ){
                parent::__construct();
                $this->name =& $name;
        }

        /**
         * Implementa o método write para gravar no arquivo
         * @param IFileObject $fo Objeto que será usado para gravar no arquivo
         * @param string $eol Delimitador de fim de linha
         */
        public function write( IFileObject $fo , $eol = PHP_EOL ){
                $iterator = $this->getIterator();
                $name = $this->name;

                if ( ( $total = $iterator->count() ) >= 1 ){
                        if ( $total > 1 ){
                                $name = sprintf( '%s[]' , $name );
                        }

                        foreach ( $iterator as $leaf ){
                                $fo->write( sprintf( '%s=' , $name ) );
                                $leaf->write( $fo , $eol );
                        }
                } else {
                        throw new LogicException( sprintf( 'O parâmetro %s precisa possuir pelo menos 1 valor.' , $this->name ) );
                }
        }
}

INIValue.php

<?php
/**
 * Valor de um parâmetro
 */
class INIValue extends AbstractINILeaf {
        private $value;

        /**
         * Constroi o valor de um parâmetro
         * @param string $value
         */
        public function __construct( $value ){
                $this->value =& $value;
        }

        /**
         * Grava o valor no arquivo
         * @param IFileObject $fo
         * @param string $eol
         */
        public function write( IFileObject $fo , $eol = PHP_EOL ){
                $fo->write( sprintf( '%s%s' , $this->value , $eol ) );
        }
}

INIComment.php

<?php
/**
 * Comentário de um arquivo ou seção
 */
class INIComment extends AbstractINILeaf {
        /**
         * @var string
         */
        private $comment;

        /**
         * Constroi o comentário
         * @param string $comment
         */
        public function __construct( $comment ){
                $this->comment =& $comment;
        }

        /**
         * Grava o comentário no arquivo
         * @param IFileObject $fo
         * @param string $eol
         */
        public function write( IFileObject $fo , $eol = PHP_EOL ){
                $fo->write( sprintf( '; %s%s' , $this->comment , $eol ) );
        }
}

INISection.php

<?php
/**
 * Seção de parâmetros
 */
class INISection extends AbstractINIComposite {
        /**
         * @var string
         */
        private $name;

        /**
         * Constroi a nova seção
         * @param string $name
         */
        public function __construct( $name ){
                parent::__construct();
                $this->name =& $name;
        }

        /**
         * Grava a seção no arquivo
         * @param IFileObject $fo
         * @param string $eol
         */
        public function write( IFileObject $fo , $eol = PHP_EOL ){
                $fo->write( sprintf( '[%s]%s' , $this->name , $eol ) );

                foreach ( $this as $leaf ){
                        $leaf->write( $fo , $eol );
                }
        }
}

INIFile.php

<?php
/**
 * Arquivo INI
 */
class INIFile extends AbstractINIComposite {
        /**
         * @var string
         */
        private $file;

        /**
         * Constroi o novo arquivo
         * @param string $file
         */
        public function __construct( $file ){
                parent::__construct();
                $this->file =& $file;
        }

        /**
         * Grava o arquivo em disco
         * @param IFileObject $fo
         * @param string $eol
         */
        public function write( IFileObject $fo , $eol = PHP_EOL ){
                $fo->open( $this->file , 'w+' );

                foreach ( $this as $leaf ){
                        $leaf->write( $fo , $eol );
                }

                $fo->close();
        }
}

Para demonstrar o funcionamento, vamos usar um objeto para gravar em disco que na verdade irá apenas exibir o conteúdo do arquivo INI gerado:

IFileObject.php

<?php
interface IFileObject {
        public function close();
        public function open( $name , $method );
        public function write( $content );
}

FileObject.php

<?php
class FileObject implements IFileObject {
        public function close(){
                echo '--- Fechando o arquivo ---' , PHP_EOL;
        }

        public function open( $name , $method ){
                echo '--- Abrindo o arquivo: ' , $name , ' ---' , PHP_EOL;
        }

        public function write( $content ){
                echo $content;
        }
}

Usando isso tudo:

<?php
$ini = new INIFile( 'teste.ini' );
$ini->add( new INIComment( 'Abaixo uma nova seção' ) );

$imasters = new INISection( 'iMasters' );
$imasters->add( new INIComment( 'O parâmetro teste possui vários valores' ) );
$teste = new INIParameter( 'teste' );
$teste->add( new INIValue( 'valor 1' ) );
$teste->add( new INIValue( 'valor 2' ) );
$teste->add( new INIValue( 'valor 3' ) );
$imasters->add( $teste );

$imasters->add( new INIComment( 'O parâmetro outro possui só um valor' ) );
$outro = new INIParameter( 'outro' );
$outro->add( new INIValue( 'apenas um' ) );
$imasters->add( $outro );

$ini->add( $imasters );
$ini->write( new FileObject() );

A saída:

--- Abrindo o arquivo: teste.ini ---
; Abaixo uma nova seção[iMasters]
; O parâmetro teste possui vários valores
teste[]=valor 1
teste[]=valor 2
teste[]=valor 3
; O parâmetro outro possui só um valor
outro=apenas um
--- Fechando o arquivo ---

Agora é só implementar a classe FileObject para que ela faça o que tem que fazer (gravar em disco) que tudo estará funcionando.

;)

Secure Hash Algorithm

2009-08-09T19:23:00.009-03:00

Bom, aqui vai uma implementação do hash SHA-1, estou trabalhando na serie SHA-2 (atualmente SHA-256 e futuramente SHA-512).
O código abaixo é para quem gosta de saber o que acontece debaixo dos panos quando você usa uma função nativa ou quando a função nativa não está disponível no seu servidor...


/**
 * Implementação PHP do Secure Hash Algorithm segundo a Secure Hash Standard (SHS)
 * (FIPS PUB 180-3) de outubro de 2008.
 * Nessa primeira versão está sendo implementado apenas o hash SHA-1, a proxima versão já contará
 * com SHA-256 e futuramente SHA-384 e SHA-512.
 *
 * @version 0.1
 * @author João Batista Neto 
 * @since 2009-08-06
 * @license LGLC
 * @link http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf
 * @category Computer Security, Cryptography, Hash.
 */
abstract class SecureHash {
    /**
     * Identifica o hash SHA-1
     */
    const SHA_1        = "sha1";

    /**
     * Identifica o hash SHA-256
     */
    const SHA_256    = "sha256";

    /**
     * Implementação do algorítimo de via única SHA-1 (Secure Hash Algorithm 1) definido
     * pela especificação FIPS 180-3
     * Message Size: < 2**64
     * Block Size: 512 bits
     * Word Size: 32 bits
     * Message Digest Size: 160 bits
     * @link http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf
     * @param $message
     * @return string
     */
    static public function sha1( $message ){
        /**
         * Pre-processamento
         */
        $M = self::pre_process( $message );

        /**
         * Define os valores iniciais [5.3.1]
         */
        $H = array( 0x67452301 , 0xefcdab89 , 0x98badcfe , 0x10325476 , 0xc3d2e1f0 );

        /**
         * Calculando o Hash [6.1.2]
         */
        for ( $i = 0 , $N = count( $M ) ; $i < $N ; $i += 16 ){
            $W = array();

            /**
             * [6.1.2.1]
             */
            for ( $t = 0 ; $t < 80 ; $t++ ){
                $W[ $t ] = ( $t <= 15 ) ? $M[ $i + $t ] : self::ROTL( $W[ $t - 3 ] ^ $W[ $t - 8 ] ^ $W[ $t - 14 ] ^ $W[ $t - 16 ] , 1 );
            }

            /**
             *  [6.1.2.2]
             */
            $a = $H[ 0 ];
            $b = $H[ 1 ];
            $c = $H[ 2 ];
            $d = $H[ 3 ];
            $e = $H[ 4 ];

            /**
             * [6.1.2.3]
             */
            for ( $t = 0 ; $t < 80 ; $t++  ){
                $T = self::add( self::add( self::ROTL( $a , 5 ) , self::f( $t , $b , $c , $d ) ) , self::add( self::add( $e , $W[ $t ] ) , self::Kt( $t ) ) );
                $e = $d;
                $d = $c;
                $c = self::ROTL( $b , 30 );
                $b = $a;
                $a = $T;
            }

            /**
             * [6.1.2.4]
             */
            $H[ 0 ] = self::add( $H[ 0 ] , $a );
            $H[ 1 ] = self::add( $H[ 1 ] , $b );
            $H[ 2 ] = self::add( $H[ 2 ] , $c );
            $H[ 3 ] = self::add( $H[ 3 ] , $d );
            $H[ 4 ] = self::add( $H[ 4 ] , $e );
        }

        return ( sprintf( "%08x%08x%08x%08x%08x" , $H[ 0 ] , $H[ 1 ] , $H[ 2 ] , $H[ 3 ] , $H[ 4 ] ) );
    }

    /**
     * Pre-processamento [5]
     * @return array
     */
    static private function pre_process( $message ){
        $size = strlen( $message );
        $M = array();
        $N = ( ( $size + 8 ) >> 6 ) + 1;

        /**
         * [5.1.1]
         */
        $message .= "\x80";

        for ( $i = 0 ; $i < $N * 16 ; $i++  ) $M[ $i ] = 0;
        for ( $i = 0 ; $i < $size ; $i++  ) $M[ $i >> 2 ] |= ord( $message{ $i } ) << ( 24 - ( $i % 4 ) * 8 );

        $M[ $i >> 2 ] |= 0x80 << ( 24 - ( $i % 4 ) * 8 );
        $M[ $N * 16 - 1 ] = $size * 8;

        return( $M );
    }

    /**
     * Operação AND [3.2.2]
     * Z = (X + Y) mod 2^32
     * @param integer $x
     * @param integer $y
     * @return integer O novo valor
     */
    static private function add( $x , $y ){
        $lsw = ( $x & 0xffff ) + ( $y & 0xffff );
        $msw = ( $x >> 16 ) + ( $y >> 16 ) + ( $lsw >> 16 );

        return ( ( $msw << 16 ) | ( $lsw & 0xFFFF ) );
    }

    /**
     * Operação Right Shift [3.2.3]
     * @param $x
     * @param $n
     * @return integer
     */
    static private function SHR( $x , $n ){
        $z = hexdec( 80000000 );

        if ( $z & $x ){
            $x = ( $x >> 1 );
            $x &= ~$z;
            $x |= 0x40000000;
            $x = ( $x >> ( $n - 1 ) );
        } else {
            $x = ( $x >> $n );
        }

        return( $x );
    }

    /**
     * Operação Circular Right Shift [3.2.4]
     * @param integer $x
     * @param integer $n
     * @return integer
     */
    static private function ROTR( $x , $n ){
        return( ( self::SHR( $x , $n ) | ( $x << ( 32 - $n ) ) & 0xFFFFFFFF ) );
    }

    /**
     * Operação Circular Left Shift [3.2.5]
     * @param integer $num
     * @param integer $n
     * @return integer
     */
    static private function ROTL( $x , $n ){
        return ( ( $x << $n ) | self::SHR( $x , 32 - $n ) );
    }

    /**
     * Função f [4.1.1]
     * @param $t
     * @param $b
     * @param $c
     * @param $d
     * @return integer
     */
    static private function f( $t , $b , $c , $d ){
        if ( ( $t >=  0 ) && ( $t <= 19 ) ) return ( self::Ch( $b , $c , $d ) );
        if ( ( $t >= 20 ) && ( $t <= 39 ) ) return ( self::Parity( $b , $c , $d ) );
        if ( ( $t >= 40 ) && ( $t <= 59 ) ) return ( self::Maj( $b , $c , $d ) );
        if ( ( $t >= 60 ) && ( $t <= 79 ) ) return ( self::Parity( $b , $c , $d ) );
    }

    /**
     * Ch [4.1.1]
     * @param integer $x
     * @param integer $y
     * @param integer $z
     * @return integer
     */
    static private function Ch( $x , $y , $z ){
        return ( ( $x & $y ) ^ ( ~$x & $z ) );
    }

    /**
     * Parity [4.1.1]
     * @param integer $x
     * @param integer $y
     * @param integer $z
     * @return integer
     */
    static private function Parity( $x , $y , $z ){
        return ( $x ^ $y ^ $z );
    }

    /**
     * Maj [4.1.1]
     * @param integer $x
     * @param integer $y
     * @param integer $z
     * @return integer
     */
    static private function Maj( $x , $y , $z ){
        return ( ( $x & $y ) ^ ( $x & $z ) ^ ( $y & $z ) );
    }

    /**
     * Sigma{256} 0 [4.1.2]
     * @param integer $x
     * @return integer
     */
    static private function Sigma_0( $x ){
        return( ( self::ROTR( $x , 2 ) ^ self::ROTR( $x , 13 ) ^ self::ROTR( $x , 22 ) ) );
    }

    /**
     * Sigma{256} 1 [4.1.2]
     * @param integer $x
     * @return integer
     */
    static private function Sigma_1( $x ){
        return( ( self::ROTR( $x , 6 ) ^ self::ROTR( $x , 11 ) ^ self::ROTR( $x , 25 ) ) );
    }

    /**
     * sigma{256} 0 [4.1.2]
     * @param integer $x
     * @return integer
     */
    static private function sigma0( $x ){
        return( ( self::ROTR( $x , 7 ) ^ self::ROTR( $x , 18 ) ^ ( self::SHR( $x , 3 ) ) ) );
    }

    /**
     * sigma{256} 1 [4.1.2]
     * @param integer $x
     * @return integer
     */
    static private function sigma1( $x ){
        return( ( self::ROTR( $x , 17 ) ^ self::ROTR( $x , 19 ) ^ ( self::SHR( $x , 10 ) ) ) );
    }

    /**
     * Recupera o valor da constante Kt [4.2.1] e [4.2.2]
     * @param integer $t
     * @param string $type
     * @return integer
     */
    static private function Kt( $t , $type = self::SHA_1 ){
        /**
         * Kt [4.2.1]
         */
        $k_SHA1        = array( 0x5a827999 , 0x6ed9eba1 , 0x8f1bbcdc , 0xca62c1d6 );

        /**
         * Kt [4.2.2]
         */
        $k_SHA256    = array(
            0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
            0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
            0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
            0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
            0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
            0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
            0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
            0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
        );

        /**
         * Retorna a constante segundo o hash usado
         */
        switch ( $type ){
            case self::SHA_1 :
                if ( ( $t >=  0 ) && ( $t <= 19 ) ) return ( $k_SHA1[ 0 ] );
                if ( ( $t >= 20 ) && ( $t <= 39 ) ) return ( $k_SHA1[ 1 ] );
                if ( ( $t >= 40 ) && ( $t <= 59 ) ) return ( $k_SHA1[ 2 ] );
                if ( ( $t >= 60 ) && ( $t <= 79 ) ) return ( $k_SHA1[ 3 ] );

                throw new UnexpectedValueException( sprintf( "O valor %08x não era esperado." , $t ) );
            case self::SHA_256:
                return( $k_SHA256[ $t ] );
        }
    }
}

Para testar o código:


$str = file_get_contents( "SecureHash.php" );

printf( "usando a função nativa.: %s\n" , sha1( $str ) );
printf( "usando SecureHash::sha1: %s\n" , SecureHash::sha1( $str ) );

A saída será:


usando a função nativa.: 127a9585171b50b421660a69f5e2a5f4adf09cfa
usando SecureHash::sha1: 127a9585171b50b421660a69f5e2a5f4adf09cfa