Antes de empezar a usarlo es importante considerar que el modulo usa la el constructor crypt de PHP pero usando como hash CRYPT_BLOWFISH, esto no afecta si estas usando PHP 5.3, pero si tienes este inconveniente al final del post pondré como solucionarlo(o cambiarte de hosting a uno mas actualizado).

Vamos a ver como usarlo para hacer un login.

Requisitos:

• Kohana 3.2
• Kohana A1 module
• Kohana ORM
• Kohana Database

Como dicen los requisitos para usar A1 debemos de estar conectados a una base de datos, también debemos de tener un modulo que abstraiga dicha base de datos, para esto podemos usar Kohana ORM, Automodeler, Jelly, Sprig o entre otros, si estamos haciendo pruebas yo recomiendo usar Kohana ORM, y ya en base a sus requerimientos y necesidades usar el que mas les agrade.

Instalamos kohana de modo que quede en http://localhost/kohana1/ ,creamos una base de datos yo la llamare, “system” y le pondré como datos de conexión ultra-seguros user:root password:root, recuerden activar el modulo database y ORM.

Y posteriormente nos toca, agregar el siguiente código SQL a nuestra base de datos, obviamente lo pueden modificar a su gusto, aunque de momento dejémoslo así.

 CREATE TABLE IF NOT EXISTS `users` (
	  `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT,
	  `email` varchar(127) NOT NULL,
	  `username` varchar(32) NOT NULL DEFAULT '',
	  `password` char(80) NOT NULL,
          `token` char(80) NOT NULL DEFAULT '',
	  `logins` int(10) UNSIGNED NOT NULL DEFAULT '0',
	  `last_login` int(10) UNSIGNED,
	  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

Ahora procedemos a bajar el modulo A1, que esta aquí: https://github.com/Wouterrr/A1/

Y lo ponemos en nuestro carpeta modules nombrando a la carpeta A1 de modo que quedara asi “modules/A1″.Dentro de dicha “modules/A1″ hay una carpeta config y dentro de ella un archivo llamado a1.php, bien este archivo es el archivo de configuración del modulo Kohana A1, de igual forma que se hace con todos los módulos hay que copiar este archivo a “application/config/” para poder editarlo y que no afecte directamente al modulo.

El archivo se ve de la siguiente forma:

<?php

return array(

	'driver'     => 'ORM', // orm/jelly/mango/sprig
	'user_model' => 'user',
	'cost'       => 12,    // Bcrypt Cost - any number between 4 and 31 -> higher = stronger hash

	'cookie'     => array(
		'key'         => 'a1_{name}_autologin',
		'lifetime'    => 1209600, // two weeks
	),

	'columns'   => array(
		'username'    => 'username',
		'password'    => 'password',
		'token'       => 'token',
		//'last_login'=> 'last_login', // (optional)
		//'logins'    => 'logins'      // (optional)
	),

	'session'  => array(
		'type'        => 'native' // native or database
	)
);

Aquí pongo la descripción de cada elemento:

• driver: EL ORM que usara (ORM,jelly,mango,sprig[se pueden agregar mas pero hay que modificar el modulo o extenderlo])
• user_model: tabla(modelo) que se usara ‘user’
• cost: fuerza (tamaño de la clave) entre 4 y 31, lo ideal es 12, si ponen un numero muy grande tomar en cuenta que consumirá mas recursos.
• cookie: los datos de la cookie que generara a1, para hacer el login(nombre y duración)
• columns: aquí le estamos asignando a los items de A1, las columnas de la base de datos, es decir si en su base de datos el nombre de usuarios están en el campo nombre, tendrán que poner ‘username’ => ‘nombre’, modificando lo que esta en el array, los campos opcionales de momento no los usaremos, aunque cabe señalar que solo guardan información extra.
• session: Aquí es donde definimos el tipo de sesión, de momento y regularmente bastara con dejarlo como esta, si su aplicación correrá en varios servidores conviene ponerlo en modo database(aunque en este caso hay que hacer un par de cosas mas, espero postear pronto sobre esto)

.

No se les olvide activar le modulo en el bootstrap, el cual en la sección módulos debería verse así:

<?php
//more code
/**
 * Enable modules. Modules are referenced by a relative or absolute path.
 */
Kohana::modules(array(
	// 'auth'       => MODPATH.'auth',       // Basic authentication
	// 'cache'      => MODPATH.'cache',      // Caching with multiple backends
	// 'codebench'  => MODPATH.'codebench',  // Benchmarking tool
         'A1'         => MODPATH.'A1',           //A1 authentication
	 'database'   => MODPATH.'database',   // Database access
	// 'image'      => MODPATH.'image',      // Image manipulation
	 'orm'        => MODPATH.'orm',        // Object Relationship Mapping
	// 'unittest'   => MODPATH.'unittest',   // Unit testing
	// 'userguide'  => MODPATH.'userguide',  // User guide and API documentation
	));

Ahora vamos a crear un controlador que sera en este caso el backend, el cual verificara que si estas logueado te deja entrar a ejecutar cualquier acción, si no te re-direccionara a un controlador “account” y al action “login” que tendra la vista del formulario de login, y también tendrá un link a registrarse usando este modulo A1.

En este controlador “backend” tenemos una action, llamada index que cargara un vista, en donde mostraremos un mensaje que dirá “bienvenido Nombre_de_usuario”

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * Controller_Backend 
 * 
 * Este es el backend de una aplicacion que esta usando A1 como metodo de autenticación
 * 
 * @author Javier
 * @package Backend
 * 
 */
class Controller_Backend extends Controller {

    /**
     *
     * @var User $auth contains object a1 user 
     */
    public $auth;
    
    /**
     * (non-PHPdoc)
     * @see system/classes/kohana/Kohana_Controller::before()
     */
    public function before()
    {
        parent::before();
        $this->auth = A1::instance();
        $this->_prevent_back();
        if($this->auth->logged_in()=== FALSE)
        {
            $this->request->redirect(Route::url('default',array('controller' => 'account', 'action' => 'login')));
            return;
        }
        view::set_global('logout',Route::url('default',array('controller' => 'account', 'action' => 'logout')));
    }
    
    public function action_index()
    {
        $view = View::factory("backend/home")
                        ->set("auth",$this->auth);
        
        $this->response->body($view);
    }

    private function _prevent_back()
    {
    	$this->response->headers("Cache-Control","no-store, no-cache, must-revalidate");
    }
} // End Welcome

Las partes importantes a destacar son:

• En el método before asignamos a $this->auth (variable publica) una instancia de A1, que es el modulo que hará el login.
• Luego preguntamos mediante el método $this->auth->logged_in() que seria lo mismo que usar A1::instance()->logged_in(), que si es FALSE, significa que no esta logeado entonces lo redirecciona a la siguiente url:
• Route::url(‘default’,array(‘controller’ => ‘account’, ‘action’ => ‘login’) la cual dice: que usando el route llamado default construya un url basada en cierto controlador, cierta acción y cierto id.
• Tenemos un action (metodo) index que mostrara una vista que estará en la carpeta backend, la vista se llama home y le digo que envié los datos de autenticación usando la variable auth.

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title></title>
    </head>
    <body>
        <div>
            <p>Bienvenido al sistema <strong><?php echo $auth->get_user()->email; ?></strong></p>
            <p style="float:right;">
            	<a href="<?php echo $logout ?>" >Salir</a>
            </p>
        </div>
    </body>
</html>

Este es el código del controlador account, con sus metodos/acciones de registro y login.

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * Controller_Account
 * 
 * Aqui estaran las funcionalidades de login y registro
 * 
 * @author Javier
 * @package Backend
 * 
 */
class Controller_Account extends Controller {

    /**
     *
     * @var User $auth contains object a1 user 
     */
    public $auth;
    
    /**
     * 
     * Variable que guardara la sesión
     * @var Session $session
     */
    public $session;
    
    /**
     * 
     * Vista que usara el sistema
     * @var View|String $view
     */
    public $view;
    
    /**
     * 
     * Aqui se cargara el modelo users
     * @var Model_Users $users
     */
    public $users;
    
    /**
     * (non-PHPdoc)
     * @see system/classes/kohana/Kohana_Controller::before()
     */
    public function before()
    {
        parent::before();
        $this->auth = A1::instance();
        $this->session =  Session::instance();
        $this->users   = new Model_Users();
    }
    
    public function action_index()
    {
        $this->action_login();
    }
    
    public function action_login()
    {
        $errors =  array();
        if($this->request->method()=="POST")
        { 
            
            $username = Arr::get($_POST, 'username');
            $password = Arr::get($_POST, 'password');
            $remember = (isset($_POST['remember']))?TRUE:FALSE;
            
            if($this->auth->login($username,$password,$remember))
            {      
                $session = $this->auth->session()->as_array();
                $session["user"] = $this->auth->get_user();
                $this->session = $session;
                $this->request->redirect(Route::url('default',array('controller' => 'backend','action' => FALSE))); 
            }
            else
            {
                $errors['login'] = "Datos no validos";
            }
        }
        $this->view = View::factory('backend/login')
        					->set('posturl',Route::url('default',array('controller' => 'account', 'action' => 'login')))
        					->set('registerurl',Route::url('default',array('controller' => 'account', 'action' => 'register')))
                            ->set("errors",$errors);
    }
    
    public function action_register()
    {
    	$errors =  array();
        if($this->request->method()== "POST")
        {
        	$username = Arr::get($_POST, 'username');
            $password = Arr::get($_POST, 'password');
            $errors['register'] = "Error al intentar registrarse";
            if($this->users->unique_user($username)=== FALSE)
            {
         		   	$new_user = $this->users->save_user($username,$password,$this->auth);
         		   	if($new_user->saved())
         		   	{
         		   		$this->auth->complete_login($new_user);
         		   		$this->request->redirect(Route::url('default',array('controller' => 'account', 'action' => 'login')).'?saved');
         		   	}
         		   	$errors["register"] = "No se pudo guardar el nuevo registro";
            }
            $errors['register'] = "El usuario {$username} ya existe en la base de datos";
        }
        $this->view = View::factory('backend/register')
        						->set('errors',$errors)
            					->set('posturl',Route::url('default',array('controller' => 'account', 'action' => 'login')))
        						->set('registerurl',Route::url('default',array('controller' => 'account', 'action' => 'register')));    
    }
    
    public function action_logout()
    {
    	$this->auth->logout();
    	$this->request->redirect(Route::url('default',array('controller' => 'backend','action' => FALSE)));
    }
    
    public function after()
    {
        $this->response->body($this->view);
        parent::after();
    }

} // End Account

Como vemos este controlador, tenemos el método before que se ejecuta antes de cualquier “action” en donde establecemos el valor de algunas propiedades de la clase como la autenticación, la sesión y el modelo (entidad).

También le indico que si recibo el método action_index, en realidad ejecute el método action_login, que es el que hará el trabajo.

El método action_login, lo que hace es mostrar la vista login, la cual tiene esta estructura.

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title></title>
    </head>
    <body>
        <div>
        <h2>Iniciar sesión</h2>
        <?php if(isset($errors['login'])):?>
        <p style="border:#F00 1px solid;background:#dd0000;color:#fff;width:auto;">
        	<?php echo $errors['login'] ?>
        </p>
        <?php endif; ?>
        <form action="<?php echo $posturl ?>" method="POST">
            <p>
                <label>Usuario</label>
                <input type="text" value="" name="username" />
            </p>
            <p>
                <label>Password</label>
                <input type="password" value="" name="password" />
            </p>
            <p>
                <input type="checkbox" name="remember" />
                <label>Recordar password</label>
            <p>
                <input type="submit" value="Iniciar sesión" name="login" >            
            </p>            
        </form>
        <p>
            <a href="<?php echo $registerurl ?>">Registrarse</a>
        </p>
        </div>
    </body>
</html>

Que como vemos, es un simple formulario.

En el mismo método action_index, tiene un if que comprueba si recibe una petición POST, si es así extraemos las variables usando Arr::get de kohana, también verificamos si existe la variable remember, la cual actúa como una FLAG, que en caso de ser verdadero lo usaremos para recordar los datos del usuario.

Aquí es donde ocurre, toda la “magia”, y haremos hincapié en esto.

if($this->auth->login($username,$password,$remember)) :

Este código lo que hace es hacer el login, y el ultimo parámetro remember tiene la capacidad de generar el recordatorio del password.

Si el login es correcto, se creara un sesión y hará la lógica de asignación de variables del usuario a la sesión, posteriormente se redirecciona a el backend del sistema.

En caso de no hacer el login, tenemos anteriormente un array, que en este caso asignara a una clave llamada login, un mensaje de error., el cual se mostrara en la vista login.

También tenemos un método action_register, que posee, un formulario similar al de login, y que en este caso hace el registro de un usuario, usando el modelo users, el cual también hace validación de que no exista un usuario con el mismo nombre(obviamente la validación puede ser diferente).

Y también tenemos el método save_user que es encargado de hacer el insert del nuevo usuario, aquí vemos que usamos para el password, $auth->hash(), que es un método de A1, que lo estamos inyectando como dependencia (DI), y es importante usar este método ya que con esto generamos el password usando el algoritmo de cifrado que incluye A1, aunque lo podremos modificar, pero es indispensable convertir el password al guardarlo, al hacer el login no es necesario convertirlo A1 lo hace en automático.

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * 
 * Model_Users 
 * 
 * Modelo/entidad de la tabla users
 * 
 * @author Javier
 * @package backend
 */
class Model_Users extends ORM {

	/**
	 * 
	 * Evitamos que convierta mi tabla a plural
	 * @var boolean $_table_names_plural
	 */
	protected $_table_names_plural = FALSE;


	/**
	 * 
	 * Comprueba que no exista en la base de datos(evita duplicados)
	 * @param String $username
	 * @return boolean 
	 * 
	 */
	public function unique_user($username)
	{
		$user = ORM::factory($this->_table_name)->where('email','=',$username)->find();
		return (bool) $user->loaded();
	}

	/**
	 * 
	 * Inserta un nuevo usuario
	 * @param String $username
	 * @param String $password
	 * @param A1 $auth
	 * @return Model_Users $user
	 * 
	 */
	public function save_user($username, $password, A1 $auth)
	{
		$user = ORM::factory($this->_table_name);
		$user->email = $username;
		$user->password = $auth->hash($password);
		$user->save();
		return $user;
	}

}

Regresando al controlador, después de que el nuevo usuario se haya registrado, se redirecciona al login, si no simplemente avisa del error, mandando esta información, a la vista.

En el mismo controlador tenemos un método action_logout, que lo que hace es cerrar la sesión, y redireccionar, aquí creo que no hace falta mas explicación.

En el método after lo que hago es lanzar la vista a la pantalla usando $this->response->body

Quizá un poco larga la explicación pero es mejor que quede claro.

En resumen, creamos nuestro controlador que haga el login, y otro que cree las cuentas, usamos A1, para manejar el password, para registrar el usuario y para hacer el login, evitando volver a reescribir este proceso cada vez que necesitemos hacer un login.

Como nota adicional, verán en el controlador backend un método privado que se llama: _prevent_back(), este método evita que cuando hagamos logout, al dar clic en el botón atrás, no regrese a la sesión como si nunca hubiéramos salido por que esta cacheado, aunque realmente hayamos finalizado la sesión y no permita hacer nada. Estoy en contacto con el creador del modulo y mande la propuesta de agregar este control de cache al core del modulo, y la parecer en breve ya vendrá por default y ya no tendrán que agregar este método(sera configurable desde el archivo de configuración del modulo).

Tambien me falto agregar que el campo de la base de datos para el password, debe de ser de al menos 70-80 caracteres, o más, por que las cadenas que genera A1, para los passwords son muy grandes, y si aumentan el cost en el config, aun seran mas grandes.

Aparte de los gists, dejo el proyecto en github, para que quien guste lo puede tomarlo y bajarlo:

Hasta el próximo post.

Github: kohana A1 implementación.
Parche para usar A1 pero con sha1 si necesidad de usar bcrypt: https://gist.github.com/1352205
Colocar el archivo del parche (a1.php) en application/classes/ y ahora sus password que generen o usen usaran sha1 y no brcypt con CRYPT_BLOWFISH

Cuando trabajamos con el framework Kohana PHP, una parte muy importante son las vistas, ya que son unos de los pilares del MVC, el cual es altamente utilizado por el framework.

Las vistas son archivos con extensión .php las cuales están pensadas para mostrar contenido, y también existe un modulo que nos permite utilizar plantillas smarty, pero hoy no tocaremos ese tema, estos archivos estarán alojados en ruta_de_instalacion_/application/views/ y pueden contener código Php, aunque la idea es de que dicho código sea lo más pequeño  y simple posible, y sea solo para mostrar resultados por ejemplo de una consulta.

Como vimos en la segunda entrega de este manual, para mostrar algo es imprescindible usar una vista, he invocarla desde nuestro controlador, mediante el método estatico View::factory.

<?php defined('SYSPATH') or die('No direct script access.');

class Controller_Tienda extends Controller {

 public function action_index()
 {

 $vista = View::factory('template');
 $this->request->response = $vista;

 }

} // End Tienda

Ahora bien como es de suponerse, podemos enviar datos a nuestra vista para poder mostrarlos en ella, esto nos sirve para por ejemplo enviar un array a nuestra vista y recórrelo para mostrar algún resultado de una consulta.

Hay varias formas de enviar datos a nuestra vista, veamos cuales son:

Mediante Bind o Set, de esta forma podemos pasar una variable, sin importar su valor a nuestra vista y puede ser un string, entero, un array o un objeto y se encadena a nuestro método estático de View::factory, cabe señalar que la única diferencia entre bind y set es que bind asigna la variable por referencia, en lo personal casi no la uso, ya que set satisface mis tareas.

La otra opción es mediante variables globales y para ellos se pueden utilizar dos métodos estáticos (uno se usa como set y otro como bind), los cuales son View::set_global y View::bind_global, la diferencia con las dos formas anteriores es que con estos métodos se crean variables globales que pueden ser usadas por cualquier vista, sin tener que especificar alguna vista en especifico.

Ahora veamos cómo usarlas, como nota, solo voy a mostrar set, ya que como indique no he usado ni he necesitado usar bind, si quieren ver el funcionamiento de bien, simplemente reemplazan set por bien y listo XD.

Usando método set.

controlador.php

<?php defined('SYSPATH') or die('No direct script access.');

class Controller_Tienda extends Controller {

 public function action_index()
 {

 $user = 'Ajaxman';
 $vista = View::factory('template')->set('username',$user);// Asignamos $user a una nueva variable $username;
 /* tambien podemos enviar muchas de la siguiente forma
 *
 * $vista = View::factory('template')
 ->set('username',$user)
 ->set('edad','18 Años')
 ->set('pais','mexico'); Y asi podemos seguir enviando mas variables a dicha vista
 */

 $this->request->response = $vista;
 }

} // End Tienda

Vista template.php

<!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">
<head>
 <title>Vista para Kohana PHP</title>
</head>
<body>
<h1>Bienvenido <?php echo $username; ?><h1>
 <p>Hola esta es una vista para Kohana PHP</p>
</body>
</html>

Lo anterior mostraría Bienvenido Ajaxman, y de esta forma pueden mandar un array o un objeto(resultado de una consulta), recórrelo mediante foreach y mostrar el resultado del mismo.

Ahora bien para las variables globales solo hay que definirlas con el siguiente método estático y podemos usarlas en cualquier vista que carguemos.

Y algo que se me olvidaba pero igual es muy importante el método estático View::factory se puede usar también dentro de la vista, pero debemos usar un método render para que se envié la salida en pantalla, en el código que sigue veremos cómo usarlo.

controlador.php

<?php defined('SYSPATH') or die('No direct script access.');

class Controller_Tienda extends Controller {

 public function action_index()
 {

 $user = 'Ajaxman';

 View::set_global('titulo','Bienvenido '.$user);
 View::set_global('keywords','Php,Kohana,Framework, prueba');

 $vista = View::factory('template'); //Notese que no enviamos nada ya que son variables globales

 $this->request->response = $vista;
 }

} // End Tienda

Vista template.php

<!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">
<head>
 <title><php echo $titulo; ?></title>
 <meta name="keywords" content="<?php echo $keywords; ?>">
</head>
<body>
<div>
 <div>
 <?php echo View::factory("head_display")->render();?>
 <!-- Con lo anterior estamos invocando a una vista -->
 </div>
</div>
</body>
</html>

Vista header_display.php

<h1><?php echo $titulo; ?> </h1>
<a href="/logout">Cerrar sesión</a>

Y listo con esto ya estaríamos trabajando con las vistas, ya saben si tienen dudas pueden dejar un comentario, si me tardo en responder no se alteren es que a veces ando muy ocupado, pero siempre respondo.

En la siguiente entrega veremos más a fondo los ORMS para después hacer un ejemplo ya útil con todo lo aprendido.

Y bien si no sabes que son estos métodos, aquí los veremos para que te des una idea de como usarlos y para que sirven.

Imaginemos el siguiente código que nos servirá para mostrar los datos de un usuario

<?php
class User {
  private $name;
  private $link;
  private $pais;

  public function setData($name = '', $link = '', $pais = '')
  {
    $this->name = $name;
    $this->link = $link;
    $this->pais = $pais;
  }

  public function getData()
  {
    echo "Nombre::".$this->name."n";
    echo "Link::".$this->link."n";
    echo "Pais::".$this->pais."n";
  }
}

$user = new User();
$user->setData('Ajaxman','http://www.ajaxman.net','Mexico'); // Lease User,Link,Pais
$user->getData();
?>

Hasta ahí todo bien,sin embargo si vemos el código notamos que tenemos el método setData unicamente para asignar datos, esto se podría hacer de esta forma

<?php
$user = new User('Ajaxman','http://www.ajaxman.net','Mexico');// Lease User,Link,Pais
$user->getData();
?>

Y si queremos que funcione simplemente hay que llamar a un método igual que el nombre d e la clase de la siguiente forma.

<?php
class User {
  private $name;
  private $link;
  private $pais;

  public function User($name = '', $link = '', $pais = '')
  {
    $this->name = $name;
    $this->link = $link;
    $this->pais = $pais;
  }

  public function getData()
  {
    echo "Nombre::".$this->name."n";
    echo "Link::".$this->link."n";
    echo "Pais::".$this->pais."n";
  }
}

?>

Ahora bien, desde que surgió PHP5 se puede usar métodos mágicos, uno de ellos es __construct el cual se ejecuta cuando se inicia la carga de la clase, la ventaja es que siempre se debe de llamar así y no tendrás que estar poniendo métodos con el mismo nombre de la clase y quedaría así.

<?php
class User {
  private $name;
  private $link;
  private $pais;
public function __construct($name = '', $link = '', $pais = '')
  {
    $this->name = $name;
    $this->link = $link;
    $this->pais = $pais;
  }

  public function getData()
  {
    echo "Nombre::".$this->name."n";
    echo "Link::".$this->link."n";
    echo "Pais::".$this->pais."n";
  }
}
?>

Se podría decir que tiene poca utilidad, sin embargo en diversas ocasiones verán que usar el método __construct les resolverá mucho problemas.

Recuerden __construct se ejecuta automáticamente al instancia la clase, osea $obj = new Class();, si recuerdan los métodos estáticos, en el post anterior, recordaran que nunca se instancia, por lo cual no funciona en los métodos estáticos.

El otro método se llama __destruct y funciona a la inversa, se ejecuta cuando se termina la clase, y este puede usarse para destruir variables o valores que ya no vayamos a usar.

Personalmente yo no había usado nunca __destruct(), hasta hace un par de días cuando debía hacer lo siguiente.

Movimos un website montado en Joomla a otro server y no funcionaba una lista de noticias, todo estaba bien, entonces revise el código y quise hacer un debug, pensé en usar un var_dump(); pero no funciono, entonces se me ocurrió que para evaluar esa variable debía usar __destruct() ya que se ejecuta cuando termina la clase, así que no debería de haber problemas y efectivamente todo funciono bien y pude depurar mis variables.

Claro es un uso que le encontré, pero puede haber muchos mas, creo que me extendí bastante, pero es para dar una idea a personas que no saben aun que onda con los métodos constructores y destructores de la clase.

Nota: Nos vemos el el Campus Party México 2010

Bien empecemos por el principio.

Cuando estamos programando a veces no deseamos estar instanciando una clase, ya que puede que el método sea algo que simplemente devuelva algún valor, por ejemplo un parser o similar, entonces se vuelve tedioso estar haciendo, $obj =new Clase();, la solución para esto es usar un método estático.

Los métodos estáticos no necesitan ser instanciandos ademas de que son ligeramente mas rápido que los métodos normales, si bien esto no significa que debamos de dejar de usar los métodos normales, estos pueden ser muy útiles para hacer por ejemplo una especie de catalogo de funciones, aunque claro su uso depende de cada quien.

Veamos una clase con un método normal y posteriormente como seria si fuera estático.

<?php
 //Clase
class Tools{
  /// Metodo normal
  public function today($paramString = '')
  {
    setlocale(LC_ALL,'es_MX');
    $date = $paramString.utf8_encode(strftime("%A %d de %B del %Y"));
    return $date;
  }
}
$Helps = new Tools();
echo $Helps->today("Hoy es "); //Salida  Hoy es jueves 29 de julio del 2010
?>

Ahora veamos como se haría usando un método estático

<?php
 //Clase
class Tools{

 /// Metodo estatico
 public static function today($paramString = '')
 {
   setlocale(LC_ALL,'es_MX');
   $date = $paramString.utf8_encode(strftime("%A %d de %B del %Y"));
   return $date;
 }
}

echo Tools::today("Hoy es "); //Salida  Hoy es jueves 29 de julio del 2010

?>

Como podemos ver es mas simple llamarlo, claro que como menciono hay algunas cosas a tener en cuenta, las mas importantes son:

• No existen los métodos “mágicos” __construct ni __destruct, puesto que jamas se instancia la clase, en su lugar se puede invocar otro método estático que asigne, las variables
• No existe $this, se debe usar en su lugar self, aunque las variables tienen que ser igualmente estáticas, esto se aplica tanto en variables como métodos

Haremos un ejemplo un poco mas complejo para ver como usar self en vez de this

<?php
/**
*
* Nota
* Este ejemplo funciona solo deben de copiar y pegar el codigo para probar
*/

 //Clase
class Tools
{
 /// Variable estatica
 public static $pais = 'Mexico';

 //Metodo estatico
 public static function setPais($pais = 'Mexico')
 {
   //Set de el pais
   /**
   * Notese la sintaxis self::$Variable
   */
   self::$pais = $pais;
 }

 /// Metodo estatico
 public static function today($paramString = '',$pais=FALSE)
 {
   setlocale(LC_ALL,'es_MX');
   $date = $paramString.utf8_encode(strftime("%A %d de %B del %Y"));
   if($pais != FALSE)
   {
   $date .= ' en '.self::$pais; //Notese la forma de obtener la variable
   }
   return $date;
 }
}

echo Tools::$pais; //Salida Mexico
Tools::setPais('Brasil');
echo Tools::$pais; //Salida Brasil
echo Tools::today("Hoy es "); //Salida  Hoy es jueves 29 de julio del 2010

Tools::$pais = 'Canada'; //Nota tambien es posible asignar valores de esta forma

echo Tools::today("Hoy es ",TRUE); //Salida Hoy es jueves 29 de julio del 2010 en Canda

?>

Con ello podríamos resumir que this es similar a self solo que hay que tratarlo con cuidado, y usar lo siguiente cuando se intenta invocar esto desde nuestra clase:

• self::$var en vez de $this->var
• self::function() en vez de $this->function()

Bueno creo que me excedí un poco con este post, pero lo importante es que creo que si quedado claro, dudas ya saben a en lo comentarios.

Ya sabemos cómo instalarlo ahora procedamos a trabajar.

Como ejemplo haremos una aplicación que liste productos, maneje altas y bajas de una tienda con un Front-End y un Back-End.

Para empezar necesitamos lo siguiente

*Requisitos

• Apache (ModRewrite instalado)
• PHP 5.2
• MySQL
• Kohana 3 Framework

*Opcionales

• SQlFront
• Phpmyadmin
• Editor de código como Webuilder (Luego veremos cómo hacer casi lo mismo con Netbeans un IDE completo)

Haremos una nueva instalación de Kohana, en nuestra PC que será nuestro servidor (localhost) copiamos el contenido del framework a una carpeta que se llame tienda (en mi caso E:/www/tienda/)

Y acceso a mi website escribiendo http://localhost/tienda/  y ahí veremos nuestro install ahora navegamos hasta  E:/www/tienda/ y ahí estará ese archivo, lo borramos (si todo salió ok, si no corregir y verificar hasta que todo este en verde)

Esta vez vamos empezar por los datos para que al final hagamos el website.
Necesitamos una tabla de productos usaremos el siguiente SQL con los datos básicos de cada producto.

Como regla general hay que tener en cuenta que la base de datos debe de tener las siguientes características:

• Nombre de la tabla en Plural (“productos”)
• Nombre de los campos en Singular (“descripción”)
• La clave principal se llamara id, en minúsculas (Se puede poner otra cosa pero habría que editar nuestra clase que manejara esa tabla por ello lo dejaremos como id)

CREATE TABLE <code>productos</code> (
 <code>id</code> int(11) NOT NULL AUTO_INCREMENT,
 <code>nombre</code> varchar(255) DEFAULT NULL,
 <code>descripcion</code> text,
 <code>activo</code> int(1) DEFAULT '1',
 PRIMARY KEY (<code>id</code>)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

Agregamos el siguiente contenido

INSERT INTO <code>productos</code> VALUES (1,'Agua Debian','Agua Embotellada 1 Lts Marca Debian',1);
INSERT INTO <code>productos</code> VALUES (2,'Refresco Php','Refresco 2 Lts Marca Php Sabor Uva',1);
INSERT INTO <code>productos</code> VALUES (3,'Paleta Ubuntu','Paleta Ubuntu sabor Cafe 1pza',1);

Ahora editaremos nuestro bootstrap   (E:/www/tienda/application/bootstrap.php)
Buscaremos el configuración del init y escribiremos los siguiente

<?php
//...
//...
Kohana::init(array(
 'base_url'   => 'http://localhost/tienda/',//Aqui le decimos cual será la url del proyecto
 'index_file' => FALSE, //                  //Le indicamos que usara urls amigables (sin .php)
));
...
...
//Buscaremos el Route en el mismo script y lo editaremos
..
...
Route::set('default', '(<controller>(/<action>(/<id>)))')
 ->defaults(array(
 'controller' => 'tienda',  //Nombre del controlador por default
 'action'     => 'index',   //Acción por default (lo dejamos en index)
 ));

Lo guardamos (:wq XD ) y vamos a ver que en la raíz del proyecto hay una archivo llamado example.htaccess lo renombramos a .htaccess que será el que manejara las urls amigables para no tener el tienda/index.php/controlador ser tienda/controlador.

Les recomiendo comentar la siguiente línea para no tener problemas en las direcciones

# Installation directory
#RewriteBase /kohana/ pueden poner /tienda y va a funcionar pero es mejor quitarla
# ya que con ello evitaremos problemas cuando estemos cambiando de un servidor local
# a un servidor de producción

Lo guardamos (:wq XD )  Y ahora vayamos a crear nuestro controlador.

Entramos a E:/www/tienda/application/classes/controller y creamos tienda.php
Y creamos nuestro controlador

<?php defined('SYSPATH') or die('No direct script access.');

class Controller_Tienda extends Controller {
/**
 * Controller_Tienda Es el controlador por default recuerden el bootstrap
 * todos los controladores llevan esta sintaxis, Controller_<Nombre_del_controlador>
 *
 *  action_index() Es la acción por default (ejemplo http://localhost/tienda/accion)
 *  si no se especifica en la url (ejemplo http://localhost/tienda/accion, se usara
 *  index por default y la sintaxis es action_<nombre_de_la_accion>
 */
 public function action_index()
 {
 echo "Programando ....";
 }

} // End Tienda

Lo guardamos (:wq XD ) y naveguemos a http://localhost/tienda/ veremos que dirá “Programando ….”, si no vemos eso es que algo hicimos mal y hay que volver a ver en donde nos fallo

Ahora bien, procederemos a conectar la base de datos, para ello vamos a editar el archivo de configuración de la base de datos E:/www/tienda/modules/database/config/database.php

Y agregaremos la conexión mysql, pueden usar PDO(pero prefiero hacerlo como ejemplo de forma tradicional)

<?php defined('SYSPATH') or die('No direct access allowed.');

return array
(
 'default' => array
 (
 'type'       => 'mysql',
 'connection' => array(
 /**
 * The following options are available for MySQL:
 *
 * string   hostname
 * string   username
 * string   password
 * boolean  persistent
 * string   database
 *
 * Ports and sockets may be appended to the hostname.
 */
 'hostname'   => 'localhost',  ////Usa los datos de tu conexión MYSQL
 'username'   => "root",       ////Usa los datos de tu conexión MYSQL
 'password'   => "localhost",  ////Usa los datos de tu conexión MYSQL
 'persistent' => FALSE,        ////Opcional
 'database'   => 'kh_tienda',  ////Usa los datos de tu conexión MYSQL
 ),
 'table_prefix' => '',
 'charset'      => 'utf8',
 'caching'      => FALSE,
 'profiling'    => TRUE,
 ),
 //Aquí continúa con el PDO, ese de momento no hay que tocarlo
 //..
 //....
 //......
)

Ahora que ya lo tenemos vamos a decirle a kohana que agregue los módulos de base de datos y orm, necesarios para que funcione nuestro ejemplo, para ello hay que editar otra vez nuestro archivo bootstrap ya descomentar los módulos de manera que quede así.

<?php
//..
//....
/**
 * Enable modules. Modules are referenced by a relative or absolute path.
 */
Kohana::modules(array(
 // 'auth'       => MODPATH.'auth',       // Basic authentication
 //'cache'      => MODPATH.'cache',      // Caching with multiple backends
 // 'codebench'  => MODPATH.'codebench',  // Benchmarking tool
 'database'   => MODPATH.'database',   // Database access
 // 'image'      => MODPATH.'image',      // Image manipulation
 'orm'        => MODPATH.'orm',        // Object Relationship Mapping
 // 'pagination' => MODPATH.'pagination', // Paging of results
 // 'userguide'  => MODPATH.'userguide',  // User guide and API documentation
 ));

Lo guardamos y ahora hay que agregar el Modelo ORM que manejara la base de datos, para ello hay que crear un archivo llamado con el mismo nombre de nuestra tabla,

En E:/www/tienda/application/classes/model hay que agregar el modelo productos.php si no existe esta carpeta model hay que crearla.

En el modelo agregaremos el siguiente contenido

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * Description of Model_Productos
 *
 * @author Javier
 */
 //// Importante el nombre de nuestra  clase debe de llevar la siguiente sintaxis
 ////  Model_<Nombre_de_la_tabla>

class Model_Productos extends ORM {

 protected $_table_names_plural = false;
 /// Ojo con esto este campo es true por default pero hace que Kohana maneje a su gusto
 /// Los nombres de la tablas agregándole "s" o "es" a las mismas
 /// Es decir trata de pluralizar el nombre automáticamente, puede que sea muy útil
 /// Pero en lo personal no me gusta prefiero yo usar lo nombres a mi gusto
 /// Por ello con esta indicación le decimos a kohana:
 /// "Deja el nombre de la tabla como se llama la clase y no le hagas cambios"


}

Y bien ya casi terminamos, ahora hagamos una prueba para ver si todo ha salido bien.

Vayamos a nuestro controlador y agreguemos el siguiente código

<?php
 //..
 //.....
 public function action_index()
 {
 //echo "Programando ....";
 $productos = ORM::factory('productos')->find_all();
 foreach($productos as $producto)
 {
 echo "[[Producto=".$producto->descripcion."]]";
 }

 }

Ojo no es MVC todavía pero es para pruebas, expliquemos el código:
Para hacer una consulta al ORM, usaremos el siguiente código (se puede de varias formas, esta es la mas fácil)
$productos = ORM::factory(‘<Nombre_del_Modelo>’)->otros_metodos()
Donde

• $productos: es la variable donde se almacenara nuestro contenido de la consulta
• ORM::factory(): Es el método estático para usar el ORM y el parámetro será el nombre del modelo
• otros_metodos: Es donde le podemos agregar métodos where, join, order_by, find,find_all, etc., digamos como una especie de parámetros del query, algo importante a destacar es
  • si usamos ->find() Kohana hará automáticamente un limit 1
  • Si usamos ->find_all() Kohana traerá todos los resultados
• Hay muchos parámetros poco a poco los iremos viendo.

Por último con el foreach recorremos nuestro objeto y mostramos sus propiedades las cuales son las mismas que los campos de la tabla y listo.

Guardamos nuestro controlador y al entrar a http://localhost/tienda/, nos debe aparecer algo como lo siguiente:

[[Producto=Agua Embotellada 1 Lts Marca Debian]][[Producto=Refresco 2 Lts Marca Php Sabor Uva]][[Producto=Paleta Ubuntu sabor Cafe 1pza]]

Con eso terminamos la parte 1, Como verán siento que fue bastante rápido, que quizá se me hayan quedado cosas, sin escribir, si notan algún error, o algo no funciona pueden comentarlo.

Yo supongo que ya leyeron el post anterior sobre instalación de Kohana 3, si no este es el link [Framework Kohana 3] Instalando y configurando Kohana 3 #Ko3

Bien teniendo eso, hoy haremos un pequeño ejemplo de MVC, recordemos que el paradigma MVC (Modelo, Vista, Controlador) nos permite desarrollar mejor, mas rápido, organizar nuestro proyecto y hacerlo abstracto.

Lo anterior es porque nos permite programar de la siguiente manera:

• Modelo: Capa de datos, la cual se encarga de la petición de datos
• Vista: capa de presentación, es la que se encarga de mostrar el resultado al cliente
• Controlador: capa de negociación, esta se encarga de organizar al información, en otras palabras identifica que es lo que necesitas, pide los datos al modelo y los presenta en la vista.

Bien ahora veamos cómo trabaja Kohana 3 con esto

Como podemos ver Kohana consta de 3 carpetas:

• Application: es donde estará nuestra aplicación donde tendremos nuestras carpetas de MVC, digamos que es lo publico
• Modules: es donde residen los módulos que le podemos agregar a Kohana por ejemplo la conexion a la base de datos, el ORM(luego hablaremos de este),autenticación etc.
• System: pues como su nombre lo indica es donde está el core del Kohana 3 o el núcleo, este pues casi no hay que tocarlo en la mayoría de proyectos de hecho casi nunca se toca o no debería tocarse.

Ahora lo que nos interesa en este caso es la carpeta Application, al abrimos y veremos las siguiente carpetas:

• Cache: es donde se guardara el cache interno, este se activa muy fácil pero no esta tan eficiente como un verdadero cache.
• Clases: es donde estarán nuestros controladores (C de MVC) y nuestros modelos aquí veremos que hay una carpeta llamada controller, ahí hay que crear una carpeta que se llame model que servirá para nuestros modelos, y también podemos crear una carpeta helper que nos servirá para poner ahí nuestros helpers cuando los creemos.
• Config: esta carpeta no le he tocado, pero por lo que he visto son como configuraciones especiales del website, yo recomiendo no poner nada ahí, hasta ver bien su uso.
• Logs: como su nombre lo indica aquí se guardan logs de los errores de nuestro código.
• views:  si bien esta carpeta regularmente no existe, pero hay que crearla por que es donde estarán nuestras vistas(la capa de presentación) de nuestro proyecto.

También veremos que dentro de la carpeta principal Application hay un archivo bootstrap.php el cual es digamos que como un config y un router a la vez, ya que es donde configuraremos algunas cosas y enrutaremos mediante expresiones regulares(se parece al settings.py de Django) a los controladores que deseemos.

A continuación describiré cada una de las partes que conforman el bootstrap.php

• date_default_timezone_set(‘America/Chicago’); define la zona donde se está ejecutando nuestros script yo le pongo America/Mexico_city
• setlocale(LC_ALL, ‘en_US.utf-8′); Configuración de la codificación, recomiendo usar UTF-8
• spl_autoload_register(array(‘Kohana’, ‘auto_load’)); Esto es un poco complicado de explicar en un par de líneas(luego me extenderé), pero diremos que con esto se esta cargando Kohana.
• ini_set(‘unserialize_callback_func’, ‘spl_autoload_call’); Lo mismo que el de arriba, es para que inicialice el autoloader para serializar.
• Kohana::init(array(‘base_url’ => ‘/kohana/’)); es donde configuraremos el mod_rewrite (en php, también hay que agregar el htacces), la url de base, el cache interno entre otras.
• Kohana::$log->attach(new Kohana_Log_File(APPPATH.’logs’)); pues indica donde guardara los logs
• Kohana::$config->attach(new Kohana_Config_File); Configuración de Kohana
• Kohana::modules(array( … )) Aquí es donde cargaremos los módulos como el ORM y la base de datos, también podemos agregar algunos otros.
• Route::set(‘default’, ‘((<controller>/(/<action>)))’) ->defaults(array( ’controller’ =>  ’welcome’,'action’ => ‘index’,)); Este por el momento diremos que nos indica a que controlador ira por default en este caso se llama welcome, y método index, luego veremos cómo configurarlo bien.
• echo Request::instance()->execute() ->send_headers() ->response; Esto hasta ahorita no lo he tocado pero es para que se ejecute el sistema.

Bien creo que por hoy es suficiente, si queremos empezar a probar les recomiendo que pongan controladores copiando el código del controlador welcome.

Perdonen que este todo amontonado pero no hay mucho tiempo para formatear bien el texto, esto es solo para que se den una idea, lo mejor el abrir el bootstrap.php y ver el contenido.

El capitulo que sigue veremos un ejemplo de un MVC con ORM (haber si me alcanza el tiempo si no por separado).

Saludos y buen codding…

• Apache o un servidor Web como Lighttpd
• Php 5 o superior (de preferencia 5.3)
• MySQL 5

Funcionando y correctamente configurado
Imaginemos que tenemos nuestro Htdocs en E:www y que ese es nuestro htdocs.

Ahora procedamos

• Bajaremos nuestro kohana 3
• Para ello iremos a la siguiente pagina http://v3.kohanaphp.com/download
  Y descargaremos la versión v3.0.0 “renaissance” que es la estable de la rama 3.x
• Lo descomprimimos y veremos dentro una carpeta que se llama kohana, y dentro de ella el framework
• Copiamos esta carpeta kohana a nuestro Htdocs
• Quedaría así E:wwwkohana

Ahora vayamos a nuestro dirección http://localhost/kohana y veremos lo siguiente.

kohana 3

Con ello ya tenemos instalado kohana, fácil verdad? lo que están viendo es el archivo install.php, que no hace otra cosa más que comprobar que tienes un entorno en donde se pueda trabajar con Kohana 3 sin problemas.

En la imagen pudiste ver que me aplicación los obligatorios son los siguientes:
Environment Tests

• PHP Version 5.2.11
• System Directory E:wwwkohanasystem
• Application Directory E:wwwkohanaapplication
• Cache Directory E:wwwkohanaapplicationcache/
• Logs Directory E:wwwkohanaapplicationlogs/
• PCRE UTF-8 Pass
• SPL Enabled Pass
• Reflection Enabled Pass
• Filters Enabled Pass
• Iconv Extension Loaded Pass
• Mbstring Not Overloaded Pass
• URI Determination Pass

Los opcionales son los siguientes:

Optional Tests

• cURL Enabled Kohana requires cURL for the Remote class.
• mcrypt Enabled Pass
• GD Enabled Pass
• PDO Enabled Pass

Como ven hay una opción que está incompleta, es porque no tengo instalada la extensión cURL, la cual al puedo agregar haciendo lo siguiente:

Abriendo el archivo php.ini de mi instalación de Php (en mi casa está en C:PHPphp.ini)

Y buscar estas líneas

<strong>;extension=php_bz2.dll
</strong>
<strong>
;extension=php_curl.dll
</strong>
<strong>
;extension=php_dba.dll</strong>

Y descomentar la que dice curl para que quede así

<strong>;extension=php_bz2.dll
</strong>
<strong>
extension=php_curl.dll
</strong>
<strong>
;extension=php_dba.dll</strong>

Reiniciamos el servidor y listo, esto sirve por si nos falta alguna extensión.

Ojo si tenemos algún campo marcado en rojo en Optional Tests, Kohana funcionara aunque en algún momento cuando usemos esa característica fallara(), si hay campos en rojo en la sección de Environment Tests, entonces no funcionara, esto se puede deber a la versión de Php que tengamos instalada, o a los permisos en ciertas carpetas, revisar los permisos de la carpeta Cache Directory E:wwwkohanaapplicationcache/ o Logs Directory E:wwwkohanaapplicationlogs/.

Ya que no existen, y kohana los crea, entonces si vemos que nos marca error, podemos crearlos a mano y poner les permisos de escritura chmod 676.

Ahora que ya todo funciona borramos el archivo install o lo renombramos (por seguridad elimínalo) y ahora si podemos ver nuestro entorno en funcionamiento
y si vemos el mensaje hello, world! significa que todo es funcionando bien.

Lo que vemos es la ejecución del controlador por default que está en

E:wwwkohanaapplicationclassescontrollerwelcome.php ->Este el el controlador por default el cual contiene el siguiente código:

<?php defined('SYSPATH') or die('No direct script access.');

class Controller_Welcome extends Controller {

public function action_index()

{

$this->request->response = 'hello, world!';

}

} // End Welcome

?>

Hasta ahí llegamos hoy, luego les diré como usar bien lo controladores, pero se pueden guiar por nuestro anterior inicio de Codeigniter son parecidos.

Bueno la idea de este post es platicarles sobre como se pueden crear los famosos virtualhosts.Pero antes de empezar enterémonos bien que es un virtualhost.

Con los virtualhosts podremos tener varios dominios apuntando a una misma pc. Dentro de cada virtualhost podremos definir las condiciones para cada dominio que esté representando.

Es como si tuviéramos varios dominios dentro de nuestro servidor osea 127.0.0.1.

Es decir que aparte de usar http://localhost, podríamos usar http://localweb, http://proyecto, http://www.beta.com o el nombre que mas nos guste, para ello lo primero que necesitamos es tener instalado apache2 (la ultima versión) y funcionando.

Ahora veamos como crear y usar los virtualhost(Es necesario tener permisos de root para algunos cambios)

Entraremos  a nuestra consola y nos moveremos a   cd /etc/apache2/sites-available/

ajaxman@debianJS:~$ su
Contraseña:
debianJS:/home/ajaxman# cd /etc/apache2/sites-available/
debianJS:/etc/apache2/sites-available#

Una vez ahí veremos que hay un archivo llamado default (en mi caso hay dos el otro se llama default-ssl es digamos que la “plantilla” de los sitio con ssl)

debianJS:/etc/apache2/sites-available# ls -la
total 24
drwxr-xr-x 2 root root 4096 abr 14 16:37 .
drwxr-xr-x 7 root root 4096 nov  6 16:46 ..
-rw-r–r– 1 root root 1428 nov  6 17:44 default
-rw-r–r– 1 root root 7366 oct  1  2008 default-ssl

El archivo default es el que contiene la información que usaremos en los virtualHost por lo cual simplemente copiaremos todo el archivo en uno nuevo eso lo hacemos mediante el comando cat.

debianJS:/etc/apache2/sites-available# cat default> website

Ahora nuestro ls se vera asi

debianJS:/etc/apache2/sites-available# ls -la
total 24
drwxr-xr-x 2 root root 4096 abr 14 16:37 .
drwxr-xr-x 7 root root 4096 nov  6 16:46 ..
-rw-r–r– 1 root root 1428 nov  6 17:44 default
-rw-r–r– 1 root root 7366 oct  1  2008 default-ssl
-rw-r–r– 1 root root 1480 abr 14 16:35 website

Ahora lo abrimos y lo editamos con el Vi y lo unico que modificaremos sera lo siguiente.

debianJS:/etc/apache2/sites-available# vim website

< VirtualHost *:80 >
ServerAdmin webmaster@localhost

DocumentRoot /home/www/
< Directory / >
Options FollowSymLinks
AllowOverride None
< /Directory >
< Directory /home/www/ >
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
< / Directory >
………
……………
…………….
< VirtualHost >

Por esto

< VirtualHost *:80 >
ServerAdmin webmaster@ajaxman.net
ServerName prog
ServerAlias www.website.net

DocumentRoot /home/www/prog
< Directory / >
Options FollowSymLinks
AllowOverride None
< /Directory >
< Directory /home/www/prog >
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
< / Directory >
………
……………
…………….
< VirtualHost >

Nota: Tiene espacios intencionales para evitar que wordpress lo tome como si fueran tags HTML

Lo que cambiamos fue

• Agregamos Server Name, que es donde estará el nombre de nuestro servidor en este caso se llama prog
• Le agregamos un ServerAlias, que es como otro nombre para acceder a este VirtualHost, en este caso es www.website.net.
• Y le modificamos el DocumentRoot, el cual sera la carpeta del sitio que queremos Virtualizar

Los guardamos con [Esc]:wq

Ahora lo agregamos a apache

debianJS:/etc/apache2/sites-available# a2ensite website

Y apache nos dira que lo agrego con éxito, Ojo: para evitar que Apache nos de errores, es necesario que la carpeta que el indicamos en DocumentRoot exista, si no no nos va a funcionar.

a2ensite, lo único que hace es un enlace simbólico dentro de la carpeta /etc/apache2/sites-enabled a algunos de los sitios que están en la otra carpeta /etc/apache2/sites-available , es decir  en sites-available están los sitios disponibles, y en sites-enabled están  los que podemos usar.


debianJS:/etc/apache2/sites-enabled# ls -la
total 8
drwxr-xr-x 2 root root 4096 abr 14 16:26 .
drwxr-xr-x 7 root root 4096 nov  6 16:46 ..
lrwxrwxrwx 1 root root   26 nov  6 16:13 000-default -> ../sites-available/default
lrwxrwxrwx 1 root root   23 abr 14 16:26 website -> ../sites-available/website

Ahora modificamos nuestro fichero hosts, hay que tener cuidado por que Apache en mi debian tiene dos un host y otro que se llama hosts, el que vamos a modificar es hosts(con ese al final)

debianJS:/etc/apache2/sites-enabled# vim /etc/hosts

Nos aparecera asi

127.0.0.1       localhost
…….
……….
…………

Lo unico que debemos hacer es agregar nuestro nuevo sitio de acuerdo al alias que le pusimos o bien el servername(se ve mas chido con Alias) y quedara asi

127.0.0.1       localhost
127.0.0.1       www.website.net
..
…..
……..

Guardamos nuestro archivo, y con esto le decimos a nuestro Linux, que cuando teeclemos www.website.net lo busque en nuestra misma pc y no afuera.

Ahora solo recargamos apache

debianJS:/etc/apache2/sites-enabled# /etc/init.d/apache2 reload

Y listo

Ahora abrimos nuestro Firefox(Navegador) (acaso hay otro?) y tecleamos www.website.net y nos debe de desplegar la informacion de la carpeta /home/www/prog ya se aun index.php index.html o un listado, claro esi esta permitido en nuestra configuracion default(recuerden que de ahi sacamos toda la configuración).

En resumen mis comandos fueron
——————
ajaxman@debianJS:~$ su
Contraseña:
debianJS:/home/ajaxman# cd /etc/apache2/sites-available/
debianJS:/etc/apache2/sites-available# ls -la
total 24
drwxr-xr-x 2 root root 4096 abr 14 16:37 .
drwxr-xr-x 7 root root 4096 nov  6 16:46 ..
-rw-r–r– 1 root root 1428 nov  6 17:44 default
-rw-r–r– 1 root root 7366 oct  1  2008 default-ssl
debianJS:/etc/apache2/sites-available# cat default> website
debianJS:/etc/apache2/sites-available# vim website
debianJS:/etc/apache2/sites-available# vim default
debianJS:/etc/apache2/sites-available# a2ensite website
Site prog already enabled
debianJS:/etc/apache2/sites-available# cd ..
debianJS:/etc/apache2# ls
apache2.conf  conf.d  envvars  httpd.conf  mods-available  mods-enabled  ports.conf  sites-available  sites-enabled
debianJS:/etc/apache2# cd sites-enabled/
debianJS:/etc/apache2/sites-enabled# ls -la
total 8
drwxr-xr-x 2 root root 4096 abr 14 16:26 .
drwxr-xr-x 7 root root 4096 nov  6 16:46 ..
lrwxrwxrwx 1 root root   26 nov  6 16:13 000-default -> ../sites-available/default
lrwxrwxrwx 1 root root   23 abr 14 16:26 website -> ../sites-available/website
debianJS:/etc/apache2/sites-enabled# vim /etc/hosts
debianJS:/etc/apache2/sites-enabled# /etc/init.d/apache2 reload
——————————————————

Creo que ya quedo, espero que les sea util y bueno ya mejore mis posts o no?

Ahora pasando a otras cosas, les platico que desde que instale Open Suse 11, me pasaba lo siguiente cuando me conectaba a Internet, la resolución de nombres era lenta, aquí pongo una lista para que vean, como estaba la situación.

• Abrir Firefox 1-3 Segundos
• Escribir Ajaxman.net  3-4 Segundos
• Resolución de nombres de dominio (DNS) 10-20 o hasta 30 segundos
• Respuesta de la pagina y mostrar en pantalla 5-9 Segundos
• Si había una conexión con Twitter o con Google, o algún otro servicio, volvía ha hacer la resolución de nombres o sea otros 30 segundos mas o menos
• Esto solo sucedía en mi pc con Linux.

El problema en si no era la conexión a Internet, si no la resolución de nombres el DNS.

Sabia que algo tenia que hacer pero no soy tan bueno en Linux, pues estuve sufriendo así mas o menos un mes.

Leyendo foros y mas di con el problema, ya que a primera vista, no sabia cual era el problema, ya cuando di con el busque como resolverlo.

La solución era simple, modificar los dns’s. Y ¿Como hacemos eso?

Bueno se supone que en Suse ya todo biene mas APP(*) , pero para verlo mas Geek, lo haremos a manita.

Como primer paso toca modificar el archivo resolv.conf, para esto veamos que contiene dicho archivo, recuerden hacer un respaldo en caso de que algo vaya mal

Ajaxman:/home/javier # cat  /etc/resolv.conf

Ahora si observamos lo siguiente

#search gateway.2wire.net
#nameserver 192.168.1.254

Ahorita están comentados pero al principio no, osea en vez de eso que les puse estaba así

search gateway.2wire.net
nameserver 192.168.1.254

Entonces, al parecer el problema viene de que al parecer suse, intenta resolver nombres en el router, lo cual es incorrecto, ya que el no es un servidor de DNS.

Entonces la solución es simple modifiquemos el archivo, agregándole unos DNS’s buenos, yo en lo personal use Open DNS, los cuales son los siguientes.

200.33.146.233
200.33.146.169

Ahora lo editamos con el Vi

Ajaxman:/home/javier # vim  /etc/resolv.conf

Para que quede asi

Archivo resolv.conf editado

Ahora bien, ya debe de funcionar bien, sin embargo tendremos un problema, cada vez que, reiniciemos la tarjeta de red (NIC), o cuando reiniciamos el servicio dhclient, veremos que nos borrar este archivo y nos lo deja como estaba al principio.

Bien para solucionar esto basta con editar dos archivos(en estos no pongo capturas por que están muy grandes los archivos), el primero es.

Ajaxman:/home/javier # vim /etc/sysconfig/network/dhcp

En donde buscaremos lo siguiente

——————————————————————————————————-

## Type:        yesno
## Default:     yes
#
# Should the DHCP client modify /etc/resolv.conf at all?
# If not, set this to “no”. (The default is “yes”)
#
# resolv.conf will also stay untouched when MODIFY_RESOLV_CONF_DYNAMICALLY
# in /etc/sysconfig/network/config is set to “no”.
#
DHCLIENT_MODIFY_RESOLV_CONF=”yes”

—————————————————————————————————–

Y cambiaremos lo que esta en negritas , pondremos no quedando asi

DHCLIENT_MODIFY_RESOLV_CONF=”no”

Lo guardamos y ahora abrimos este

Ajaxman:/home/javier # vim /etc/sysconfig/network/config

Y ahi buscamos

## Type:        yesno
## Default:     yes
# There are some services (ppp, ippp, dhcp-client, pcmcia, hotplug) that have to
# change the /etc/resolv.conf dynamically at certain times.  E.g. if ppp/ippp
# establishes a connection and is supplied by the peer with a list of
# nameservers. Or pcmcia needs to set the correct nameserver for the choosen
# configuration scheme. If you don’t like these services to change
# /etc/resolv.conf at all, then set this variable to “no”.
# If unsure, leave it at the default (which is “yes”).
#
MODIFY_RESOLV_CONF_DYNAMICALLY=”no”

## Type:        yesno
## Default:     no
# Like MODIFY_RESOLV_CONF_DYNAMICALLY, except it modifies
# /etc/named.d/forwarders.conf instead of resolv.conf.
# If unsure, leave it at the default (which is “no”).
#
MODIFY_NAMED_CONF_DYNAMICALLY=”no”

————————————————————————————-

Y tambien lo que esta en negritas lo ponemos en NO, en mi caso ya lo deje en no.

Y ahora si podemos reiniciar la interfaz de red y siempre conservara los valores del DNS.

Bueno un pequeño pero valioso tutorial, créanme que fue muy difícil encontrar dicha solución.

Les cuento a que viene el caso o la situación, estoy creando una clase en Php, para manejar unas cosas, sin embargo son 3 cosas diferentes, vamos, tendré que usar 3 clases diferentes, ya que se trata de cosas distintas, ahora bien, para usar una clase el php se haría de la siguiente forma.

< ?php
include ("clases/calcula.inc.php");
$calcula=new Calcula();
?>

El problema surge cuando deseamos utilizar varias clases, las cuales a veces por facilidad y por costumbre las almacenamos en archivos diferentes, el ejemplo se vería mas o menos de esta forma

< ?php
include ("clases/cacula.inc.php");
include ("clases/suma.inc.php");
include ("clases/resta.inc.php");
include ("clases/raiz.inc.php");
$calc=new Calcula();

$sum=new Suma();

$rest=new Resta();
?>

Esto DESAFORTUNADAMENTE se tendrá que hacer si tenemos php 4 en nuestro server, ya que si tenemos Php 5 podemos usar autoload, una función nativa de php5, como lo indica la documentacion de Php.

Puede definir una función __autoload la cual es llamada automáticamente en caso de que intente usar una clase que no ha sido definida aún. Al llamar esta función la ejecución del script da una última oportunidad de cargar la clase antes de que PHP falle con un error.

Aqui les pongo un ejemplo de como quedaría nuestro código anterior

< ?php

function __autoload($nombre_de_clase) {
require_once $nombre_de_clase . '.php';
}

$calc=new Calcula();

$sum=new Suma();

............
?>

Como vemos es muy simple, espero que les ayude, ya que a mi no me ayudara mucho, por que en uno de los servers donde haré esto usa php 4 pues ya que, si a ti te sirvió coméntanos, como la usaste.

Mas información | Auto carga de Objetos