Sobre como utilizar pequeños programas, IDE de desarrollo, pequeños apuntes generales, “tips & tricks”…
El comando make mejora y configurar una compilación de varios ficheros en C\C++, y es que a diferencia del compilador tradicional sólo recompila los ficheros de código fuente que han cambiado. Otra de sus ventajas es que no es necesario utilizar una larga línea donde se incluyan las librerías, las cabeceras y el código fuente para compilar, lo que se hace es configurar un fichero llamado makefile y a partir de ahí, cuando queramos compilar, llamar al make.
El makefile es un archivo de texto común donde se definen las reglas para el make utilizando el siguiente formato:
# comentario destino: requisito comando
Los comentarios son, evidentemente, opcionales. El destino se refiere al objeto a crear (un ejecutable, un fichero .o…) o una tarea. El requisito es el nombre del archivo (o archivos separados por espacios) que se necesita para ejecutar el comando. En la línea de comando no se utilizan espacios sino tabulaciones e indica el comando del shell a ejecutar (en nuestro caso lo que nos concierne es el compilador), si el comando nos ocupa más de una línea podemos indicar que sigue en la línea siguiente mediante \, si queremos añadir más comandos podemos hacerlo en una segunda línea.
polaca: main.o stack.o getop.o getch.o
gcc -o polaca main.o stack.o getop.o getch.o
main.o: main.c calc.h
gcc -c main.c
stack.o: stack.c calc.h
gcc -c stack.c
getop.o: getop.c calc.h
gcc -c getop.c
getch.o: getch.c
gcc -c getch.c
clean:
rm polaca \
main.o stack.o getop.o getch.o
El anterior ejemplo corresponde a un makefile el cual podemos ejecutar haciendo make, make polaca y make clean. Cuando ejecutamos el comando make sin seguirlo de nada escogerá un fichero makefile por defecto, este deberá tener el nombre makefile (si queremos utilizar un makefile con otro nombre añadiremos el parámetro -f y el nombre del fichero), como tampoco estamos indicando el destino se ejecutará el primero que encuentre, en este caso “polaca” (por lo que haría lo mismo que ejecutar “make polaca”), en cambio, si indicamos destino (como en make clean) se ejecutará el apartado del destino clean. Si un comando necesita un fichero que no existe busca entre los demás destinos, si coincide lo ejecuta.
Puedes utilizar variables dentro del archivo, para ello las definirías en la primera línea haciendo únicamente nombreVariable = valor. Luego, para utilizarla, harías $(NombreVariable). Ni que decir tiene que distingue mayúsculas de minúsculas. En el ejemplo anterior podemos definir el compilador y los objetos:
CC = gcc
OBJECTS = main.o stack.o getop.o getch.o
polaca: $(OBJECTS)
$(CC) -o polaca $(OBJECTS)
...
Un makefile contiene reglas predefinidas como por ejemplos comandos de compilación de C, de esa forma nos es innecesario indicar los .o, .c o .h.
CC = gcc
OBJECTS = main.o stack.o getop.o getch.o
polaca: $(OBJECTS)
$(CC) -o polaca $(OBJECTS)
clean :
rm polaca $(OBJECTS)
Los ficheros .o son los que indican al make cuando se ha generado el elemento, por lo tanto si los borramos el make recompilaría todo el proyecto.
| Herramienta | Uso | Lenguaje |
|---|---|---|
| waf | Sistema de construcción | Python |
| Consola de Chrome | Intérprete de JavaScript | JavaScript |
| Fabric | Herramienta para lanzar comandos vía Python | Python |
| Vagrant | Tool to create development environtments | - |
| Factory Boy | Fixtures replacement tools | Python |
DoxyS es una herramienta por consola de documentación de C\C++. Partiendo del código en este lenguaje genera un manual en formato html.
doxys -m.doxys en el directorio raíz del código.Es una herramienta que ayuda en la automatización de la compilación de código, creación de librerías y otras acciones que se requieren para la creación del resultado de un proyecto Java.
Un script de Ant se escribe en XML y se llama build.xml, describe como construir un proyecto Java a partir de objetivos (targets) y tareas (tasks). Un objetivo es una acción a realizar (compilar el codigo, ejecutar los tests…), una tarea es una acción concreta (generar un jar…). Tendrá una estructura parecida al siguiente:
<?xml version="1.0" ?> <project name="tax-calculator" default="package"> <target name="init"> <mkdir dir="build/classes" /> <mkdir dir="dist" /> </target> <target name="compile" depends="init" description="Compile Java code"> <javac srcdir="src" destdir="build/classes"/> </target> <target name="package" depends="compile" description="Generate JAR file"> <jar destfile="dist/tax-calculator.jar" basedir="build/classes"/> </target> <target name="clean" description="Deletes generated directories"> <delete dir="build" /> <delete dir="dist" /> </target> </project>
La rama principal es la llamada project, esta contiene todos los targets, podemos encontrar las propiedades name (que define el nombre) o default (que define la target por defecto que se ejecutará). Los targets tienen un nombre (definido por name) y, si necesitan que otro target se realice antes, dependencias a este (mediante la propiedad depends); la description no es más que una descripción de lo que hace el target.
Si no estamos utilizando un IDE de desarrollo de Java y queremos ejecutar el script Ant por consola tendremos que echar mano del comando ant de la siguiente forma:
ant clean: Ejecuta el target clean.ant clean compile: Ejecutará el target clean y luego el compile.ant -f x.xml: Utilizará el fichero x.xml en vez el build.xml.Dentro de los targets podemos encontrar las tareas las cuales son:
Existen otras definiciones de tareas para mover\copiar ficheros como copy que copia un fichero file al directorio todir. También existen ftp y scp (secure copy).
Otras serían para la configuración de la aplicación, con acciones como coger elementos (get), unzip o available.
Para indicar el archivo correspondiente a una librería utilizaremos una tarea parecida a esta: <path id=“junit.classpath” location=“lib/junit.jar”/>
Si quisieramos indicar una ruta donde estubiesen varios archivos .jar usaremos las siguientes líneas:
<path id="compile.classpath"> <fileset dir="lib" includes="*.jar" /> </path>
Para usar este classpath con la tarea javac utilizaremos la propiedad classpathref:
<target name="compile" depends="init" description="Compile Java code"> <javac srcdir="src" destdir="build/classes" classpathref="compile.classpath" /> </target>
Aunque también podemos incrustarlo dentro de la tarea:
<target name="compile" depends="init" description="Compile Java code"> <javac srcdir="src" destdir="build/classes"> <classpath> <fileset dir="lib" includes="*.jar"/> </classpath> </javac> </target>
Podemos definir valores para el script en unos elementos llamados propiedades. Por ejemplo podríamos definir un directorio, dándole como identificador build.dir, de la siguiente forma:
<property name="build.dir" location="build"/>
Y luego accederíamos al valor de build.dir haciendo ${build.dir} , es decir, haciendo ${identificador de la propiedad}:
<target name="display-properties"> <echo>Build directory : ${build.dir}</echo> </target>
Podemos mostrar todas las propiedades definidas haciendo <echoproperties />.
Ant tiene predefinidas las siguientes propiedades: ${basedir}, ${java.home}, ${java.version}, y ${user.home}.
Otra cosa que podemos hacer es definir las propiedades en un fichero distinto:
<property file="${user.home}/ant-global.properties"/><property file="${basedir}/local.properties"/>
libddraw.a añadiremos al linker -lddraw.valgrind. Existen GUIs tales como Alleyoop o valkyrie.gProf es un analizador de código.
Es una herramienta de consola para utilizar protocolos que permitan sintaxis URL (FTP, FTPS, LDAP, HTTP…). Es una buena herramienta para simular acciones sobre el navegador web, además existe libcurl, una API que permite arreglar cURL a desarrollos.
curl url
curl -X POST -d "param1=value1¶m2=value2" http://127.0.0.1:8080/group/
curl -X DELETE http://127.0.0.1:5000/servers/1
El comando ssh es usado para acceder remotamente a una consola Linux.
ssh 192.168.1.100 - Accede al host 192.168.1.100 con el usuario actualmente validado.ssh 192.168.1.100 -l root - Accede al host 192.168.1.100 con el usuario indicado (root).
Existen servidores de ssh que podemos instalar en nuestras máquinas, como por ejemplo: dropbear para pequeños dispositivos o el openssh-server.
Podemos montar dispositivos remotos con el protocolo sftp.
Podemos conectar a un host remoto mediante un archivo clave .pem:
$ ssh -i skey.pem ubuntu@ec2-54-218-73-84.us-west-2.compute.amazonaws.com
Aunque también podríamos añadir esta clave al archivo de configuración de ssh y acceder mediante un alias:
$ cd ~/.ssh $ cp skey.pem ~/.ssh/ $ chmod 400 ~/.ssh/skey.pem $ chmod 700 ~/.ssh $ gedit ~/.ssh/config
Esto sería su contenido:
Host awshost1 HostName ec2-54-218-35-71.us-west-2.compute.amazonaws.com User ubuntu IdentityFile "~/.ssh/skey.pem"
Y así su conexión:
$ ssh awshost1
#define DLLIMPORT _declspec(dllimport) de esa forma harás el código más legible y no sólo eso, puedes hacer un define distinto para la cabecera de la librería o para la del programa, por ejemplo, en MSVC++ se define para el preprocesador _USRDLL cuando se trabaja con un proyecto que compila una dll y eso puede usarse para crear una cabecera válida para un proyecto dll o para un proyecto ejecutable.#ifdef _USRDLL #define DECLSPEC _declspec(dllexport) #else #define DECLSPEC _declspec(dllimport) #endif DECLSPEC int suma (int);
_DEBUG.#if defined _DEBUG std::cout << "Compilado en modo debug"; #endif
OutputDebugString (string), recuerda incluir windows.h.MultiByteToWideChar.iisreset es un comando de consola que reinicia el IIS.
adsutil.vbs es un script bastante útil que se encuentra en c:\inetpub\adminscripts y que admite una serie de parámetros, a partir de los cuales puedes realizar la configuración de los sitios web (que no directorios virtuales) dentro de un IIS.
Para llevar a cabo acciones con este script es necesario conocer el identificador del sitio web con el que quieras trabajar. Aquí tienes un script que va indicando pares de sitio web\identificador que tienes en la máquina actualmente.
El adsutil.vbs ha de ejecutarse con el cscript.exe.
dsutil.vbs enum w3svc/WebsiteId
Siendo el WebsiteId un número identificador que corresponda al id del site sobre el que queramos ver su info.
cscript adsutil.vbs CREATE W3SVC/2cscript adsutil.vbs DELETE W3SVC/2cscript adsutil.vbs COPY W3SVC/1 W3SVC/2
Para que las aplicaciones dinámicas que ejecutes sobre IIS generen automática y correctamente las url será necesario configurar los ServerBindings (rutas por las que puede ser accedida nuestra aplicación). Es decir, sin configurar pueden aparecernos como http://local/site cuando lo que queremos es que nos aparezcan como http://internet/site.
Para configurar estos elementos usaremos el parámetro set del adsutil.vbs seguido de /w3svc/WebsiteId/elemento (siendo el WebsiteId el número identificador del site y el elemento ServerBindings o SecureBindings) y luego la dirección que queramos definir en el siguiente formato: “:puerto:ruta”. Si quisieramos configurarlo como inicialmente estaba haríamos: :80:.
adsutil.vbs set /w3svc/WebsiteId/ServerBindings ":80:www.example.com" adsutil.vbs set /w3svc/WebsiteId/SecureBindings ":443:www.example.com"
Si quisiesemos agregar una lista de sitios:
adsutil.vbs set /w3svc/WebsiteId/ServerBindings ":80:www.example.com" ":81:www.example2.com"
Una vez definidos estos parámetros reiniciaremos el server con el comando iisreset.
En IIS 5.1. Teniendo algún certificado existente en nuestra máquina podemos hacer botón derecho sobre el sitio web, ir a las propiedades y luego a la pestaña Seguridad de directorios, en el apartado Conexiones seguras se nos dan opciones que nos permite escoger el certificado que queramos y, a partir de ahí activar SSL en nuestras webs (siempre desde la pestaña Seguridad de directorios).
aspnet_regiis -i (que está en C:\WINDOWS\Microsoft.NET\Framework\vXXXX).Las aplicaciones web que son solicitadas al IIS son ejecutadas por el usuario ASPNET que se instala en el sistema cuando instalamos el framework. Si en algún momento nos interesase que sea otro usuario quien lance estas aplicaciones lo que haremos será:
aspnet_regiis -ga MachineName\AccountNamectrl + alt + enter: Abre una consola interactiva.