martes, 9 de abril de 2013

SQL Server - Resolver "Cannot resolve the collation conflict"


En una consulta que tuve que hacer en una base de datos SQL Server, tuve un pequeño conflicto, al hacer un join, primero me aparecio el problema que eran tipos de datos diferente, al solucionarlo, me aparecio el problema
“Cannot resolve the collation conflict between "Modern_Spanish_CI_AS" and "SQL_Latin1_General_CP1_CI_AS" in the equal to operation.”
Para resolver esto, simplemente debemos añadir COLLATE [insert required collation name], por ejemplo, yo tenía
CONVERT(tabla1.campo1 AS VARCHAR(64)) = tabla2.campo2
Por lo que lo deje así:
CAST(tabla1.campo1 AS VARCHAR(64)) = tabla2.campo2 COLLATE Modern_Spanish_CI_AS
y simplemente con esto, se logró solucionar el problema

martes, 2 de abril de 2013

PHP - Pasar variables sin usar form


La verdad es que este es un tema sumamente sencillo, uno siempre tiende a pensar en lo complejo, por lo que buscamos una solución sencilla. Para pasar variables sin usar un formulario, simplemente lo hacemos a través de GET, como bien sabemos, GET permite pasar variables a través de URL’s, por lo cual simplemente le damos los valores pertinentes. Por ejemplo:

Hoja 1: index.php



    
    Prueba Variables

    
    Abril 2013

Hoja 2: imprimir.php


En la primera hoja (index.php) tenemos una estructura HTML, en la cual está el tag <a > el cual nos redirecciona a la hoja imprimir.php, la diferencia está en que aquí les pasamos las variables que nosotros deseamos.

En el caso de la hoja 2 (imprimir.php), recepcionamos las variables en otras variables ($ano y $mes) y luego las imprimimos con echo, claro está, que si queremos, podemos imprimirlas directamente.

jueves, 21 de marzo de 2013

Conexión PHP - MongoDB



Lo primero es instalar el driver para que podamos hacer la conexión, para lo cual hacemos lo siguiente:

$ sudo yum install php-devel

$ sudo pecl install mongo


Entramos a nuestro php.ini

$ sudo nano /etc/php.ini


Al final del fichero, ingresamos la siguiente línea:

extension=mongo.so


Si tenemos problemas de permiso denegado (RedHat, CentOS, Fedora) debemos aplicar lo siguiente:

$ /usr/sbin/setsebool -P httpd_can_network_connect 1


Ahora creamos un fichero de prueba para probar la conexión de MongoDB con PHP

$ sudo nano testmongodb.php


Dentro de este fichero, copiamos lo siguiente:

 
comedy;

// select a collection (analogous to a relational database's table)
$collection = $db->cartoons;

// add a record
$document = array( "title" => "Calvin and Hobbes", "author" => "Bill Watterson" );
$collection->insert($document);

// add another record, with a different "shape"
$document = array( "title" => "XKCD", "online" => true );
$collection->insert($document);

// find everything in the collection
$cursor = $collection->find();

// iterate through the results
foreach ($cursor as $document) {
    echo $document["title"] . "\n";
}
?>

Finalmente, corremos el fichero PHP desde consola

 $ php testmongodb.php


MongoDB - Introducción



¿Qué es MongoDB?

MongoDB, recibe su nombre de la palabra "humongous", es un sistema de base de datos NoSQL orientado a documentos, open source y multiplataforma, escrito en C++.  Al ser NoSQL, MongoDB no guarda los datos en tablas, como lo hacen las base de datos relacionales, sino, que guarda los datos en estructuras de documentos JSON. Esta base de datos nos ofrece un alto rendimiento, alta disponibilidad, y fácil escalabilidad.

Una característica que me pareció bastante interesante es que MongoDB tiene la capacidad de realizar consultas utilizando JavaScript, haciendo que estas sean enviadas directamente a la base de datos para ser ejecutadas.



MongoDB presenta drivers oficiales para:

C
C++
C# / .NET
Erlang
Haskell
Java
JavaScript
Lisp
node.JS
Perl
PHP
Python
Ruby
Scala

Terminología

El sitio web oficial de MongoDB nos presenta una similitud de terminologías o conceptos en relación con SQL



Instalación de MongoDB

Instalación en RedHat, CentOS, Fedora

Lo primero que debemos hacer es crear (con permisos de administración) el fichero 10gen.repo, para eso:

$ sudo vi /etc/yum.repos.d/10gen.repo

Dentro de este fichero debemos colocar lo siguiente:

[10gen
name=10gen Repository
baseurl=http://downloads-distro.mongodb.org/repo/redhat/os/
gpgcheck=0
enabled=1

en Donde <ARCH> es x86_64 ó i686, dependiendo de nuestra arquitectura. Luego simplemente instalamos MongoDB

$ sudo yum install mongo-10gen mongo-10gen-server


Debian

Lo primero que debemos hacer, es ver el tema de la llave, para eso:

$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10

Luego de eso, agregamos el repositorio necesario, para lo cual editamos el fichero sources.list
$ sudo nano /etc/apt/sources.list

Ahora agregamos lo siguiente:

deb http://downloads-distro.mongodb.org/repo/debian-sysvinit dist 10gen

Para que Debian nos reconozca el repositorio agregado, debemos actualizar

$ sudo apt-get update

Finalmente instalamos

$ sudo apt-get install mongodb-10gen


Agregando puertos al firewall

Debemos agregar el puerto de trabajo de MongoDB, para eso debemos editar el fichero de iptables, para eso:

$ sudo nano /etc/sysconfig/iptables

Dentro de este, al final del fichero pegamos:

-A INPUT -m state --state NEW -m tcp -p tcp --dport 27017 -j ACCEPT

Ahora reiniciamos el servicio de iptables

service iptables restart


Primeros pasos en MongoDB

Ahora en consola escribimos mongo

$ mongo

y entramos a la consola de MongoDB, aquí podemos listar las base de datos

 >show dbs

Para crear o seleccionar una base de datos a trabajar:

 >use 

Listar los collections de esta base de datos
 >show collections

Para insertar los datos, hacemos algo como lo siguiente:

 >db.test.insert({texto: "HOLA MUNDO!"})

Y para buscar los datos ocupamos find()

 >db.test.find()


lunes, 18 de febrero de 2013

Cambiar zona horaria en RedHat/CentOS 6.x


Para cambiar la zona horaria, lo primero que debemos hacer es editar el siguiente fichero:

# nano /etc/sysconfig/clock

Nos encontraremos con algo parecido a:

ZONE="America/New_York"
UTC=True

Lo que debemos hacer es cambiar la ZONE por la que nosotros necesitemos, para saber las disponibles, simplemente:

# ls -l /usr/share/zoneinfo

Una vez sabido lo modificamos. Ya modificado, debemos hacer un enlace simbólico, por ejemplo, aquí haremos un enlace simbólico de Buenos Aires al localtime.

# ln -sf /usr/share/zoneinfo/America/Buenos_Aires /etc/localtime

Echo esto, comprobamos que la hora esté correcta con el comando date.

# date
Thu Nov  8 10:26:25 ART 2012

domingo, 11 de noviembre de 2012

Habilitar User/Group para cada VirtualHost

Para realizar esto, debemos utilizar mpm-itk, el cual lo podemos instalar desde los repositorios
# yum install httpd-itk
Una vez hecho esto,  editamos a nuestro VirtualHost, por ejemplo: mivh
# nano /etc/httpd/conf.d/mivh
Ahora, dentro del bloque <VirtualHost *:80></VirtualHost > debemos agregar lo siguiente:
<IfModule mpm_itk_module>   AssignUserId <UserName> <GroupName></IfModule>

*No olvidar agregar el Include correspondiente en /etc/httpd/conf/httpd.conf*

Ahora debemos editar:
# nano /etc/sysconfig/httpd
Y agregar la siguiente línea:
HTTPD=/usr/sbin/httpd.itk
Esto puede generar un conflicto con php, para esto debemos editar:
# nano /etc/httpd/conf.d/php.conf
Y modificar esto:
<IfModule prefork.c>   LoadModule php5_module modules/libphp5.so</IfModule>
Por:
LoadModule php5_module modules/libphp5.so
Luego debemos reiniciar Apache
# sudo service httpd restart
Y listo, debiese cargar el usuario definido, cabe considerar que el dueño de la carpeta a trabajar, debe ser el mismo que especificamos con la variable AssignUserID, lo podemos hacer de la siguiente forma:
# chown UserName:GroupName /path/to/webroot

domingo, 30 de septiembre de 2012

Controlar reproductores en Linux desde Android

Hoy quería darme un relajo mental y dedicarme a descansar escuchando música, pero tenía un inconveniente, tengo mi laptop conectado a un subwoofer que no posee control remoto y lo que yo quería era estar acostado relajado escuchando música, entonces pensé ¿que hago?, simple! ya debe un app en Android que me solucione este problema, probe un par de aplicaciones sin que ninguna me convenciera al 100%, hasta que llegue a Remuco.

La verdad la encontré una app fantástica, al meno cumple a la perfección lo que yo quería, entre sus características están:
  • Funciona tipocliente-servidor a través de bluetooth o wifi.
  • Soporta los reproductores Amarok, Audacious, Banshee, Clementine, Exaile, gmusicbrowser, MPD, MPlayer, Rhythmbox, Songbird, Totem, TVtime, VLC y XMMS2.
  • Permite subir y bajar volumen de la música.
  • Permite elegir reproducción aleatoria.
  • Permite elegir repetir lista al finalizar la reproducción.
  • Visualiza la carátula (si es que está disponible).
  • Permite retroceder, adelantar, reproducir, pausar (casi obvio)
Quizás tiene más características, pero al menos con lo poco que lo probe, eso pude destacar, además fue lo que noté a simple vista.

Ahora que ya sabemos que es, comencemos el proceso de instalación, para eso en primer lugar debemos descargar Remuco:
$ wget http://remuco.googlecode.com/files/remuco-0.9.6.tar.gz
Nos descargará un fichero comprimido (tar.gz) por lo que procedemos a descomprimir:
$ tar xvf remuco-0.9.6.tar.gz
Nos creará un directorio nuevo (remuco-0.9.6), al menos para mi, me es más cómodo dejarlo como oculto, ya que terminado los pasos no ingresaré más al directorio, para esto debemos agregarle un punto “.” antes del nombre (para listar los ficheros ocultos realizamos un ls -a)
$ mv remuco-0.9.6 .remuco-0.9.6
Ahora ingresamos al directorio
$ cd .remuco-0.9.6
Ya estando en el directorio instalamos lo que necesitemos reproducir, pero antes de eso, saber que tenemos las dependecias instaladas (al menos yo no necesite hacerlo, pero nunca está demás), por lo que:
$ sudo aptitude install python-bluez
Ahora si, nos falta solamente elegir el reproductor a controlar, tienen todas estas opciones según su reproductor
$ sudo make install-amarok
$ sudo make install-amarok14
$ sudo make install-audacious
$ sudo make install-banshee
$ sudo make install-clementine
$ sudo make install-exaile
$ sudo make install-fooplay
$ sudo make install-gmusicbrowser
$ sudo make install-mpd
$ sudo make install-mplayer
$ sudo make install-okular
$ sudo make install-quodlibet
$ sudo make install-rhythmbox
$ sudo make install-songbird
$ sudo make install-totem
$ sudo make install-tvtime
$ sudo make install-vlc
$ sudo make install-xmms2
En mi caso estoy utilizando solo clementine, por lo que en la terminal ejecute:
$ sudo make install-clementine
Al hacer esto, ya tenemos listo el la fase del computador, por lo que (en mi caso) simplemente inicio el proceso con:
$ remuco-clementine
Obviamente esto varía según lo que hayamos instalado. Puede ser que les salga un error al ejecutarlo, parecido a esto:
ERROR: failed to set up bluetooth server ((2, 'No such file or directory')) (check the log for details)
Pero esto simplemente es porque nuestra laptop no tiene habilitado o simplemente no posee bluetooth. Ahora simplemente abrimos nuestro reproductor.

Por último debemos instalar el cliente en Android, para eso nos vamos al directorio
$ cd .remuco-0.9.6/client/android/app
y encontraremos un fichero llamado remuco.apk, el cual copiamos al Android, antes de instalarlo debemos “Origenes Desconocidos” dentro del menu Ajustes > Aplicaciones. Si está activado, simplemente lo instalamos.

Ahora abrimos la aplicación remuco apretamos el botón menú y luego “Connect” aquí elegimos si queremos la conexión por bluetooth o wifi, en mi caso por wifi así que ingresamos la ip del equipo y listo, empezamos a reproducir sin problemas.

jueves, 27 de septiembre de 2012

Debian - Configurando servidor DHCP

En palabras sencillas, al tener un servidor DHCP lo que hacemos es entregar direcciones IP a distintos dispositivos que contengan una conexión a Internet, ya sea por alámbrica o inalámbricamente. Del mismo modo, puedo hacer que este dispositivo que tenga asignada una dirección IP por defecto por lo que podemos segmentar más nuestra red e ir organizándose. Otra ventaja que posee montar un servidor DHCP es justamente el hecho de que tenemos una infinidad de posibles variables, una de ellas, es que por ejemplo podemos definir cuántas direcciones asignaremos dinámicamente, es decir, definir un pool de direcciones.

Esto lo quiero tomar como un laboratorio, para llevarlo a cabo pueden montar 2 máquinas virtuales, yo usaré Virtualbox, una máquina virtual la ocuparemos como Servidor (obviamente Debian) y la otra puede ser cualquier distribución, en mi caso lo haré con un CentOS 6 minimal.

En el caso del servidor, creamos la máquina virtual, luego vamos a la configuración de la máquina virtual, vamos a red y creamos una interfaz en modo bridge (puente) y otra interfaz en modo intnet (red interna). En el caso del cliente sólo creamos una interfaz en modo intnet (red interna). Ahora instalamos el sistema operativo normalmente.

La configuración la haremos todo en el servidor, lo primero que debemos hacer es configurar nuestras interfaces de red, para esto editamos el fichero de configuración con nuestro editor de texto, en este caso con nano:

# nano /etc/network/interfaces

Aquí debemos configurar nuestras 2 interfaces de red, lo que haremos es que nuestra interfaz, la configuración eth0 la dejaremos como DHCP ya que este recibirá directamente la dirección IP, en cambio nuestra eth1 la dejaremos como interfaz estática, para esto dentro del fichero debemos configurarlo de forma parecida a esto:
#loopback
auto lo
iface lo inet loopback

#eth0
auto eth0
iface eth0 inet dhcp

#eth1
auto eth1
iface eth1 inet static
        address 192.168.0.1
        netmask 255.255.255.0
        network 192.168.0.0

  • Al agregar auto <interfaz> lo que hacemos es indicar que esa interfaz se levante automáticamente.
  • La palabra iface es para indicar la configuración de la interfaz asociada.
  • Para configurar una interfaz en DHCP, simplemente escribimos iface <interfaz> inet dhcp
  • Para configurar una interfaz en modo estático, simplemente escribimos iface <interfaz> inet static, seguido de esto escribimos address que es la dirección IP que tendrá la interfaz, netmask que es la máscara de red y network, que es el segmento al cual pertenece. Tenemos más configuraciones, pero está configuración mínima sirve para para el ejemplo.
  • Tenemos que tener en cuenta el segmento de nuestra eth0 y eth1, ya que no deben ser el mismo, por ejemplo, si nuestra eth0 recibe el segment0 192.168.1.0, nuestra eth1 puede ser cualquier segmento menos el de la eth0.
Una vez configuradas nuestras interfaces de red, hacemos lo siguiente:

# service networking restart && ifup eth0 && dhclient eth0 && ifup eth1

Con hacer un ifconfig podemos ver la configuración de nuestras interfaces, seguido de esto, instalamos los servicios necesarios:

# aptitude install dhcp3-server isc-dhcp-server

Ahora comienza la configuración, primero:

# nano /etc/default/isc-dhcp-server

Aquí encontraremos una línea que dice INTERFACES="", lo que debemos hacer es indicar la interfaz que repartirá las direcciones DHCP, en nuestro caso es la interfaz eth1, por lo que nos quedaría INTERFACES="eth1"

Ahora debemos configurar el último fichero de configuración, pero antes como medida de precaución, hacemos una copia de seguridad de nuestro fichero:

# cp /etc/dhcp/dhcpd.conf /etc/dhcp/dhcpd.conf.original

Ya con nuestra copia de seguridad hecha, lo primero que haremos será vaciar el fichero para que sólo tenga nuestra configuración

# cat /dev/null > /etc/dhcp/dhcpd.conf

Ahora si, finalmente, configuramos:

# nano /etc/dhcp/dhcpd.conf

Aquí agregaremos una configuración mínima

authoritative;
ddns-update-style interim;
ignore client-updates;

subnet <segmento-red> netmask <máscara-red> {
  option routers                  <ip-gateway, este caso eth1>;
  option subnet-mask              <máscara-red-de-subred>;
  option domain-name              "<nombre-dominio-dns>";
  option domain-name-servers   <ip-dns>;
  option time-offset   -18000; 

  range dynamic-bootp 192.168.0.100 192.168.0.200;
  default-lease-time 600;
  max-lease-time 7200;
}

Un ejemplo según nuestra configuración sería:

authoritative;
ddns-update-style interim;
ignore client-updates;

subnet 192.168.0.0 netmask 255.255.255.0 {
  option routers                   192.168.0.1;
  option subnet-mask               255.255.255.0;
  option domain-name               "mired.cl";
  option domain-name-servers 192.168.0.1;
  option time-offset         -18000; 

  range dynamic-bootp 192.168.0.100 192.168.0.200;
  default-lease-time 600;
  max-lease-time 7200;
}

Como comentamos anteriormente, también podemos asignar ip estáticas, simplemente agregando lo otro segmento de configuración

host nombrecliente { 
hardware ethernet MAC; 
      fixed-address IP; 

Inclusive podemos hacer que los equipos que no estén en la lista, no puedan obtener una dirección IP gracias a:

deny unknown-clients;

Un ejemplo completo podría ser:

authoritative;
ddns-update-style interim;
ignore client-updates;

subnet 192.168.0.0 netmask 255.255.255.0 {
  option routers                   192.168.0.1;
  option subnet-mask               255.255.255.0;
  option domain-name               "mired.cl";
  option domain-name-servers 192.168.0.1;
  option time-offset         -18000; 

  range dynamic-bootp 192.168.0.100 192.168.0.200;
  default-lease-time 600;
  max-lease-time 7200;
}

deny unknown-clients;

host cliente {
        hardware ethernet 08:00:27:5B:C6:44;
        fixed-address 192.168.0.199;
}

Luego simplemente:

service dhcpd restart
chkconfig dhcpd on

Con lo que reiniciamos el servicio y hacemos que este inicie con el sistema.

martes, 25 de septiembre de 2012

SSH - Generar llave de confianza en solo 3 pasos


Cuando nos conectamos mediante ssh nos pide la contraseña del usuario para realizar con éxito la conexión, esto si bien es cierto es un grado de seguridad, puede resultarnos útil que a nuestra máquina no le pida la contraseña, esto se logra creando una relación de confianza, lo que hace es que nuestra máquina sea reconocida por la máquina remota como equipo de confianza y sólo a la máquina la deje ingresar sin contraseña, las demás les pedirá dicha contra.

El tutorial lo dividiré en 3 partes, la primera parte contendrá sólo las sintaxis, la segunda parte tendrá un ejemplo de conexión y la tercera parte será un bash script que podemos ejecutar para automatizar esto.

Primera parte - Sintaxis

PASO 1: Con nuestro usuario (no con root) debemos generar la key:

$ ssh-keygen

Aquí nos saldrá una serie de preguntas, simplemente apretamos enter y dejamos todo en blanco.

PASO 2: Copiar nuestra key pública al host remoto

$ ssh-copy-id -i ~/.ssh/<> <usuario>@<host remoto>

Luego de esto nos pedirá ingresar la contraseña del usuario remoto, la ingresamos y nos deberá aparecer un mensaje diciendo: “now try logging into the machine, with "ssh '<usuario>@<host>'" lo que significa que ya podemos loguearnos sin necesidad de la contraseña

PASO 3: Conectarse a la máquina remota por SSH

$ ssh <usuario>@<host>



Segunda parte - Ejemplo

Ejemplo 1

PASO 1: Con nuestro usuario (no con root) debemos generar la key:

$ ssh-keygen

PASO 2: Copiar nuestra key pública al host remoto

ssh-copy-id -i ~/.ssh/id_dsa.pub root@192.168.1.105

PASO 3: Conectarse a la máquina remota por SSH

ssh root@192.168.1.105


Ejemplo 2

PASO 1: Con nuestro usuario (no con root) debemos generar la key:

$ ssh-keygen -t id_dsa.pub -b 1024

PASO 2: Copiar nuestra key pública al host remoto

ssh-copy-id -i ~/.ssh/id_dsa.pub root@192.168.1.105

PASO 3: Conectarse a la máquina remota por SSH

ssh root@192.168.1.105


Como podemos darnos cuenta, en tan solo 3 pasos podemos generar una llave de confianza, tenemos que tener en cuenta que tipo de key hemos creado, ya que podemos crear una key dsa o una rsa, también podemos agregar opción como el -t para elegir el tipo (rsa o dsa) -b para ver la cantidad de bits, etc. Todo esto lo podemos ver en el manual haciendo

$ man ssh
$ man ssh-keygen
$ man ssh-copy-id



Tercera parte - Bash Script

Como amante de la línea de comandos y de Bash, debemos generar un Bash Script para generar una llave de confianza automatizada, aquí dejo el script.

#!/bin/bash
#
# author:       Nicolás Ormeño
# email:        ni.ormeno at gmail dot cl
# license:      GPL V3
# date:         2012-09-25
# description:  Script para generar llaves de confianzas SSH BASICAS!
#
read -p "Crear llave? (s/n) " key

if [ $key == s ]; then
       read -p "rsa o dsa? " type
       ssh-keygen -t $type
fi
read -p "ip del host: " host

ssh-copy-id -i ~/.ssh/id_dsa.pub root@$host

viernes, 21 de septiembre de 2012

Comando GCP, un CP mejorado

En Linux, como todos sabrán, para copiar ficheros por consola tenemos el comando cp, si bien es cierto funciona a la perfección, no nos detallada el progreso del fichero, normalmente esto no es problema, pero que pasa si queremos copiar un fichero de varios megas o gigas? esto se vuelve más complejo, ya que no sabemos cuanto deberemos esperar, para solucionar esto tenemos GCP, para instalarlo simplemente
# aptitude install gcp
Luego simplemente en vez de copiar con cp, copiamos con gcp, adjunto un screenshot para que vean su función



Algunas personas prefieren reemplazar cp por gcp, en mi caso no es así, ya que son comandos diferencias y no me cuesta nada trabajar con cp o agregarle una letra g y trabajar con gcp, en el caso que quieran hacerlo, deben hacer es crear el alias correspondiente.
echo "alias cp='gcp'" >> $HOME/.bashrc