Simulacion de analisis REMAYS en XSB
Copyright © 2002 Oscar Medina Duarte
Bajo licencia BSD
http://www.medina-web.com
Introducción
REMAYS es un intento por generalizar una especificacion
de monitoreo con analisis automatizado de eventos, que
permita analizar los datos, con un rendimiento cercano
al tiempo real en una arquitectura flexible que permita
configuraciones redundantes, distribuidas y/o centralizadas.
Analisis en XSB
El analisis en XSB en este proyecto, consistio de 2 etapas,
la primera traducir las reglas tipo remays, en reglas de dlv,
y la segunda, implementar algunas reglas en XSB que trabajando
en conjunto, funcionen aceptablemente.
Para acoplar las reglas principales junto con las generadas
a partir de nuestro "traductor", es necesario concatenarlas.
La traducción
En esta primera versión, solamente se realizo una traducción lexica
es decir, que solamente partiendo de reglas gramaticalmente correctas,
es posible obtener una salida XSB correcta. De lo contrario, el programa
obtenido en XSB tendra muy probablemente errores de sintaxis.
Ejemplos de traducciones
| REMAYS | XSB |
trigger00{
e.source == 140.148._._;
writeln(' Segmento de red de la UDLA ');
}
|
%%%%%%%%%%%%%%%
%% trigger00 %%
%%%%%%%%%%%%%%%
trigger00(N,[C,U],I,A) :- I = [140,148,_,_] ,
(writeln(' Segmento de red de la UDLA '); not writeln(' Segmento de red de la UDLA ')).
|
trigger07{
e.class.name==e.name&&@trigger05;
writeln(' Clase y nombre identicos ');
}
|
%%%%%%%%%%%%%%%
%% trigger07 %%
%%%%%%%%%%%%%%%
trigger07(N,[C,U],I,A) :- C = N , trigger05(N,[C,U],I,A),
(writeln(' Clase y nombre identicos '); not writeln(' Clase y nombre identicos ')).
|
trigger08{
($Yy = 100) && (e.1 == $Yy);
writeln(' Uso simple de variables ');
}
|
%%%%%%%%%%%%%%%
%% trigger08 %%
%%%%%%%%%%%%%%%
trigger08(N,[C,U],I,A) :- ( Yy is 100 ) , ( _1 = Yy ) ,
A = [_,_1|T],
(writeln(' Uso simple de variables '); not writeln(' Uso simple de variables ')).
|
Asi mismo, es generada una regla para llamar a cada una de las otras reglas,
sin importar si se cumplen o no para que todas sean evaluadas cada vez,
para nuestro ejemplo, esta regla es como sigue :
detonan(N,[C,U],I,A) :- writeln(' Detonan '),
(trigger00(N,[C,U],I,A); not trigger00(N,[C,U],I,A)),
(trigger01(N,[C,U],I,A); not trigger01(N,[C,U],I,A)),
(trigger03(N,[C,U],I,A); not trigger03(N,[C,U],I,A)),
(trigger04(N,[C,U],I,A); not trigger04(N,[C,U],I,A)),
(trigger05(N,[C,U],I,A); not trigger05(N,[C,U],I,A)),
(trigger06(N,[C,U],I,A); not trigger06(N,[C,U],I,A)),
(trigger07(N,[C,U],I,A); not trigger07(N,[C,U],I,A)),
(trigger08(N,[C,U],I,A); not trigger08(N,[C,U],I,A)),
(peligro(N,[C,U],I,A); not peligro(N,[C,U],I,A)).
La gramática
Existen dos niveles a los que podemos hablar de gramatica,
el primero para esta implementación es en XSB, donde se
reciven y verifican los eventos, y el segundo son
las reglas que modelan el comportamiento del sistema.
Nivel XSB
Para verificar la validez de los eventos, fue necesario
definir la sintaxis del paquete de este modo:
:- op(300,fx,'{').
:- op(200,xfx,';').
:- op(100,fx,'}').
{N;[C,U];I;A}:- ((age(N,a),age(z,N))|(age(N,'A'),age('Z',N))),
((age(C,a),age(z,C))|(age(C,'A'),age('Z',C))),
(age(U,0),age(9,U)),
I=[X,Y,Z,P],(X>0,X<256),(Y >= 0,Y =< 255),(Z >=0,Z =<255),
(P>0,P<256),
imprimeB(N,[C,U],I,A,'log.txt'),
imprime(N,[C,U],I,A),
detonan(N,[C,U],I,A).
Donde, hacemos verificacion del nombre del evento (N), la clase del evento (C),
el PID del evento sea un numero (U), y la IP (I) sea valida.
Un ejemplo de paquete valido podria ser como sigue:
{bsu;[su,23];[140,148,20,3];[today,100]}.
Nivel REMAYS
A este nivel, la sintaxis pretende ser intuitiva,
y facil de traducir a XSB, por lo que no es posible
aun hacer cosas muy complejas, pero aun con la complejidad
restringida su funcionalidad es aceptable.
Para que esto sea posible, es necesario hacer el traductor
más complejo, y tomar en cuenta la gramatica, con lo
que seria posible hacer traducciones de expresiones
mas complejas.
La forma general de una regla REMAYS es como sigue :
nombre{
expresion;
funcion1();
funcion2();
.
.
.
funcionn();
}
Donde "nombre" sera un hecho, mismo que podra usarse como tal o como
funcion, la diferencia entre uno y otro es que en el hecho es importante
que se cumpla, mientras que la funcion, no importa si se cumple o no,
solo se evalua.
expresion es una expresion logica, que permite un uso limitado de variables
y hechos, las variables son usadas para dar la sensacion de poder
hacer asignaciones a cosas alternativas, ya que su traducion a XSB es dificil.
funciones son hechos de los que se va a ignorar su resultado, solo van a
intentar ser ejecutados, tengan exito o no, esto con dos motivos, el primero
es para que todos sean evaluados y el segundo es para dar al
programador de reglas, la sensacion de trabajar con un lenguaje
más procedural que logico.
Sintaxis
Dados los detalles de la gramatica anteriores, es importante notar
que la sintaxis aún es bastante estricta en cuanto al formato.
Nombre de la regla REMAYS
Esta debe empezar con letra y no llevar espacio entre la llave "{" y el
nombre, no puede llevar caracteres especiales o reservados.
Expresión
Los principales operadores son comparadores y logicos, los
operadores bitwise deben usar variables para poder ser
usados, su uso no es muy recomendado ya que su comportamiento aun
no ha sido probado suficientemente.
Operadores
A continuación se presenta una lista de los
operadores con una breve descripción:
Operandos
Estos son evaluados por XSB como variables, y su significado/tratuccion
es de acuerdo a los siguientes criterios.
Simbolos de evento
Cada evento de la forma :
{'Nombre';['Clase',PID];IP;Lista}.
Donde PID es un valor entero, IP es una lista con cada octeto valido
de una direccion IP [127,0,0,1] y Lista es una lista de parametros referentes al evento.
Tiene su correspondiente simbolo en la sintaxis de remays de la siguiente
forma:
| Canonico | REMAYS | XSB |
| Nombre | e.name | N |
| Clase | e.class.name | C |
| PID | e.class.pid | U |
| IP | e.souce | I |
| Lista | e.n1 | _n |
1.- Donde n es un indice que apunta a un elemento de
a Lista empezando en e.0
Variables
Los nombres de variables deben ser precedidos por un "$" y su primera
letra debe ser mayuscula por ejemplo $Variable es traducido a XSB
como : Variable.
Hechos
Para incluir un hecho de XSB este debe ser precedido por "@" para indicar
que se trata de un hecho y no de una funcion, mismo que es traducido de la
siguiete forma :
En remays :
@unhecho
En XSB :
unhecho(N,[C,U],I,A)
Funciones
Las funciones tienen la siguiente forma:
nombre(parametros);
estas son traducidas a XSB de la siguiente forma:
(nombre(parametros); not nombre(parametros))
lo que significa que su "resultado" no va a importar
en la ejecución del programa.
Uso
El traductor :
t2x.l
Las reglas basicas :
remays.pH
El primer paso es compilar el traductor:
$ flex t2x.l
$ cc -o t2x lex.yy.c -ll
$
El segundo paso es traducir las reglas a XSB:
$ t2x test.trg sale.P
Leyendo reglas desde test.trg
Escribiendo remays a sale.P
$
Hecho esto, el siguiente paso es concatenar
el programa generado al programa base:
$ cat remays.pH sale.P > reglas.P
$
Ahora ya tenemos nuestro programa completo listo
para cargar en XSB !
$ xsb
[xsb_configuration loaded]
[sysinitrc loaded]
[packaging loaded]
XSB Version 2.2 (Tsingtao) of April 20, 2000
[sparc-sun-solaris2.6; mode: optimal; engine: chat; scheduling: batched]
| ?- [reglas].
.
.
.
| ?- {bsu;[su,23];[140,148,20,3];[today,100]}.
{bsu;[su,23];[140,148,20,3];[today,100]}.
Detonan
Segmento de red de la UDLA
Ojo bad su at: [140,148,20,3]
PID menor que 1000
Segmento de red de la UDLA
Ojo bad su at: [140,148,20,3]
Peligro : Bad su en nuestra red !!!
yes
| ?- {evt1;[su,2000];[140,148,5,175];[today,algo]}.
{evt1;[su,2000];[140,148,5,175];[today,algo]}.
Detonan
Segmento de red de la UDLA
evt1 pid mayor que 100
Segmento de red de la UDLA
Segmento de red de la UDLA
Segmento de red de la UDLA
Segmento de red de la UDLA
yes
| ?- halt.
End XSB (cputime 0.77 secs, elapsetime 202.13 secs)
$