Welcome to the Slackware Documentation Project

¡Esta es una revisión vieja del documento!


En proceso de traducción. — rramp 2020/01/13 16:26 (UTC)

Anatomía de un Slackbuild

Preámbulo

Supongo que todos los usuarios de Slackware habrán usado alguna vez un script de SlackBuild para crear un paquete de software que pueda ser instalado fácil y limpiamente y eliminado más tarde si es necesario. Mi experiencia fue que ejecuté el script de SlackBuild para crear un paquete y nunca miré realmente el código que contenía hasta que un día la versión fuente no coincidió con la indicada en el script.

¿Por qué te molestarías en mirar el código en un script de SlackBuild? Bueno, en primer lugar, puedes usarlo si estás aprendiendo a hacer un bash. En segundo lugar, puede que no quieras enviar un script de SlackBuild, pero quizás quieras crear un paquete que no exista para el software que quieres.

Así que aquí me gustaría revisar un script de SlackBuild lo mejor que pueda (verbalmente). Doy la bienvenida abiertamente a las ediciones de todos los demás en todos los niveles. De hecho, creo que es importante que la gente de todos los niveles contribuya. Lo que es obvio para una persona puede necesitar ser explicado a otra persona.

Existen diferentes enfoques de un script de Slackbuilds, por ejemplo Alien Bob tiene su muy útil creador de SlackBuild en: Herramienta de Alien para un SlackBuild.

En estos días en SlackBuilds.org prefieren las presentaciones usando una plantilla de SlackBuild. Creo que sería bueno utilizar un script de SlackBuild que se encuentra actualmente en SlackBuilds.org. Para ello utilizaré el script de SlackBuild que envié para latex2html a Slackbuilds.org latex2html y que esta actualmente disponible para la versión de Slackware 14.2.

De esta manera, estamos hablando acerca de un script contemporáneo que se puede descargar, usar y con suerte relacionarte con el una vez que leas esto.

La otra cosa que hay que mencionar es que el contexto de esta página, cuando lo lees, con respecto a un script latex2html es que se ha descargado todo un “slackbuild” de slackbuilds.org, está en algún lugar conveniente (digamos en mi escritorio) que se desempaqueta y en el directorio desempaquetado llamado “latex2html” se ha colocado el código fuente del software llamado latex2html-2019.2.tar.gz.

Este script se ejecuta rápidamente de la siguiente forma:

bash-5.0# chmod a+x latex2html.SlackBuild 
bash-5.0# ./latex2html.SlackBuild 
Bash

En los días anteriores a Windows en Unix, un shell o Bourne Shell (Stephen Bourne, Bell Labs) fue una forma de comunicarse con el sistema. En reconocimiento a Stephen Bourne, Brian Fox lanzó una nueva versi{on en 1989 y la llamó *Bourne again Sh**ell (bash).

Si abrís una terminal en Slackware - es decir Menu → System → Console y tipeando en el $ prompt:

bash --version

, deberías conseguir algo como:

GNU bash, version 5.0.11(1)-release (x86_64-slackware-linux-gnu)
Copyright (C) 2019 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>

En términos simples, la entrada fue recibida y actuada. La entrada tiene una duración algo corta, ya que cuando cierras la ventana la entrada ha desaparecido.

Un script en bash en términos simples es un código en bash que puede ser salvado como un archivo en un disco duro.

La primer línea de un script en bash tiene la línea:

#!/bin/sh

Esto es comúnmente referido como un shebang. Esto define que el archivo es un shell script y también el camino al interprete shell.

Script SlackBuild

Hasta ahora hemos descrito que un script de SlackBuild es en esencia código bash presentado en una presentación más permanente de un archivo.

En la parte superior del archivo esta el shebang.

Después de esto, en línea con los requisitos de slackbuilds.org, las siguientes líneas son el nombre del paquete, quién escribió el script y opcionalmente se añade un aviso de copyright.

Intentaré revisar el 14.2 latex2html de slackbuild línea por línea. Si hay espacios en blanco, es un aviso para que otros contribuyan. Probablemente también significa que no entiendo completamente esa parte.
PRGNAM=latex2html
VERSION=${VERSION:-2019.2}
BUILD=${BUILD:-1}
TAG=${TAG:-_SBo}

Si miro el paquete que he instalado en mi actual Slackware de 64 bits es: latex2html-2019.2-x86_64-1_SBo. Ahora si miras la primera línea de arriba verás PRGNAM (nombre del programa). Esta es una variable y su valor se establece en la cadena latex2html.

La versión esta relacionada a la fuente del software; si vas a la pagina web fuentes de Latex, podrás observar que el código fuente es del 5 de junio de 2019. Por lo tanto, simplemente le he puesto un nombre a la versión después de esa versión. Para aquellos que están aprendiendo bash (yo todavía lo estoy): en la segunda línea VERSION= de la izquierda asigna un valor a la variable llamada VERSION.

Cuando se asigna un valor a la variable VERSION, ¿por qué usamos VERSION=${VERSION:-2019.2} y no simplemente VERSION=2019.2?
Tome la expresión ${VERSION}. Esto significa “el valor contenido en la variable VERSION”. La notación más compleja ${VERSION:-2019.2} significa “el valor contenido en la variable VERSION, pero si esa variable no tiene todavía un valor entonces usa el valor por defecto de '2019.2'”.
Así que esa segunda línea simplemente se reduce a VERSION=2019.2. Se puede establecer un valor para VERSION fuera del script: si especificaste un valor para VERSION en la línea de comandos de SlackBuild o si se ha definido en tu entorno Bash.

De la misma forma la variable TAG es configurada a SBo y cuando el paquete es creado esto muestra esto es un paquete “slackbuilt”. Si miras en los repositorio de los paquetes, deberías ver en el nombre del paquete que es de Alien Bob, por ejemplo chromium-77.0.3865.75-x86_64-1alien.

El próximo bloque de código es como sigue:

if [ -z "$ARCH" ]; then
  case "$( uname -m )" in
    i?86) ARCH=i586 ;;
    arm*) ARCH=arm ;;
    *) ARCH=$( uname -m ) ;;
  esac
fi

En un lenguaje de programación tales como php, python y otros incluyendo bash hay algunas practicas comunes y lógicas. Un principio común es el procedimiento de tener una prueba de código. Una evaluación es aplicada y por supuesto que habrá una salida dependiendo del resultado. Un ejemplo de una sentencia “if” en un script bash es:

if[ condición a evaluar]
then
código a ser ejecutado dependiendo del resultado
fi

En el bloque anterior, simplemente el “if” es el comienzo de una condición de prueba If y “fi” denota el final de una condición de prueba If.

Volviendo al bash por un minuto, se puede establecer una variable bash de la siguiente manera

ARCH=something

y podes obtener el valor de una variables y ver el valor de la variable “ARCH” colocando un signo dolar de la siguiente forma:

echo $ARCH

Una bandera (flag) -z puede ser utilizada en una sentencia “if” para ver si una cadena de texto esta vaciá. Así que echemos un vistazo a la primera línea de nuevo y averigüemos lo que significa.

if [ -z "$ARCH" ]; then

In the above we don't need to see the value of ARCH; as long as we can access its value and be able to use it in the script. So the first part before the “then” simply equates to , if the value of the variable ARCH is expressed as a string and its value is empty, do something. ARCH could represent a string value of the architecture of the PC the script is running on.

Another common algorithm is called in for instance php is the “switch statement” . This put in its simplest terms is a list and the test is to see if a certain value you have can be found in that list. If its not found you can place on the line last in the list would you would like to do, if nothing is matched.

In bash its in principle the same idea but its referred to as “case statement” .In principle you can put anything you like in the case block, but if you think about the fact we want to find out the “architecture” of a computer and already know there are only certain possibilities then it makes sense to try out a couple of known possibilities in the list first and if there is no match do something to get an answer. arm and i586 are of course two types of computer architecture.

Now if you try out this code in a terminal window:

uname -m 

it should display the architecture of you PC, in my case its x86_64.

So to summarize regarding the block of code. First an “if” statement is run to see if the variable “ARCH” is empty. If there is a value for the ARCH variable nothing in the block of the “if” and inner “case” will run;but if an empty string is found (ARCH has no value) a “case statement” is run(within the if block of code) to find a match.If a match was found the variable ARCH would be set to the value of the match found, and the execution of the case would come to a stop. If the ARCH variable was empty and no match was found in the case list , then the bottom line comes int play which is:

uname -m 

is used to get a result and ARCH set to the result.

Don't be fazed by the question mark in i?86 ,the question mark is a place holder that allows for possibilities via regex. it could be “3” (i386) , “6”( i686) etc.

Next block of code

CWD=$(pwd)
TMP=${TMP:-/tmp/SBo}
PKG=$TMP/package-$PRGNAM
OUTPUT=${OUTPUT:-/tmp}

Before we go into this let me have a look in my slackware file system and see whats there at /tmp/SBo.Taking a quick look at the image will give you a clue that the slackbuild works, by using the /tmp/SBo/ directory and creates a directory with the syntax package-packagename.So if we now have a look at the code above. CWD (current working directory) is a variable and is set to the value of pwd. If you run that in a terminal window, it will tell you where you in a bash context where you are working from.

TMP is going to be set to /tmp/SBo. Now lets have a look at

PKG=$TMP/package-$PRGNAM

You might guess PKG is going to be set for latex2html to :

/tmp/SBo/package-latex2html

If you look closely at the image (taking into account /tmp/SBo/ at top of image) you will see exactly that in the image.OUTPUT is set to /tmp

Next block of code:

if [ "$ARCH" = "i586" ]; then
  SLKCFLAGS="-O2 -march=i586 -mtune=i686"
  LIBDIRSUFFIX=""
elif [ "$ARCH" = "i686" ]; then
  SLKCFLAGS="-O2 -march=i686 -mtune=i686"
  LIBDIRSUFFIX=""
elif [ "$ARCH" = "x86_64" ]; then
  SLKCFLAGS="-O2 -fPIC"
  LIBDIRSUFFIX="64"
else
  SLKCFLAGS="-O2"
  LIBDIRSUFFIX=""
fi

Probably we need, before we look at the rest of the code for latex2html slackbuild to introduce some basic concepts.

Historically computer software is installed in a three step process called configure, make, make install. Configure gets ready to build the software , see if everything needed is there and builds a new make file. A make file is a file that contains instructions to build a program.

You can from the command line install software just using configure, make and make install. A slackbuild does the job of creating a package so that the process of installing is more manageable and reliable fashion. When you have a slackbuild downloaded on your system should there be a new release of source code its a simple matter of putting that source in your unpacked slackbuild and a quick edit to the slackbuild script.

Computer program source are written in “high level “ languages but are converted into a form that the computer can readily understand.Code written in the C language involves a C compiler converted it to binary.

The whole goal of any system installing a program, is that it should involve the concept of making it “tailor made” for the computer its being installed. Obviously that is going to involve the computer Architecture. During the compile process the system can be tweaked by passing in options from variables.

So lets now have a look at the block of code above. The block of code is simply an “if , else block” , where the code is executed top to bottom and amounts to -if the architecture is i586 set SLKFLAGS to .. if not go to next line.

CFLAGS and CXXFLAGS are variables holding values that can be passed in at compile time. We will see later that the variable SLKFLAGS will be used to set them.

Next block of code:

set -e
rm -rf $PKG
mkdir -p $TMP $PKG $OUTPUT
cd $TMP
rm -rf $PRGNAM-$VERSION
tar xvf $CWD/$PRGNAM-$VERSION.tar.gz
cd $PRGNAM-$VERSION
chown -R root:root .
find -L . \
 \( -perm 777 -o -perm 775 -o -perm 750 -o -perm 711 -o -perm 555 \
  -o -perm 511 \) -exec chmod 755 {} \; -o \
 \( -perm 666 -o -perm 664 -o -perm 640 -o -perm 600 -o -perm 444 \
  -o -perm 440 -o -perm 400 \) -exec chmod 644 {} \;

set -e: this stops the execution of the script if there is an error executing this code following this command
rm -rf $PKG: this deletes any previous directory (and contents) of package-latex2html at of /tmp/SBo/package-latex2html
mkdir -p $TMP $PKG $OUTPUT :mkdir with the “ -p ” flag creates directories, but only if they don't exist already.

that would be /tmp/SBo , /tmp/Sbo/package-latex2html, /tmp

Its unlikely that the SBo directory doesn't exist unless no other slackbuilds have been run in the past . /tmp should be there as default with the slackware installation.
cd $tmp : moves location where bash is working from to /tmp/SBo

rm -rf $PRGNAM-$VERSION will get rid of any previous directory entries(maybe failed) for latex2html-2019.2

tar xvf $CWD/$PRGNAM-$VERSION.tar.gz : This equated to unpacking of latex2html-2019.2.tar.gz , which would be inside the unpacked slackbuild from slackbuilds.org namely “latex2html”.

cd $PRGNAM-$VERSION : This is a “change directory” command. The bash shell will now be working from the context that is located inside the unpacked source, which is located $CWD. i.e We are back to the unpacked slackbuild but, inside the unpacked source.

chown -R root:root . : Notice the dot , with a space at the end of the line; this means all in current directory. -R is permission recursive. So here we are giving ownership to root and group root.

 find -L . \
 \( -perm 777 -o -perm 775 -o -perm 750 -o -perm 711 -o -perm 555 \
  -o -perm 511 \) -exec chmod 755 {} \; -o \
 \( -perm 666 -o -perm 664 -o -perm 640 -o -perm 600 -o -perm 444 \
  -o -perm 440 -o -perm 400 \) -exec chmod 644 {} \;

If i understand the above block of code correctly its using the “find” on the basis of permissions and following symbolic links using the “-L flag”. If i understand this correctly its basically setting directories to 755 in order to enable a “cd” into them and files so that root can read write. If this is true I might have expected

-type d -exec chmod 775 {} 

For directories and

-type f -exec chmod 644 {}

For files. Next block of code:

CFLAGS="$SLKCFLAGS" \
CXXFLAGS="$SLKCFLAGS" \
./configure \
  --prefix=/usr \
  --libdir=/usr/lib${LIBDIRSUFFIX} \
 A test is applied and of course there will be a result depending on the outcome. An example of a 
bash "if" block statement is:    
  --sysconfdir=/etc \
  --localstatedir=/var \
   --with-perl=/usr/bin/perl \
  --enable-eps \
  --enable-gif \
  --enable-png \
  --build=$ARCH-slackware-linux \
  --host=$ARCH-slackware-linux

make
make install DESTDIR=$PKG

A couple of things to say here , the use of “\” is a way of using a long command over several lines. We have already mentioned CFLAGS and CXXFLAGS. We also previously mentioned the variable SLKFLAGS and here we use it to set the value of CFLAGS and CXXFLAGS.

In this latex2html slackbuild script we also utilize a three step process of configure, make, make install. But what about the likes of –enable-eps , where does that come from ?

Well if you take the source code latex2html sourceunpack it ( a quick way is right click , open with Ark) cd into it and run :

./configure --help

Then you will get some useful information from the developers. It tells you the option and how you can enable some of them.

make
make install DESTDIR=$PKG

Here, make, make install are carried out.Note DESTDIR is a flag to say where the package will go.

$PKG equates to /tmp/SBo/package-latex2html

Next Block of code:

find $PKG -print0 | xargs -0 file | grep -e "executable" -e "shared object" | grep ELF \
  | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null || true

mkdir -p $PKG/usr/doc/$PRGNAM-$VERSION
cp -a \
 FAQ INSTALL LICENSE MANIFEST README.md TODO  \
  $PKG/usr/doc/$PRGNAM-$VERSION
cat $CWD/$PRGNAM.SlackBuild > $PKG/usr/doc/$PRGNAM-$VERSION/$PRGNAM.SlackBuild
cp $CWD/manual.pdf  $PKG/usr/doc/$PRGNAM-$VERSION

mkdir -p $PKG/install
cat $CWD/slack-desc > $PKG/install/slack-desc 

cd $PKG
/sbin/makepkg -l y -c n $OUTPUT/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.${PKGTYPE:-tgz}

The first two lines of this block are a bit of a mouth-full:

find $PKG -print0 | xargs -0 file | grep -e "executable" -e "shared object" | grep ELF \
  | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null || true

We can however pick out key words that are commands and that can help to make some sense of it. ind“ located at /usr/bin/find is a powerful utility that has around 50 options. It basically does what it says on the can.With the -print0 option it separates what it finds with “\000” - in a word NULL.

The “|” or pipe is used to pass the results of a command to another;in this case xargs which has a flag -0. This option is for xargs to accept input that has /000 between them. ELF is is Executable & Linkable Format.

To give a succinct answer the two lines are removing debugging symbols and other unnecessary stuff to make the binaries smaller, faster and take up less memory.

mkdir -p $PKG/usr/doc/$PRGNAM-$VERSION

Here we are preparing a directory which will be called “latex2html-2019.2” located at /usr/doc. This is so we an put relevant documentation into a directory relevantly called, so that a user can access documentation on the package. The next lines put files such as README.md into the /usr/doc/latex2html-2019.2 directory.

cat $CWD/$PRGNAM.SlackBuild > $PKG/usr/doc/$PRGNAM-$VERSION/$PRGNAM.SlackBuild

That line goes back to the original directory that Latex2html.SlackBuild was run from ( i previously quoted Desktop) opens up the SlackBuild with “cat” command and copies it to the documentation directory. Now before I submitted latex2html to slackbuilds obviously I did some testing and found that when the package was installed it had a fairly comprehensive output of what it could do just using:

$ latex2html --help

Also I had access to a comprehensive manual in pdf format; so in my case I did not write code for man pages. Instead I simply put a copy of “manual.pdf” into the /usr/doc/latex2html-2019.2 directory.

andy brookes 2020/01/05 16:29 (UTC)

Si enseñas matemáticas no te impide incrustar un poco de inglés. Una plantilla en blanco puede ser obtenida de: https://slackbuilds.org/templates/

Fuentes

Estoy usando un script de SlackBuild que envié a slackbuilds.org: latex2html slackbuild.

  • Escrito originalmente por andy brookes
  • Traducido por — rramp 2020/01/13 16:29 (UTC).


En otros idiomas
Traducciones de esta página?:
QR Code
QR Code es:howtos:misc:anatomy_of_a_slackbuild (generated for current page)