Lenguaje para programar PFS


Last Update: 16/11/03

Introducción

Para que PFS se comporte de la manera que nosotros deseamos, necesitamos poder decirselo mediante un lenguaje. COn dicho lenguaje le comunicaremos a PFS las accionesque tiene que hacer en determinadas situaciones. Estas indicaciones se hacen mediante reglas, las cuales escribimos en un fichero (fichero del álgebra), el cualserá leidopor el PFS cuando este sea arrancado. Vease página de manual.

El lenguaje con el que describiremos las reglas del álgebra lo definiremos a continuación de manera detallada.

La estructura básica del lenguaje estará formada por reglas de la siguiente manera:
    guardas
       acciones

Como se puede apreciar, las guardas son el antecedente de la regla y como consecuente tendremos una lista de acciones. Si la guarda se cumple, las acciones del consecuente se ejecutan, en caso contrario no se hará nada.


Para que todo quede más o menos claro desde ya mismo, vamos a poner un ejemplo de regla de programación de PFS.
       ifname= fichero1
          perm= 0700

Aunque todavia no sabemos nada de los tipos de guardas que tenemos, ni los tipos de acciones, queda bastante claro que la regla anterior quiere decir, que si hay un fichero que se llama "fichero1", se le cambien los permisos a 0700.

Como se puede apreciar las lineas del fichero del álgebra deben de estar separadas por un retorno de carro.


Tipos de guardas

La función de las guardas es la de asegurarse del cumplimiento de ciertas características. Esas características de ficheros pueden referirse a características de ficheros o a características de directorios. Por tanto se contemplas varios tipos de guardas.
   
    Guarda ifname -> Esta guarda evalua la condicion sobre el nombre del fichero en cuestión. Vamos a continuación a mostrar unos ejemplos de su uso:
                                        ifname= fichero1         Esta guarda devolvera cierto si el nombre del fichero es fichero1
                                        ifname!= fichero2       Esta guarda devolvera cierto si el nombre del fichero es distinto de fichero2

    Guarda ifuid -> Esta guarda evalua la condición sobre el nombre de usuario del fichero en cuestión. Vamos a continuación a mostrar unos ejemplos de su uso:
                                        ifuid= jvergara             Esta guarda devolvera cierto si el nombre de usuario del fichero es jvergara
                                        ifuid!= jvergara           Esta guarda devolvera cierto si el nombre de usuario del fichero es distinto de jvergara

    Guarda ifgid -> Esta guarda evalua la condición sobre el nombre de grupo del fichero en cuestión. Vamos a continuación a mostrar unos ejemplos de su uso:
                                        ifgid= jvergara            Esta guarda devolvera cierto si el nombre de grupo del fichero es jvergara
                                        ifgid!= jvergara          Esta guarda devolvera cierto si el nombre de grupo del fichero es distinto de jvergara

    Guarda ifperm -> Esta guarda evalua la condición sobre los permisos de un fichero en cuestión. Vamos a continución a mostrar unos ejemplos de su uso:    
                                        ifperm= 0777                Esta guarda devolvera cierto si los permisos del fichero son 0777
                                        ifperm!= 0777              Esta guarda devolvera cierto si los permisos del fichero son distintos de 0777 
   
    Guarda iflength-> Esta guarda evalua la condición sobre la longitud de un fichero en cuestión. Vamos a continuación a mostrar unos ejemplos de su uso:
                                        iflength= 200                Esta guarda devolvera cierto si la longitud del fichero es 200
                                        iflength!= 200              Esta guarda deviolvera cierto si la longitud del fichero es distinta a 200

                                        iflength> 200                Esta guarda devolvera cierto si la longitud del fichero es mayor que 200
                                        iflength!> 200              Esta guarda devolvera cierto si la longitud del fichero no es mayor que 200
         
                                        iflength< 200               Esta guarda devolvera cierto si la longitud del fichero es menor que 200
                                        iflength!<200              Esta guarda devolvera cierto si la longitud del fichero no es menor que 200

    Guarda especiales and y or -> Estas guardas se usan para evaluar condiciones sobre el cumplimiento de varias guardas para un mismo fichero. Son usadas con la notación matemática de predecendia de operadores. A continuación se exponen unos ejemplos de su uso:
                                        and ifname= f1 ifperm= 0700      Esta guarda devolvera cierto si el nombre del fichero es f1 y sus permisos son 0700.
                                        or and ifname=f1 ifperm= 0700 ifname= f2      Esta guarda devolvera cierto si el nombre del fichero es f1 y sus permisos son 0700 o bien devolvera cierto si el nombre del fichero es f2.


Como se puede apreciar con estas guardas ya se cubren muchas de las cosas que se quieren mirar sobre un fichero, pero puede que el usuario quiera hacer cosas más especificas. Por ejemplo, el usuario puede querer que se haga alguna operacion  con los permisos de un fichero, si el contenido del mismo tiene una determinada cadena de caracteres. Para no limitar la funcionalidad de PFS, se le ha dotado de una serie de guardas genericas para su programación con scripts externos por parte del usuario. Es decir, si un usuario lo desea, puede engachar su fichero de álgebra con un script externo. Veamos unos ejemplos para que queden más claros estos conceptos.
      
          Guarda iffile -> Esta guarda se encarga de pasar a un script externo el contenido de un fichero por la entrada estandar. La guarda se queda escuchando en la salida estandar, esperando a que el script externo, después de mirar lo que quiera sobrel contenido del fichero que le he pasado, me devuelva true o false.

                                        iffile /usr/jvergara/check_content      Esta guarda pasa el contenido del fichero que este tratando al script check_content por la entrada estandar. El script hará sus comprobaciones sobre ese contenido y después devolverá true o false.
                                        El contenido del script check_content es el siguiente:
                                              #!/bin/rc
                                              aux=`{cat |grep pass}
                                               if (test $aux '=' '') echo false
                                               if (!(test $aux '=' '')) echo true

                                        Como se puede ver, comprueba si el contenido del fichero tiene la palabra pass y si es asi devuelve true, por tanto la guarda se cumpliría.
      
             Guarda ifattr -> Esta guarda es como la anterior pero sobre los atributos de un fichero. Es decir, al script externo se le pasarán los atributos del fichero, uno por línea. Después el script ya se encargará de devolver true o false segun se cumplan ciertas cosas sobre esos atributos.
            
                                           ifattr  /usr/jvergara/check_uid         Esta guarda pasa el contenido del fichero que este tratrando al script check_uid por la entrada estandar, escribiendo un atributo por linea. El script hará sus comprobaciones sobre esos atributos y después devolverá true o false. El orden en que se le pasarán los atributos al script es: name, uid, gid, muid, length, mode, atime, mtime.

                                           El contenido del script check_uid es el siguiente:
                                               #!/bin/rc
                                               aux=`{cat |sed 2q | tail -1l}
                                               if (test $aux '=' jvergara)     echo true
                                               if (test $aux '!=' jvergara) echo false

                                           Como se puede ver, el script comprueba si la linea 2 que le han pasado es jvergara, si es asi devuelve true, sino false.
         

               Guarda ifdir -> Esta guarda es muy interesante para poder hacer comprobaciones sobre el contenido de un directorio. Ifdir pasará al script el path de un directorio que esta trantando para que el script haga las comprobaciones que desee y después devuelva true o false como en los dos casos anteriores.
       
                                            ifdir  /usr/jvergara/check_dir        Esta guarda pasa el path del directorio al script check_dir, para que este haga un ls sobre él y devuelva true si ese directorio contiene el fichero de nombre f1d1. Si no devuelve false.
   
                                           El contenido del script check_dir es el siguiente:
                                                #!/bin/rc
                                                aux=`{cat |sed 1q}
                                                direntry=`{ls $aux| grep f1d1}
                                                if (test $direntry '=' '') echo false
                                                if (!(test $direntry '=' '')) echo true

                                            Como se puede ver, el script comprueba si en en el listado de directorio se encuentra el fichero f1d1, si es asi devuelve true, sino false.                                                                                 

Tipos de acciones

Las funciones de las acciones es realizar cambios en el sistema de ficheros "al vuelo". Esos cambios son hechos sobre el contenido de un fichero, o sobre el contenido de un directorio, o sobre los atributos de un fichero... por esto tenemos varias acciones.

    Acción name= -> Esta acción cambia el nombre de un fichero. Ejemplo:
                                        name=f1
   
    Acción uid= -> Esta acción cambia el nombre de usuario de un fichero. Ejemplo:
                                        uid=jvergara
   
    Acción gid= -> Esta acción cambia el nombre de grupo de un fichero. Ejemplo:
                                        gid=jvergara
     
    Acción perm= -> Esta acción cambia los permisos de un fichero. Ejemplo:
                                        perm=0700

    Acción content= -> Esta acción cambia el contenido de un fichero. Ejemplo:
                                        content= Este es el nuevo contenido del fichero
   
    Acción rm= -> Esta acción borra un fichero. Ejemplo:
                                        rm= /usr/jvergara/varios/log

Con este conjunto de acciones se cubren bastantes de las cosas más comunes que se pueden querer hacer sobre los ficheros. Ahora bien, al igual que pasaba con las guardas, no podemos limitar la funcionalidad de PFS, asi es que se pueden usar acciones apoyandose en scripts externos.

    Acción file= -> Esta acción pasa al script por la entrada estandar el contenido del fichero para que este lo cambie a su gusto o lo sustituya por uno nuevo escribiendo el nuevo contenido por la salida estandar.
         
                                  file= /usr/jvergara/change_content      Esta acción pasa a change_content el contenido del fichero en cuestion. El script change_content se encarga de cambiarlo.

                                  El contenido del script es el siguiente:
                                     #!/bin/rc
                                    cat > /dev/null
                                    echo No podemos mostrar este fichero porque contenia material privado....
                                 
                                   El script tira el contenido que le pasan y pone el nuevo contenido en la salida estandar.

    Acción attr= -> Esta acción pasa al script por la entrada estandar los atributos edl fichero (uno por linea), para que este los cambie y los devuelva escrbiendo por la salida estandar.
      
                                    attr= /usr/jvergara/change_perm      Esta acción pasa a change_perm los atributos del fichero en cuestión. El script change_perm, se encarga de cambiar en este caso uno de ellos, los permisos del fichero.

                                     El contenido del script es el siguiente:
                                         #!/bin/rc
                                        cat > /tmp/total.attrs
                                        aux=`{cat /tmp/total.attrs |sed 1q |tail -1l}
                                        echo $aux
                                        aux=`{cat /tmp/total.attrs|sed 2q |tail -1l}
                                        echo $aux
                                        aux=`{cat /tmp/total.attrs|sed 3q |tail -1l}
                                        echo $aux
                                        aux=`{cat /tmp/total.attrs|sed 4q |tail -1l}
                                        echo $aux
                                        aux=`{cat /tmp/total.attrs|sed 5q |tail -1l}
                                        echo $aux
                                        echo 0700
                                        aux=`{cat /tmp/total.attrs|sed 7q |tail -1l}
                                        echo $aux
                                        aux=`{cat /tmp/total.attrs|sed 8q |tail -1l}
                                        echo $aux
            
                                        Devuelve todas las lineas tal cual menos una
                                    
    Acción addfile= -> Esta acción hace una lectura de los atributos y el contenido de un fichero nuevo que un script le pasa por la salida estandar para crear un nuevo fichero. Esta acción pasa al script el path actual.
         
                                         addfile=/usr/jvergara/add_log      Esta acción pasa a add_log el path actual y este le escribe por la salida estandar los atributos del nuevo fichero que quiere crear y el contenido del fichero.

                                          El contenido del script es el siguiente:

                                            #!/bin/rc
                                            aux=`{cat |sed 1q}
                                            echo log
                                            echo jvergara
                                            echo jvergara
                                            echo jvergara
                                            echo 200
                                            echo 0755
                                            echo -2147483155
                                            echo 0
                                            echo F
                                            echo $aux/log
                                            echo Directorio contiene f1d1....
                        
                                            Hay que destacar que en el caso de la longitud del fichero o el tiempo de creación, PFS se encarga de corregirlo, da igual que escribamos  -2147483155 o que digamos que el fichero tiene longitud 200, se corrige solo al crear el fichero, no nos tenemos que preocupar. Se puede dar cualquier número en el caso de length, atime y mtime. Eso si, el orden es importante, y el name, uid, gid, muid, length, perm, atime, mtime, tipo de fichero (F fichero, Ddirectorio), path y contenido.

    Acción delfile= -> Esta acción pasa al script el  path del fichero al que la regla se refiere la regla. El script escribe por la salida estandar el path del fichero a borrar, bien puede ser el mismo al que se refiere la regla y que me pasan por la entrada estandar, o puede ser otro.

                                        delfile= /usr/jvergara/hide_file      Esta acción pasa a hide_file el path del fichero actual de la regla y el script lo escribe por la salida estandar para que sea borrado.

                                        El contenido del script es el siguiente:
         
                                         #!/bin/rc
                                        aux=`{cat |sed 1q}
                                        echo $aux

    Acción naddfile= -> Esta acción hace la lectura de los atributos de varios ficheros y su contenido, es parecida a addfile pero añade varios fichero de una sola acción.

                                        naddfile= /usr/jvergara/add_varios   Esta accion pasa a add_varios el path actual y este le escribe por la salida estandar los atributos de los ficheros que quiere crear y su contenido.

                                        El contenido del script es el siguiente:
            
                                           #!/bin/rc
                                            aux=`{cat |sed 1q}
                                            echo log
                                            echo jvergara
                                            echo jvergara
                                            echo jvergara
                                            echo 200
                                            echo 0755
                                            echo -2147483155
                                            echo 0
                                            echo F
                                            echo demo/log
                                            echo Directorio contiene f1d1....
                                            echo ~~~*~~~
                                            echo log2
                                            echo jvergara
                                            echo jvergara
                                            echo jvergara
                                            echo 200
                                            echo 0755
                                            echo -2147483155
                                            echo 0
                                            echo F
                                            echo demo/log2
                                            echo Directorio contiene f1d1....
                                            echo ~~~*~~~

                                        El delimitador ~~~*~~~ marca el fin de la descripción de un fichero.  Por lo demás es igual que addfile.

       Acción ndelfile= -> Esta acción pasa al script por la entrada estandar el path actual y el script escribe por la salida estandar los path de los ficheros que queremos que sean borrados de una sola vez.

                                        ndelfile= /usr/jvergara/hide_all        Esta acción pasa a hide_all el path actual y este le escribe por la salida estandar el path de todos los ficheros que el path actual contiene. Es decir, el path actual es un directorio y queremos borrar todo su contenido.
                     
                                         El contenido del script es el siguiente:
                                              #!/bin/rc
                                              aux=`{cat |sed 1q}
                                              nline=`{ls $aux |wc -l}
                                              cont=`{seq 1 $nline}
                                              for(i in $cont) @{
                                                    v=$i'q'
                                                    item=`{ls $aux|sed $v |tail -1l}
                                                    echo $item
                                               }
   


Aqui encontraras fichero de álgebra de ejemplos y scripts externos que te harán su uso más facil!!! (proximamente)