Enero 12th, 2015

Actualizar Fedora 20 a Fedora 21

Si quieres actualizar a fedora 21 sin morir en el intento con un yum upgrade sigue estos pasos.
Antes que nada, realiza una copia de seguridad de todos los elementos importantes de tu equipo.

Actualiza los repositorios de yum:

[root@bash]$ yum update

Reinicia tu equipo:

[root@bash]$ reboot

Instala FedUp, el hará todo el trabajo por nosotros:

[root@bash]$ yum install fedup

Empieza el proceso de actualización a Fedora 21:

[root@bash]fedup-cli --network 21 --debuglog /root/fedup-20to21.log

Revisa errores en /root/fedup-20to21.log, existe una opción por si actualizas desde una distro con un entorno como mate o alternativo. Funciona también sin problemas.

Puedes habilitar diferentes repos con la siguiente opción:

--enablerepo REPO

Reinicia de nuevo tu equipo:

[root@bash]$ reboot

En el grub del menú, entra con FedUp:
Grup FedUp

Esto tardará bastante y realizará toda la actualización de nuestro equipo a Fedora 21, después podremos iniciar sesión en Fedora 21 y continuar como siempre.

Noviembre 11th, 2014

Redireccionar una url

Cuando vamos a cambiar el contenido de nuestro dominio a otra dirección, es importante indicar este cambio. De esta forma, tanto los motores de búsqueda como los propios usuarios podrán seguir encontrando la información que desean.
Hay varios métodos para hacer una redirección:
Método 1, HTML:

<meta http-equiv="acción" content="segundos";
                       url="http://www.neleste.com/nuevaruta" />

Método 2. PHP (para este método, es imprescindible no haber escrito html antes, esto cambiaría las cabeceras del documento):

<?php header ("Location: http://www.neleste.com/nuevaruta"); ?>

Método 3. JavaScript:

<script type="text/javascript">
window.locationf="http://www.neleste.com/nuevaruta";
</script>

Método 4. editar .htaccess (gracias por recordarlo Emilio):
Este método también se puede hacer en los archivos de configuración de apache si tenemos acceso

Redirect /viejaruta/ http://neleste.com/nuevaruta/

Octubre 13th, 2014

Comandos de Vi o Vim

Cuando estamos por consola en un servidor y no podemos usar nuestra interfaz gráfica favorita, Vi o Vim (Vi Mejorado) se convierten en una herramienta indispensable.
Vim, hace un consumo de memoría excelente, y si conocemos todos los comandos para navegar con él, pronto nos resultará bastante atractivo.

Lo que más nos choca cuando nos iniciamos en vim, es que tengas que cambiar entre diferentes modos. El hecho de que exista un modo para escibir, es lo que hace que puedan existir confusiones al usarlo.

Sin embargo, cuando los dominas, son una de las grandes bondades del programa.
Aunque una vez los dominamos, nos encontramos con que es uno de los mejores beneficios del programa.

Modo comandos: aparece por defecto. En este modo podremos efectuar acciones como copiar/pegar y formatear el texto. Desde cualquier modo se puede acceder a él pulsando dos veces la tecla ESC.
Modo inserción: todo lo que teclee aparecerá en pantalla y se convertirá en parte integrante de su buffer de archivo.
Modo ex: para grabar un archivo o abrir otro y operaciones relacionadas.
Modo visual: permite cortar, copiar y pegar expeditivamente grandes porciones de texto mediante teclado o ratón.
Como la interfaz se basa en consola, la interacción con el teclado es vital. Veamos para qué sirve cada tecla, dividiendo su funcionalidad en grupos.

Movimiento del cursor

h: mover izquierda
j: mover abajo
k: mover arriba
l: mover derecha
w: salta de palabra en palabra al comienzo de las mismas
    (la puntuación es considerada palabra)
W: salta de palabra en palabra (al espacio entre ellas)
e: salta de palabra en palabra al final de las mismas
    (la puntuación es considerada palabra)
E: salta al final de las palabra (sin considerar puntuación)
b: salta hacia atrás entre palabras (considerando la puntuación)
B: salta hacia atrás entre palabras (sin considerar puntuación)
0: al comienzo de la línea
^: primer carácter no blanco de la línea
$: final de la línea
G: comando ir a

Modo inserción (insertando/añadiendo texto)

i: empieza modo inserción donde está el cursor
I: empieza modo inserción al comienzo de la línea
a: añade donde está el cursor
A: añade al final de línea
o: añade nueva línea en blanco, bajo la línea actual
O: añade nueva línea en blanco, sobre la línea actual
ea: añade al final de la palabra
Esc: sale del modo

Edición

r: reemplaza un único carácter
J: une la línea de abajo con la actual
cc: reemplaza una línea entera
cw: reemplaza hasta el final de la palabra
c$: reemplaza hasta el final de la línea
s: borra el carácter que indica el cursor y substituye el texto
S: borra la línea y substituye el texto (lo mismo que cc)
xp: transpone dos letras (primero corta, luego pega)
u: deshace (undo)
.: repite el último comando

Marcando texto (modo visual)

v: comenzar modo visual
V: comenzar modo visual lineal
o: moverse a otra área marcada
Control+v: comenzar bloque de modo visual
O: moverse a la esquina de otro bloque marcado
aw: marcar una palabra
ab: marca un bloque delimitado por paréntesis (del inglés braces)
aB: marca un bloque delimitado por llaves (del inglés brackets)
ib: marca dentro de un bloque delimitado por paréntesis
iB: marca dentro de un bloque delimitado por llaves
Esc: salir del modo visual

Comandos visuales

>: corre el texto hacia la derecha
<: corre el texto hacia la izquierda
y: copia el texto marcado
d: borra el texto marcado

Cortar y pegar

yy: copia una línea
2yy: copia dos líneas
yw: copia una palabra
y$: copia hasta el final de la línea
p: copia el contenido del portapapeles, tras el cursor
P: ídem pero antes del cursor
dd: borra una línea
dw: borra una palabra
x: corta el carácter actual

Salir
Todas llevan dos puntos al comienzo, los del final son de separación pero no del comando en sí. Esto mismo pasará en los siguientes apartados.

:w: guarda el fichero pero no sale
:wq: guarda el fichero y sale
:q: intenta salir. Si hay cambios da error, en caso contrario, sale
:q!: sale sin guardas y aunque haya habido cambios

Buscar y reemplazar

/pattern: busca un patrón
?pattern: busca un patrón hacia atrás
n: repite la búsqueda en la misma dirección
N: repite la búsqueda en la dirección opuesta
:%s/viejo/nuevo/g: reemplaza todo lo que encuentra definido
    por “viejo” por “nuevo”
:%s/viejo/nuevo/gc: lo mismo, pero con confirmaciones

Trabajar con múltiples ficheros

:e nombreFichero: edita un fichero en un nuevo buffer
:bnext (o :bn): se dirige al siguiente buffer
:bprev (o :bp): se dirige al bufer anterior
:bd: borra un buffer
:sp nombreFichero: abre un fichero en un nuevo buffer y lo divide
Control+ws: divide la ventana
Control+ww: intercambia la ventana
Control+wq: cierra una ventana
Control+wv: divide la ventana horizontalmente

Septiembre 17th, 2013

Importar/Exportar tablas de bbdd PostgreSQL

Para realizar esto, hay dos métodos, crear un dump, o crear un archivo sql ejecutable. Es preferible esta segunda opción, puesto que la primera puede dar problemas por la versión de PostgreSQL que tengamos instalada. Veamos a continuación los dos métodos:

Mediante un dump:

#Creamos el archivo dump
pg_dump -Fc -t nombre_tabla nombre_bbdd_origen -f /direccion_destino.dump
#Restauramos el archivo dump
pg_restore -t nombre_tabla -d nombre_bbdd_destino /direccion_destino.dump

Mediante un .sql:

#Creamos el archivo .sql
pg_dump nombre_bbdd_origen -t nombre_tabla > /direccion_destino.sql
#Ahora dentro del cliente pgsql (yo uso este, pero puedes usar otro método)
\i /direccion_destino.sql



Si suprimimos el parámetros -t nombre_tabla, podremos volcar la bbdd completa.

Enero 29th, 2011

FATAL: Ident authentication failed for user XXXXX

He instalado postgres en un servidor CentOS, luego he creado el usuario, contraseña y bbbdd. Pero si me intento conectar por PHP, shell o navicat usando la siguiente sintaxis:

psql -d mibbdd -U usuario -W 

Me devuelve el siguinte error:

psql: FATAL: Ident authentication failed for user "username"

¿Como corregir este error?
Abrimos el fichero de configuración de postgres: /var/lib/pgsql/data/pg_hba.conf :

# vi /var/lib/pgsql/data/pg_hba.conf

El fichero controla

  1. Desde que host se permite conectar.
  2. Que clientes están autentificados.
  3. Que usuario the postgres pueden usar.
  4. A qué BBDD pueden acceder

Por defecto, PostgreSQL usa autentificación basada en IDENT. Todo lo que debes hacer es permitir al usuario y contraseña que utilizas para tu conexión. IDENT nunca permitirá que entres a través de las opciones -U y -W. Concatena el permiso al fichero para que puedan entrar todos los usuarios del localhost.

local	all	all	trust
host	all	127.0.0.1/32	trust

Guarda y cierra el fichero, luego restaura el servicio postgreSQL:

# service postgresql restart

Ahora, deberías ser capaz de entrar usando el comando:

# psql -d myDb -U username -W

Julio 27th, 2010

Módelo Vista Controlador y algunas variantes

Flex es un framework creado para poder llegar a usar otros frameworks. Nos centraremos en este artículo en la base de otros frameworks, como PureMVC o Cairngorm, esta característica es el patrón Módelo Vista Controlador (MVC). Analizaremos este patrón que tanto nos gusta y entonces veremos algunas otras aproximaciones para compararlas y adjuntaré proyectos de ejemplo para entender el concepto que representa cada uno.

Módelo Vista Controlador (MVC)

El Módelo Vista Controlador es el patrón arquitectural más usado en la ingeniería del software. Este patrón nos separa el modelos de datos, el modelo de la capa de presentación (vista) y de la parte de control.

De este modelo podemos decir, que gestiona la información y advierte a las otras capas de cambios en sus datos. Representa el dominio de datos. La vista representa gráficamente el modelo para que el usuario pueda interactuar él, es la interfaz de datos. El controlador recibe las peticiones de la vista y le responde actualizando el modelo de datos. Debido a que la vista observa los cambios en el modelo de datos, esta actualiza sus componentes en función de éstos.

La finalidad de este patrón será la de conseguir un bajo acoplamiento en sus aplicaciones. Este lo logra desacoplando los modelos de las vistas, reduce la complejidad en el diseño arquitectural e incrementando la flexbilidad y mantenimiento del código.

La aplicación para el ejemplo será esta:

Módelo Vista Presentación (MVP)

Módelo Vista Presentación

Este patrón es un derivado del anterior. Está centrado en la interfaz de usuario y también pensado para facilitar el la unidad de testeo y mejorar la separación conceptos en la presentación de la lógica del programa. Genera una implementación limipia del patrón Observer entre el modelo y la vista.

El modelo funciona como una interface que define los datos que serán mostrados luego en la vista. La vista es una interface que nos muestra los datos del modelo y lanza llamadas a la capa presentacion para que luego actúe con los datos. La presentacion recupera los datos del modelo y los modera y hacia la vista.

Normalmente, la vista instancia su objecto presentacion con el que se relacionará y luego le proporciona una referencia suya.
El grado de lógica permitida en las vistas variara en función de la implementación que usemos: podremos hacer que la vista sea totalmente pasiva, alegando todas las operaciones a la presentacion. Otras versiones del MVP nos permiten más autonomía a la vista.

Si nos centramos en un punto de vista de capas, la presentacion se consideraría la capa de aplicación entre el modelo y la vista.

El creador del patrón MVP, Martin Fowler, decidió separarlo en dos patrones de presentación que ya hemos tratado en madeinflex, son el supervising presenter y el passive view.

MVC vs MVP

Los une la idea de que el modelo alberga los datos y la vista los representa. Tanto el controller como el presenter se encargan de coordinar la aplicación y es en estas clases donde está la diferencia: el Presenter tiene más responsabilidades, maneja los datos del modelo y trata las propiedades de la vista que recibirá como parámetro.

Modelo Vista Adaptación (MVA)

Como en los dos patrones anteriores, se pretende separar el modelo de datos de la vista para poder realizar cambios en la vista y que estos no afecten al modelo de datos.

MVA y MVC intentan solucionar este problema con dos aproximaciones diferentes:

  • MVC mantiene un estructura triangular entre el modelo, la vista y el controller, en la cual las tres entidades serían los vértices del triángulo y las aristas las vías de comunicación entre éstas.
  • MVA lo soluciona de otra forma, lo hace mediante una estructura lineal en la cual en una punta estará la vista, en la otra el modelo y en el centro el adapter o mediating controller, pero se evita la comunicación directa entre la vista y el modelo.

Así pués, en este modelo, la vista está totalmente separada del modelo de datos y estas entidades sólo se pueden comunicar a través el adapter, dicho de otro modo, sólo el adapter tiene conocimiento del modelo y de la vista.

Con esta separación de comportamientos, conseguiremos que una amplia variedad de vistas puedan acceder indirectamente al modelo de datos mediante el mismo adapter. Las vistas también se olvidan del modelo de datos, ya que es el adapter quien las comunica con éste.

Esto también nos permite poder usar diferentes adapters para cada par vista / modelo. Un ejemplo podría ser la aplicación de una entidad bancaria, para cada una de sus delegaciones, puede ser que con los mismos datos y la misma vista se tengan que manipular los datos de maneras diferentes, para eso podremos tener diferentes adapters sin tener que modificar ni la vista ni el modelo de los datos.

MVA también es conocido como “mediating-controller”. Hay quien cree que como base sigue la misma idea que MVP, aunque hay gurús del software que se matan y defienden diferencias entre ellos.

Aquí os dejo un enlace de un proyecto de ejemplo para que podais analizarlo vosotros mismos.

Autor: Sergi Dote Teixidor

Abril 10th, 2010

Optimizando nuestro código PHP

1 – Inicializa las variables antes de utilizarlas. Estás, se inicializan solas, pero con un coste de tiempo.

2 – Debes estar en constante aprendizaje, cada vez el lenguage PHP se hace más fuerte, y salen nuevas características interesantes sobre este..

3 – Incrementar una variable en el método de una clase es lo mas rápido, que incrementar una variable global.

4 – Incrementar una variable global a un fichero puede llegar a ser hasta dos veces más lento que en un entorno local.

5 – Incrementar una variable local en un método es lo más rápido. Casi lo mismo que llamar a una variable local en una función.

6 – Incrementar una variable indefinida puede ser hasta 9 ó 10 veces más lento que una ya declarada.

7 – Declarar una variable global, a pesar de que no la llegues a utilizar en ninguna función hace más lento tu script, PHP tiene que chequear si la variable existe.

8 – Llamar a una función a una función con un parametro puede tomar aproximadamente el mismo tiempo que de 7 a 8 operaciones con variables locales, y esa misma llamada a un método supondrían unas 15 operaciones. Aún así, es más rapido que usar variables globales.

9 – Si necesitas saber el timestamp (tiempo de ejecución) de acceso a un script, considera utilizar la variable $_SERVER['REQUEST_TIME'] en lugar de time(), es mucho más rapido.

10 – $row['id'] es hasta 7 veces más rápido que el mecanismo $row[id].

11 – $localvar++ es hasta 15 veces más rápido que function inc(){ $localvar++; }, debido a que debe acceder a la función.

12 – Los scripts PHP se compilan/interpretan cada vez que son ejecutados, a no ser se guarde el código objeto en un cache. Las herramientas de compilación de PHP pueden incrementan el rendimiento hasta un 100%.

Febrero 20th, 2010

Validar ccc con PHP

Identificación de una cuenta corriente o libreta de ahorros
En España las cuentas corrientes y las libretas de ahorros tienen una identidad única que se compone de 20 dígitos, el denominado Código Cuenta Cliente. Este código identifica a la entidad bancaria, sucursal y cuenta de forma única de tal modo que actúa como dirección de la cuenta para la realización de cualquier operación financiera.

Esquema del código de identificación de una cuenta bancaria

esquema ccc

Proceso de cálculo de los dígitos de control
a) Dígito de control de la entidad y sucursal

Posicion Factor Datos Operación Resultado
Unidad: 6 8 6×8 48
Decena: 3 3 3×3 9
Centena: 7 3 7×3 21
Unidad de millar: 9 0 9×0 0
Decena de millar: 10 7 10×7 70
Centena de millar: 5 7 5×7 35
Unidad de millón: 8 0 8×0 0
Decena de millón: 4 2 4×2 8
Suma 191

Cálculos:

191/11 = 17; Resto = 191-(17×11) = 4; Dígito = 11-4 = 7

- Si el resultado es 11, el dígito buscado es 0

- Si el resultado es 10, el dígito buscado es 1

b) Dígito de control de la cuenta

Posicion Factor Datos Operación Resultado
Unidad: 6 1 6×1 6
Decena: 3 2 3×2 6
Centena: 7 3 7×3 21
Unidad de millar: 9 4 9×4 36
Decena de millar: 10 5 10×5 50
Centena de millar: 5 2 5×2 10
Unidad de millón: 8 0 8×0 0
Decena de millón: 4 0 4×0 0
Centena de millón: 2 1 2×1 2
Unidad de millar de millón: 1 3 1×3 3
Suma 134

Cálculos:

134/11 = 12; Resto = 191-(12×11) = 2; Dígito = 11-2 = 9

- Si el resultado es 11, el dígito buscado es 0

- Si el resultado es 10, el dígito buscado es 1
A continuación, implementaremos el algoritmo en php

function ccc_valido($ccc)
{
    //$ccc sería el 20770338793100254321
    $valido = true;

    ///////////////////////////////////////////////////
    //    Dígito de control de la entidad y sucursal:
    //Se multiplica cada dígito por su factor de peso
    ///////////////////////////////////////////////////
    $suma = 0;
    $suma += $ccc[0] * 4;
    $suma += $ccc[1] * 8;
    $suma += $ccc[2] * 5;
    $suma += $ccc[3] * 10;
    $suma += $ccc[4] * 9;
    $suma += $ccc[5] * 7;
    $suma += $ccc[6] * 3;
    $suma += $ccc[7] * 6;

    $division = floor($suma/11);
    $resto    = $suma - ($division  * 11);
    $primer_digito_control = 11 - $resto;
    if($primer_digito_control == 11)
        $primer_digito_control = 0;

    if($primer_digito_control == 10)
        $primer_digito_control = 1;

    if($primer_digito_control != $ccc[8])
        $valido = false;

    ///////////////////////////////////////////////////
    //            Dígito de control de la cuenta:
    ///////////////////////////////////////////////////
    $suma = 0;
    $suma += $ccc[10] * 1;
    $suma += $ccc[11] * 2;
    $suma += $ccc[12] * 4;
    $suma += $ccc[13] * 8;
    $suma += $ccc[14] * 5;
    $suma += $ccc[15] * 10;
    $suma += $ccc[16] * 9;
    $suma += $ccc[17] * 7;
    $suma += $ccc[18] * 3;
    $suma += $ccc[19] * 6;

    $division = floor($suma/11);
    $resto = $suma-($division  * 11);
    $segundo_digito_control = 11- $resto;

    if($segundo_digito_control == 11)
        $segundo_digito_control = 0;
    if($segundo_digito_control == 10)
        $segundo_digito_control = 1;

    if($segundo_digito_control != $ccc[9])
        $valido = false;

    return $valido;
}

Enero 29th, 2009

Buscar y Reemplazar en Linux

Esta es una instrucción sencilla que quería compartir, y es que muchas veces me ha salvado incluso la vida, o por lo menos me ha quitado un dolor de cabeza, puesto que cambiar una palabra en un fichero es fácil, pero cuando se tratan de 100 ficheros…

grep -rlZ 'textoareemplazar' /ruta/ | xargs -r0 perl -pi
-e 's/textoareemplazar/textonuevo/g'

Sirve sobre todo en servidores con mucha “morralla histórica” en la que queramos cambiar una frase/instrucción que se repite. Eso si, cuidado con su uso, si reemplazamos algo que no debemos podemos tener un caos!

Octubre 17th, 2008

Cajas de Igoogle

Llevo bastante tiempo intentando lograr hacer el efecto de arrastrar y soltar de las cajas de igoogle, hay poquísima información en la red respecto a cómo se consigue crear este efecto, a pesar de que es algo muy interesante a nivel de diseño.

Cajas Igoogle

¿Como he conseguido lograr el efecto? La base de todo es la clase prototype que podeis descargar desde ese link. Prototype es un framework hecho en JavaScript que se sirve para ayudar a un desarrollo sencillo y dinámico de aplicaciones web (como cualquier framework) con el uso de técnicas Ajax.
Luego mediante CSS, y definiendo las capas en el init() de javascript (se encuentr todo en el fichero index.html) podremos adaptarlo como queramos.

Enlaces |DemoPrototype