Que es LaTeX

Es un lenguaje de marcado y de preparación de textos. Creado por Donal Knuth, el lenguaje TeX, fue después extendido, es decir se la añadieron un conjunto de macros, para hacer el TeX, mas fácil de usar para el usuario común. Estas fueron introducidas por Leslie Lamport y de ahí que ahora el lenguaje Tex extendido con las macros se llama .

LaTex es un lenguaje ampliamente usado en la comunidad científica, sobre todo para preparar documentos donde hay muchas formulas matemáticas. sin embargo aun cuando queramos hacer un escrito donde no haya matemáticas LaTeX es una muy buena opción pues podemos beneficiarnos de su gran calidad en el formato y en la facilidad con la que se pueden hacer documentos académicos, por ejemplo con un montón de citas bibliográficas.

Latex en GNU/Linux

Primero pretendía escribir una guía de como instalar y configurar correctamente LaTeX en Ubuntu. Pero me encontré que ya hay una excelente referencia en este blog, así que mejor pongo la cita. Y algunos tips

• Es ampliamente recomendable usar codificación utf-8, para todos tus documentos en LaTeX.
• En conjunto con el utf-8, e uso del paquete inputec y del paquete babel, para hacer los documentos en español de manera mas simple.
• En Linux no hay nada mejor que usar Kile (conste que lo digo yo, que no me gusta KDE), y ahora es muy fácil configurarlo para usarlo con GNOME.
• Nada mejor que tener correctamente configurado el KIle, es decir, sustituir los programas de KDE de visualización por sus respectivos en GNOME y el corrector ortográfico.
• Ampliamente recomendado instalar los extras, para que tengamos beamer.

Cosas extras

Una cosa bastante interesante es instalar el plugin para poder escribir LateX en wordpress, como comenté en un post pasado.
Nada mejor que poder instalar el plugin de LaTeX para Pidgin y así poder escribir y chatear a gusto con tus compas con un montón de matemáticas. (vaya que se oyo geek).
la instalación me fue mas o menos sencilla, make , sudo make install, ojo que debemos de tener instalado, tanto el Latex, como el Image Magick. Después de la instalación tuve problemas pues al parecer mi Image Magick se reusaba a convertir un .dvi en un .png, pero lo pude seleccionar agregando una linea al archivo de confguración de image magic como dice este post.

Bibliografía recomendada

Yo aprendí con este libro, pero honestamente creo que ya esta un poco pasado de moda, Laura me recomendó éste otro libro excelente, y además recuerden que la documentación oficial de LaTeX así como excelentes manuales-tutoriales, viene en los repositorios en los paquetes texlive-doc-base y texlive-doc-es. Así que no hay excusa además hay un montón de documentación en la red.

Al principio me gustó la idea, después de todo, traía fresco lo de la graficada y el programa parecía ser muy sencillo, le dije que solo preparara la recurrencia matemática y que después pasaría a ayudarle, después de una semana pase a verlo y como suele suceder no había hecho nada ni yo ni el, sin embargo el programa resulto ser lo bastante simple para que solo me llevara un par de horas terminarlo.

Pueden descargar el código aquí. Y para probar mis últimos dos plugines agregados al blog me decidí a escribir este post. los dos plugines de los que hablo son el WP-sintax que permite poner código de algún lenguaje de programación en tus post y el WP-LaTeX que agregar una fórmula escrita en LaTeX, (en forma de imagen) a tus post.

Copo de Koch

La primeras lineas solo incluyen las dos bibliotecas que vamos a usar, la primera es la glut estandar para levantar OpenGL y la otra es math.h, para hacer cálculos.

Veamos después de eso que hay:

6
7
8

typedef struct {
	float x, y, z;
}Punto;

Con estas lineas definimos un nuevo tipo de dato, lo bautizamos como Punto y tiene adentro tres flotantes, para representar coordenadas, aunque el programa es en esencia bidimensional, como el OpenGL trabaja en 3D, me gusta declarar todo como si estuviera dibujando en 3D.

Después se declaran algunas variables globales, y el prototipo de las funciones, las variables globales son:

• xMax, yMax: Guardan el tope de las coordenadas del mundo, es decir de donde a donde corre la parte visible de la ventana en X y en Y, con respecto al origen (situada al centro de la ventana)
• vertices: Es un arreglo de tres puntos, que guardara la única información que necesitamos para empezar a generar el copo de nieve, la posición de tres vértices.
• numPtos: Este guarda el número de vértices proporcionados por el usuario, es un contador para poner la siguiente lógica: “Si ya tienes tres puntos, empieza a hacer el fractal, si tienes menos de tres puntos, continua esperando…”
• fondo: Otro entero que guardará la profundidad máxima para hacer el fractal, donde un cero, pinta un triangulo, un uno la estrella de David y así en adelante. Es si lo quieren ver así el numero de veces que se manda a llamar recursivamente el fractal.

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

int main(int argc, char** argv) {
 
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGBA);
   glutInitWindowSize (640, 480);
   glutInitWindowPosition (100, 105);
   glutCreateWindow (argv[0]);
   inicializar();
 
   glutDisplayFunc(dibuja);
   glutReshapeFunc(redimensiona);
   glutKeyboardFunc(teclado);
   glutSpecialFunc(tecladoEspecial);
   glutMouseFunc(raton);
 
   glutMainLoop();
 
   return 0;
}

La función main, no mucho que decir, es muy estándar en el estilo glut, pone la maquina de estados en el estado adecuado, manda llamar a inicializar, registra cinco funciones de callback y por ultimo manda al loop principal de glut. Utilizo un solo buffer por que no voy a hacer animación, y ocupo el nombre del programa para el titulo de la ventana.

47
48
49
50
51
52

void inicializar () {
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   glPointSize(5.0);
   numPtos = 0;
   fondo = 1;
}

La primer función en ser ejecutada, pone el color del fondo en negro, a los puntos les da tamaño 5, inicializa el contador de puntos y a profundidad.

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

void redimensiona (int ancho, int alto) {
   float aspect;
 
   glViewport (0, 0, ancho, alto);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
 
   if (alto == 0){
   	  alto = 1;
   }
 
   aspect = (float) ancho / (float) alto;
 
   if (ancho <= alto) {
   	  glOrtho(-MUNDO, MUNDO, -MUNDO/aspect, MUNDO/aspect, -MUNDO, MUNDO);
   	  xMax = MUNDO;
   	  yMax = MUNDO / aspect;
 
   } else {
   	  glOrtho(-MUNDO * aspect, MUNDO * aspect, -MUNDO, MUNDO, -MUNDO, MUNDO);
   	  xMax = MUNDO * aspect;
   	  yMax = MUNDO;
   }
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

La función redimensiona, es llamada al inicio del programa, (el estándar de glut así lo indica) y cada vez que hay un evento de resize a la ventana. es una función muy común en estilo glut, lo único raro, quizás es que guarda en variables globales el valor de la máxima coordenada Y y la máxima coordenada X. Por lo demás es muy normal, da una proyección ortogonal, i.e: pone el sistema de referencia.

82
83
84
85
86
87
88
89
90
91
92
93

void teclado (unsigned char key, int cx, int cy) {
 
	switch (key) {
		case 27:
		   exit(0);
		break;
 
		default: break;
	}
 
	glutPostRedisplay();
}

La función teclado es muy simple, si detecta un evento de la tecla “Esc”, termina el programa con codigo 0.

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

void tecladoEspecial (int key, int cy, int cx) {
 
	switch (key) {
		case GLUT_KEY_PAGE_UP:
		   fondo++;
		break;
 
		case GLUT_KEY_PAGE_DOWN:
		   if (fondo > 1) fondo--;
		break;
 
		default: break;
	}
 
	glutPostRedisplay();
}

Está función sirve para cachar eventos de las teclas PgUp y PgDn, y en respuesta aumenta el valor de la variable global fondo, es decir hace que el fractal itere mas o menos veces, después de poner el nuevo valor en fondo, avisa a la ventana que necesita volver a dibujarse.

112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

void raton (int boton, int estado, int cx, int cy) {
	float x, y;
 
	/* Calculamos las coordenadas de mundo (relativas) apartir de 
	 * las de ventana (absolutas) */
 
	x = ((GLfloat)cx * 2.0 * xMax) / glutGet(GLUT_WINDOW_WIDTH) - xMax;
	y = yMax - ((GLfloat)cy * 2.0 * yMax) / glutGet(GLUT_WINDOW_HEIGHT);
 
	if (boton == GLUT_LEFT_BUTTON && estado == GLUT_DOWN) {
 
		if (numPtos < 3) {
		   vertices[numPtos].x = x;
		   vertices[numPtos].y = y;
		   vertices[numPtos].z = 0.0;
		   ++numPtos;
	    }
	    else {
	       numPtos = 0;
	       vertices[numPtos].x = x;
		   vertices[numPtos].y = y;
		   vertices[numPtos].z = 0.0;
		   numPtos++;
	    }
	}
 
	glutPostRedisplay();
}

Este código cacha las acciones del ratón, las lineas 118 y 119, calculan la posicion en x y en y en donde el usuario realizo el click, recordemos que el glut, nos pasa como parámetros dos enteros que representan el pixel en el que se hizo el click, pero para la lógica de nuestro programa lo queremos en coordenadas de mundo.

En las lineas siguientes, se pregunta si el mouse dio click izquierdo de ser así, preguntamos cuantos puntos llevamos, si son menos de tres, seguimos esperando si no que este sea el primero, de esta manera cada cuarto punto se resetea, el estado del programa, así que si después de pintar un fractal queremos pintar otro simplemente damos un nuevo click y ese es el primer punto de un nuevo fractal.

142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

void dibuja (void) {
	int i;
 
	glClear(GL_COLOR_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
 
 
	if (numPtos != 3) {
	   glColor3f(1.0, 1.0, 1.0);
	   glBegin(GL_POINTS);
	      for (i = 0; i <numPtos; i++) {
	   	     glVertex3f(vertices[i].x, vertices[i].y, vertices[i].z);
	      }
	   glEnd();
	}
 
	if (numPtos == 3) {
	   glColor3f(1.0, 1.0, 0.0);
	   glBegin(GL_LINE_STRIP);
	      koch(vertices[0], vertices[1], 0);
	      koch(vertices[1], vertices[2], 0);
	      koch(vertices[2], vertices[0], 0);
	   glEnd();
	}	
 
	glFlush();
}

Esta función se encarga de dibujar el fractal, primero limpia la pantalla, luego pone el estado de dibujar y pregunta si tenemos algún numero de puntos que no sea tres (por la lógica de la función anterior esto solo puede pasar cuando son menos que tres) de ser así solo pone los puntos que llevamos. En caso contrario se prepara a dibujar el fractal, para esto hace uso de la función auxiliar koch, que da los vértices de una curva de koch, así que para hacer el copo de koch, pinta tres curvas de koch: Una del vértice 0, al vértice 1, otra del vértice 1 al vértice 2 y por ultimo una que cierra el copo del vértice 2 al vértice 0.

Dibujando la curva de Koch

Ahora viene la parte mas interesante: ¿Como se dibuja la curva de Koch?
La función encargada de hacerlo es la función koch, pide como argumento dos puntos y un entero, que es el nivel de profundidad en la recursividad del algoritmo, es decir: la primera vez que se llame tendrá valor 0, la segunda vez que se llame tendrá valor 1 y así sucesivamente. Aquí esta el código de la función:

173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

void koch (Punto p0, Punto p1, int profundidad) {
	Punto a, b, p2;
 
	if (profundidad < fondo) {
		a.x = 2.0 / 3.0 * p0.x + 1.0 / 3.0 * p1.x;
		a.y = 2.0 / 3.0 * p0.y + 1.0 / 3.0 * p1.y;
		a.z = 0.0;
 
		b.x = 1.0 / 3.0 * p0.x + 2.0 / 3.0 * p1.x;
		b.y = 1.0 / 3.0 * p0.y + 2.0 / 3.0 * p1.y;
		b.z = 0.0;
 
		p2.x = 0.5 * p0.x + 0.5 * p1.x + a.y - b.y;
		p2.y = 0.5 * p0.y + 0.5 * p1.y + b.x - a.x;
		p2.z = 0.0;
 
		glVertex3f(p0.x, p0.y, p0.z);
		koch(p0, a, profundidad + 1);
		glVertex3f(a.x, a.y, a.z);
		koch(a, p2, profundidad + 1);
		glVertex3f(p2.x, p2.y, p2.z);
		koch(p2, b, profundidad + 1);
		glVertex3f(b.x, b.y, b.z);
		koch(b, p1, profundidad + 1);
		glVertex3f(p1.x, p1.y, p1.z);
 
	} 
 
	return;
}

En la linea 176, se pregunta cuantas veces se ha ejecutado esta función en la recursión, si es mas que lo que vale la variable fondo, regresa sin hacer ninguna operación, poniendo fin a la recursión. Sin embargo si aun es menor, se ejecutan los cálculos necesarios (se hace otra iteración) y dentro del procedimiento se llama recursivamente la función koch aumentando el nivel de profundidad.

La lógica de la función koch se explica a continuación:

La idea principal es que como entrada tenemos dos puntos (p0 y p1), los cuales representan un segmento y queremos a partir de ellos calcular tres puntos mas (a, b y p2). Como se ve en la figura:

Segmento de recta

Para calcular cada uno de estos puntos, se hace uso de la ecuación paramétrica de un segmento de recta. Si tenemos dos puntos p y q entonces la ecuación paramétrica en t, del semento de recta entre p y q es: con con esta ecuación podemos calcular fácilmente tanto a, como b. Sin embargo para calcular p2 tendremos que hacer algunas cosas mas.

Puntos a calcular en el nuevo segmento de koch

Primero calculamos el punto medio del segmento, a ese vector hay que sumarle la elevación del nuevo punto, para calcularla necesitamos sumarle un nuevo vector que sea perpendicular al segmento, para esto utilizamos el hecho de que el producto punto de dos vectores perpendiculares entre si, siempre es cero. Así que construimos el vector que va de a a b y de ahí lo volteamos es decir:

Dado un vector:

Es perpendicular a el vector v dado por:

Por lo que podemos encontrar el punto p2 de la siguiente manera:

Recordemos que el vector que va de a a b se puede ver como b-a.

Descargas

• Código fuente el programa
• Ejecutable de win32

¿Por que solo pongo el ejecutable para Windows, si yo siempre uso GNU/Linux?, por que los usuarios del lado luminoso de la fuerza les conviene mas compilar el fuente, que al cabo es solo uno, recuerden que deberán tener instalado OpenGL y glut.

Pantallazos

[Show as slideshow]

Un cierto genero de juegos que me gustaba mucho era el denominado Bet ‘em Up, tambien llamado hack and slash. Básicamente son los juegos de pelea de uno contra muchos. Un juego que era de mi particular agrado es el de alien v.s. predator.

Cuando era un usuario del lado obscuro de la fuerza, conocí un proyecto libre llamado MAME, que por cierto es desarrollado en C. MAME es un emulador de maquinitas es decir que nos permite usar nuestra computadora como si de una de estas se tratara.

Dentro de la filosofía de MAME se debe de emular el hardware independientemente del juego en cuestión. Los juegos de las arcades eran chips es decir también hardware. De ahí que para jugar un juego de arcade en nuestra computadora debemos tener dos cosas un el juego o rom y un emulador. MAME es solamente el emulador.

Instalando MAME en Ubuntu

Lo primero que tenemos que hacer es instalar MAME, para esto instalamos los siguientes dos paquetes ya sea vía sinaptic, o aptitude. No recomiendo usar la utilería de quitar y añadir programas.

• xmame-common
• xmame-sdl

¿Que por que estos? Bueno el paquete xmame-common contiene las utilerías necesarias para usar MAME y el paquete xmame-sdl contiene los binarios de MAME. Los binarios de SDL no son los únicos binarios, también hay binarios de svga (xmame-svga) y de x11 (xmame-x). Cualquiera de ellos hace lo mismo y solo necesitamos tener uno, mi recomendación personal son los de SDL que en mi maquina fueron los únicos que funcionaron.

Bajamos un rom para jugar.

Hay muchos lugares en la red donde conseguir ROMS, a mi en lo personal me gustan mucho dos sitios: planet emu y rom world. ahora que si de veras queremos tener un montón de juegos podemos ver esta otra opción :p

Bajemos el juego de Alien vs Predator de romworld, al buscarlo podemos ver que hay muchos roms que parecen ser el mismo juego.

Generalmente un juego que salio en muchos países haya cambiado un poco de un país a otro, por eso hay as de un ROM, sin embargo casi siempre hay un ROM maestro con el juego y los demás solo contienen los cambios.

Para jugar necesitamos al menos el rom maestro, si queremos además alguna versión en especial también la bajamos. No hay manera segura de saber cual es el maestro, aunque casi siempre es el que mide mas, así que para seguir con el ejemplo anterior bajamos el de Europa. También notamos que nos avisan que este juego necesita de los ROMS de Neo Geo para poder jugarlo, algunos fabricantes como NEO GEO le cargaban un bios a las maquinas, estos bios eran necesarios para jugar juegos de esa compañía) así que los bajamos también.

Instalamos los ROMS.

Si estamos siguiendo el ejemplo debemos haber descargado al menos dos archivos: avsp.zip y neogeo.zip. Los ROM solo funcionan estando comprimidos así que no se les vaya a ocurrir descomprimirlos. La manera como le decimos a xmame que tenemos nuevos ROMS es moviéndolos a la carpeta donde el busca ROMS al arrancar, si estamos haciendo la instalación de default de Ubuntu eso es en /usr/share/games/xmame/rom que usualmente es una carpeta protegida de escritura así que para mover los ROMS podemos hacer lo siguiente:

sudo mv avsp.zip neogeo.zip /usr/share/games/xmame/rom/

Probando que funcione el juego

Para jugar un juego simplemente corremos el MAME desde la linea de comandos así:

xmame NOMBREROM
Si queremos ser mas específicos le podemos decir el binario que queremos que ocupe (solo si tenemos mas de uno instalado), en el caso de mi ejemplo seria algo así:
xmame.SDL avsp.zip

No importa en donde estemos parados ya que xmame buscara el ROM en la carpeta de ROMS.

Ahora es posible que tengamos una bronca es decir que veamos que el juego corre en una ventanita chiquita que no podemos maximizar ni darle resize.

Creando un archivo de configuración

Xmame por default busca la configuración en un archivo de sistema, luego la busca en otro archivo dentro de nuestro home, así que para decirle que corre en pantalla completa vamos a usar ese archivo de configuración.

Primero necesitamos crearlo, para no tener problemas de sintaxis, lo podemos hacer todo en un paso con el siguiente comando:

xmame --showconfig > ~/.xmame/xmamerc

Que manda la configuración actual al archivo xmamerc dentro de un directorio oculto de nuestro home. Luego nos ponemos a editar el archivo

gedit ~/.xmame/xmamerc

Y buscamos la linea:

fullscreen              0

Donde cambiamos el 0 por un 1, salvamos y listo podemos volver a correr el juego para ver el resultado.

Poniendo un front end gráfico

Alternativamente podemos usar un frontend, para usar mame. Hay algunos en los repositorios, a mi en lo personal no me gusto ninguno de ellos, así que mi humilde recomendación es usar uno que no viene en el repositorio gxmame.

Entramos a al sitio de gxmame y bajamos la versión 0.35beta2, es importante señalar dos cosas. Uno, que la versión que ofrecen directamente de la pagina no es la que queremos, para bajar la 0.35beta2 tenemos que irnos a la pagina de proyecto en surceforge, de ahí a donde dice download y de ahí buscar la ultima que es la 0.35beta2, es importante por que la 0.34 tiene un bug que le impide encontrar los ROMS. Dos, bajemos la gxmame_0.35beta2-1_i386.deb por que es un binario que funciona en Debian/Ubuntu y nos hará mas sencilla la instalación. Luego simplemente instalamos el deb, como acostumbremos, una manera es:

sudo dpkg -i gxmame_0.35beta2-1_i386.deb

Y listo ahora vamos al menú Juegos y vemos que ya tenemos el gxmame, al ejecutarlo vemos una pantalla como esta:

Antes de que vemos los juegos debemos hacer dos cosas, ir al menú Archivo y darle Audit all games. Con esto checa la integridad de nuestros roms para ver que sean compatibles y que esten completos. Cuando termine, debemos ir al menú Opciones y le damos reconstruir lista de juegos, cuando termine, podemos navegar con la barra lateral a donde dice Disponibles, y ahora si debemos de ver nuestro juego listo para usarse, simplemente lo seleccionamos y le damos Play Game.

Algunos tips

Una ves corriendo el juego, lo minimo que necesitan saber es los siguiente:

• Con el botón de Tab, pueden ver la opciones, Y en Input this game, pueden configurar los botones a usar.
• Con el botón de Esc salen del juego.

• Suponemos que la instalación se va a realizar en Ubuntu, esto significa que el servidor va a vivir en Ubuntu.
• Que queremos que los repositorios sean visibles vía web, que el servidor web sea Apache de la rama 2.x (Subversión tiene su propio servidor, nosotros mejor ocuparemos Apache).
• Que el protocolo para comunicarse sea SSL, la información viaje encriptada (es decir que el URL sea https://algo).
• Que se podría hospedar mas de un repositorio.
• Que para conectarse un usuario tenga que proporcionar un password.
• Que tengamos políticas de acceso, es decir que no todos los usuarios puedan ver todas las carpetas, habrá algunos que puedan ver, otros que puedan escribir, y a cada carpeta le podemos poner diferentes atributos (permisos).

Cuando aprendimos a hacer esta instalación leímos el tutorial de Viktor Zigo, que esta libre bajo una licencia Creative Commons, sin embargo me decido a aumentar algunas cosas como la política de acceso, además dado que no hay mucha documentación en español sobre este tema, me imagino que este documento le ayudara a alguien.

Paquetes necesarios

Hay que instalar, o verificar que estén instalados los siguientes paquetes:

• subversion
• libapache2-svn
• libapache-mod-dav
• apache2

En ubuntu 7.10 el paquete libapache-mod-dav, no existe simplemente continuamos sin el pues mod-dav ya esta incluido en apache2

Habilitar el modulo de SSL en apache

Para hacer este paso primero hay que habilitar el modulo de apache que deja comunicarse via SSL, luego hay que editar un archivo de configuración de apache para decirle que escuche por el puerto 443, que es el default de SSL

Habilitar el modulo de apache2 de SVN

sudo a2enmod ssl

Editar el archivo de configuración /etc/apache2/ports.conf del apache.

Agregando al final la linea: “Listen 443”. Es decir deben haber dos lineas, la del 80 y la del 443

Nota me acabo de dar cuenta de que en Ubuntu 7.10, no es necesaria la edición del archivo, pues el comando anterior a2enmod, ya edita el archivo por nosotros, lo que se debe de hacer es fijarnos en este archivo y que escuche el 443.

Generar un certificado

Para hacer un certificado hay que ocupar una herramienta, desde Ubuntu Festy en adelante esta herramienta es: make-ssl-cert, antes de eso la herramienta era: apache2-ssl-certificate.

Sea cual sea el caso, hay que hacer un certificado, el certificado es un archivo .pes y una llave, que es un archivo con números raros de nombre.

Para hacer el certificado la herramienta nos hace algunas preguntas, como quienes somos, donde se ubica el servidor físicamente, a que organización pertenecemos, etc.

Es importante usar el nombre real de nuestro servidor, cuando lo pida, por que de lo contrario cada vez que un usuario quiera acceder al repositorio, su cliente le marcara un warning diciendo que el servidor y el emisor del certificado no corresponden.

Si el servidor va a ser accesible por un dominio, el dominio es el nombre del servidor, si va a ser accedido por una IP fija, la IP es el nombre del servidor, si va a ser accedido dentro de una red interna el nombre en la red de la maquina es el nombre del servidor.

La herramienta debe generar ambos archivos el apache.pem y el de la llave, lo mas recomendable es que estos se encuentren en la carpeta ssl, dentro de la carpeta de apache. Puede que sea necesario que nosotros tengamos que mover los archivos manualmente.

La herramienta antes de Festy 7.04 se usaba asi:

sudo apache2-ssl-certificate

Desde Festy en adelante se usa así:

sudo /usr/sbin/make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem

En donde el primer argumento es el comando a invocar en este caso make-ssl-cert, el segundo es una plantilla de certificado en este caso se ubica en /usr/share/ssl-cert/ssleay.cnf, y el tercero el lugar donde se pone el certificado /etc/apache2/ssl/apache.pem. Es decir que lo único que podría cambiar es el tercer argumento aunque no se recomienda. Es importante que antes se cree la carpeta donde va a vivir el certificado

Crear un host virtual

En apache2 hay posibilidad de que un solo servidor maneje muchos sitios, lo mas recomendable es hacer un sitio aparte para nuestros repositorios de SVN.

Copiamos el sitio de default, para ocuparlo de plantilla

sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/$NOMBRESITIO

En donde $NOMBRESITIO, es el nombre que queremos que tenga nuestro sitio que maneja los repositorios. por ejemplo podemos ponerle repos.

Editamos configuración del sitio

Abrimos con nuestro editor de textos plano favorito el recién creado archivo de configuración del sitio y lo editamos:

Cambiamos la parte que dice:

NameVirtualHost *
<VirtualHost *>

Por:

NameVirtualHost *:443
<VirtualHost *:443>

Y añadimos las siguientes lineas:


SSLEngine on
SSLCertificateFile /etc/apache2/ssl/apache.pem
SSLProtocol all
SSLCipherSuite HIGH:MEDIUM

Dentro de las etiquetas VirtualHost, pero fuera de cualquier etiqueta Directory

Habilitamos el nuevo host virtual

Primero le decimos a apache que ya hay un nuevo sitio

sudo a2ensite $NOMBRESITIO

Y reiniciamos apache

sudo /etc/init.d/apache2 restart

Si hubo errores al editar el archivo, ahora se quejara, corregimos hasta que apache arranque, si hay un warning de que no puede determinar el nombre de dominio calificado, es normal.

Y se puede arreglar añadiendo ServerName $NOMBREDELSERVIDOR al archivo de configuración principal de apache: /etc/apache2/apache2.conf (el nombre del servidor es el nombre de la maquina que lo hospeda)

Creando los repositorios:

Suponemos que queremos tener varios repositorios, creamos una carpeta donde ponerlos todos, un buen lugar para hacerlo es en: /var/svn, luego hacemos los repositorios y le cambiamos los permisos a los repositorios para que el usuario de apache (www-data), tenga total control sobre ellos.

Por ejemplo:

sudo mkdir /var/svn
sudo svnadmin create /var/svn/$REPOS
sudo chown -R www-data:www-data /var/svn/$REPOS
sudo chmod -R g+ws /var/svn/$REPOS

Donde $REPOS, es el nombre del repositorio a crear, se pueden hacer varios repositorios. Que deberían vivir bajo la mima carpeta, en este caso /var/svn.

Agregar usuarios al repositorio

Para que un usuario pueda consultar el repositorio, debe de tener un password, el encargado de hacer la validación sera Apache, y la manera como lo hará sera verificando que el usuario y el password, estén en un archivo de texto plano.

Creando el archivo de password

Hay que ocupar la herramienta htpasswd, en versiones de Ubuntu anteriores a 7.04, la herramienta se llama htpasswd2, ambas son la misma herramienta, solo le quitaron el 2, en el nombre, así que es cuestión de usar el que nos corresponda.

Ejemplo:

sudo htpasswd -c -m /etc/apache2/svn-auth-file $NOMBREUSUARIO

En este momento nos preguntara cual va a ser el password del para el usuario $NOMBREDEUSUARIO y se crea el archivo de nombre svn-auth-file. El nombre del archivo puede ser cualquiera pero se sugiere algo que nos recuerde que son los passwords del svn, y puede vivir en cualquier lado, pero se recomienda que viva donde el apache lo hace.

El modificador -c, es para que cree el archivo de passwords y el modificador -m para que encripte el password.

Importante: Si queremos agregar un nuevo usuario usamos el comando sin el modificador -c y lo apuntamos al archivo que ya creamos, de esta manera los passwords de ambos usuarios están guardados en el mismo archivo. En nuestro ejemplo seria:

sudo htpasswd -m /etc/apache2/svn-auth-file $NOMBRENUEVOUSUARIO

Agregando políticas de acceso

Vamos a hacer una archivo de control de acceso, lo mas simple es usar como plantilla alguno de los que viene en cualquier repositorio. Por ejemplo podemos ir al repositorio que acabamos de hacer y dentro de su directorio conf, hay un archivo de ejemplo: authz

Podemos tomar este archivo de ejemplo como plantilla. Y copiarlo al directorio de apache, cambiarle por los permisos adecuados y después editarlo con nuestras preferencias. Podemos ponerle cualquier nombre yo aquí lo llamo svn-authz-file.

sudo cp /var/svn/$REPOS/conf/authz /etc/apache2/svn-authz-file
sudo chmod 644 /etc/apache2/svn-authz-file
sudo gedit /etc/apache2/svn-authz-file

Editar el archivo no es difícil y podemos ver que la plantilla ya trae un ejemplo con la sintaxis. Yo por ejemplo solo le agrego algo como esto:

[$REPOS:/]
$NOMBREUSUARIO = rw
$NOMBRENUEVOUSUARIO = r
En donde $NOMBREUSUARIO puede leer y escribir el repositorio $REPOS y $NOMBRENUEVOUSUARIO solo puede leerlo.

Poniendo todas las opciones de configuración a nuestro repositorio

Ahora solo resta decirle a apache que sirva de interfaz a nuestro repositorio con todas las opciones que le acabamos de dar.

Para hacer esto editamos el archivo dav_svn_conf que se encuentra dentro de la carpeta mods-available del directorio de apache.

sudo gedit /etec/apache2/mods-available/dav_svn_conf

Este archivo tiene de nuevo un ejemplo de llenado, cada repositorio tiene sus opciones dentro de las etiquetas location. Podemos repetir la que ya tiene por defecto y agregarle nuestras opciones.

<Location /$REPOS>
DAV svn
# our access control policy
AuthzSVNAccessFile /etc/apache2/svn-authz-file
SVNPath "/var/svn/$REPOS"
AuthType Basic
AuthName "Subversion repository"
AuthUserFile /etc/apache2/svn-auth-file
Require valid-user
SSLRequireSSL
</Location>

De estas opciones debemos modificar dentro de la etiqueta de apertura de location el nombre de nuestro repositorio. En donde dice SVPath ponemos el lugar donde esta el repositorio. En la opción de AuthzSVNAccessFile el archivo que creamos de políticas de control de acceso. Y en la opción de AuthUserFile el archivo donde están las contraseñas de los usuarios. No olvidemos añadir tambien la linea SSLRequireSSL

Reiniciamos apache

Por ultimo para que todos los cambios surtan efecto:

sudo /etc/init.d/apache2 restart

Si algún archivo no quedo bien editado ahora se quejara, de no ser así podemos proceder a probarlo:

Abrimos nuestro navegador web favorito y visitamos las dirección http://localhost/$REPOS y debe de contestarnos algo así como 403: Forbiden. Ahora visitamos el sitio https://localhost/$REPOS y debe pedirnos usuario y contraseña, en caso de que la contraseña sea incorrecta o que el usuario que introducimos no tenga permiso de lectura sobre $REPOS volverá a contestarnos 403: Forbiden.

Si el usuario se autentifica correctamente y tiene los permisos necesarios, debe mostrarnos el repositorio si aun no hemos hecho ningún import o commit, debe ser un repositorio vacío en la revisión 0.

He probado que estos pasos funcionan en Ubuntu 6.10, 7.04 y 7.10

Mas conocimientos

Recuerden que el mejor lugar para aprender mas de subversion es el libro oficial, que ademas es libre y existe una traducción al español.

El makefile es un archivo de texto plano, que usa la herramienta make, dicho archivo debe ser escrito por el desarrollador y dice como se compila el programa que escribió. Usualmente los makefiles son complejos y contienen un montón de reglas, sin embargo nosotros nos vamos a limitar a tres: una para compilar, una para limpiar y otra para reconstruir.

Así que abrimos nuestro editor de texto plano favoritos y construimos un archivo que tenga por nombre makefile (el nombre es muy importante).

Si nuestro programa solo va tener un archivo fuente esta sera nuestra plantilla:

1
2
3
4
5
6
7
8
9
10

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = -Wall
LIBRARIES = -lglut -lGL -lGLU -lm
ejecutable: fuente.c
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
destroy:
	rm -f *.o ejecutable
clean:
	rm -f *.o

En donde ejecutable es el nombre que queremos que tenga nuestro archivo ejecutable y fuente es el nombre de nuestro único archivo fuente.

Analizando un poco vemos que el makefile define unas variables en las primeras lineas, y luego define unas reglas, las reglas siempre son de la forma:

[objetivo]: [dependencia]
[comandos]

Donde objetivo es el nombre de la operación que queremos hacer, dependencia es todo lo que necesitamos para llevarla a acabo y comandos es lo que debemos hacer para llevar a cabo la operación.

Las reglas que defino son ejecutable que sirve para hacer el ejecutable, clean que sirve para borrar todos los los archivos intermedios que hace el compilador (por ejemplo los .o) y destroy que borra todo lo que hace el compilador y nos deja listos para intentar compilar de nuevo (por ejemplo en nuestro periodo de ensayo error).

Se observa que uso gcc como compilador, por que el lenguaje C es usualmente nuestro default, si piensan programar en c++, cambien gcc por g++. Tambien fijense que entra las librerías mando a GL a GLU y a glut, que es por que queremos hacer un programa de OpenGL con glut, pero además mando un misterioso -lm, estas son as demás librerías de default de C, por ejemplo si en nuestro programa queremos usar funciones definidas en math.h.

Si queremos hacer un programa con mas de un código fuente esta es otra plantilla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = $(COMPILERFLAGS)
LIBRARIES = -lglut -lGL -lGLU -lm
OBJ = fuente1.o fuente2.o fuente3.o fuente4.o
BIN = ejecutable
 
all: $(BIN)
$(BIN) : $(OBJ)
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
 
fuente1.o: fuente1.c
	$(CC) -c fuente1.c -o fuente1.o $(CFLAGS)
 
fuente2.o: fuente2.c
	$(CC) -c fuente2.c -o fuente2.o $(CFLAGS)
 
fuente3.o: fuente3.c
	$(CC) -c fuente3.c -o fuente3.o $(CFLAGS)
 
fuente4.o: fuente4.c
	$(CC) -c fuente4.c -o fuente4.o $(CFLAGS)
 
destroy:
	rm -f $(OBJ) $(BIN)
clean:
	rm -f $(OBJ)

En donde fuente1, … fuentei, son todos los archivos fuentes que componen el programa y ejecutable es el nombre del ejecutable.

Ahora lo importante:

Es ampliamente recomendado tener una carpeta donde guardar todo lo referente a nuestro programa y solo eso, es decir mi fuente y mi makefile deben estar en una carpeta para ellos solos (esto para facilitar su transporte) y que no se vayan a volar algo sin querer al escribir una regla mal del make XD
Para compilar nuestro programa simplemente escribimos en la linea de comandos “make”: (obviamente debemos estar parados en el directorio donde esta todo):

$make

Si nuestro programa compilo correctamente genero el archio ejecutable, pero si tuvimos errores, veremos los errores y warnings en la shell y debemos de hacer los siguiente:
ejecutar make destroy, para limpiar toda al basura generada por la compilación fallida, corregir nuestro fuente y luego volver a intentar compilar.

$make destroy 

Algunas observaciones:

• Estos makefiles son solo recomendaciones y de hecho no siguen las reglas GNU de los makefiles, para aprender mas de eso pueden visitar: http://www.gnu.org/software/make/
• Para escribir este post me base en la guia publicada por el area de linux de la fesa, quizas si le dan un ojo les quede mas claro http://www.acatlan.unam.mx/linux/graficacion/compilalinux.html
• Si nuestro fuente tiene cabeceras por ejemplo cabecera.h, estas no necesitan ser compiladas y por lo tanto no se ponen en el make, basta que en el fuente sean usadas #include, Siempre que la cabecera no tenga código en C, si no mas bien declaraciones de estructuras y variables globales (que es como debe ser).