parser.c

Go to the documentation of this file.

#include "parser.h"
#include "structs.h"
#include "constants.h"
#include "FilterSpec.h"
#include "StreamSpec.h"
#include "Layout.h"
#include "FilterData/Policies.h"
#include "Hosts.h"

// global: parser state
static State state = start, lastState = start;
static char errorMsg[200];

static char *stateNames[] = {
                "start", "prehost", "hostdec","preplace", 
                "placement", "prelay", "layout", 
                "preend", "end", "resources", "filter", 
                "stream", "fromto", "tostream", 
                "error", "parseerror" 
};

static int currentHostIndex; //the host index we are reading resources
static FilterSpec *currentFilter = NULL; // the filter we are reading
static StreamSpec *currentStream = NULL; //the stream we are reading
static int remainingInstances, instances; //each filter runs on X hosts, we use this variable to control this


/*! \file parser.c This file parses the conf.xml, using the expat lib  */

/// this functions is called whenever a tag is open. 
void abreTag(void *userData, const XML_Char *name, const XML_Char **atts){
        Layout *systemLayout = (Layout*)userData;

        lastState = state;
        switch (state){
                case start:
                        //we expect config tag here
                        if (strcasecmp("config", name) ==  0)
                                state = prehost;
                        else {
                                strcpy(errorMsg, "Expecting <config>\n");
                                state = error;
                        }
                break;
                case prehost:
                        //we expect hostdec tag here
                        if (strcasecmp("hostdec", name) ==  0){
                                state = hostdec;
                        }
                        else {
                                strcpy(errorMsg, "Expecting <hostdec>\n");
                                state = error;
                                return;
                        }
                break;
                case hostdec:
                        //we expect host tag here
                        if (strcasecmp("host", name) !=  0){
                                strcpy(errorMsg, "Expecting <host name=\"\" [weight=\"\"]/>\n");
                                state = error;
                                return;
                        }


                        int wi = -1, ni = -1, mi = -1, weight, mem = -1;
                        int i=0;
                        char *hname;

                        while (atts[i] != NULL){
                                if (strcasecmp(atts[i], "name") == 0){
                                        ni= i+1;        
                                }
                                else if (strcasecmp(atts[i], "weight") == 0){
                                        wi = i+1;
                                }
                                else if (strcasecmp(atts[i], "mem") == 0){
                                        mi = i+1;
                                }
                                else {
                                        strcpy(errorMsg, "Expecting name or weight attribute\n");
                                        state = error;
                                        return;
                                }
                                i += 2;
                        }

                        if (ni == -1){
                                strcpy(errorMsg, "Expecting <host name=\"\" [weight="" mem=""]/>\n");
                                state = error;
                                return;
                        }
                        else {
                                hname = strdup(atts[ni]);
                        }

                        if (wi == -1){
                                weight = 1;
                        }
                        else {
                                weight = atoi(atts[wi]);
                        }

                        //memory: if mem == -1, filter must autodetect memory
                        //reading /proc/meminfo
                        if (!((mi == -1) || (strcasecmp(atts[mi], "auto") == 0 ))){
                                int len = strlen(atts[mi]);
                                int unitType = 0; // 0 = MB(default), 1 = GB

                                //skip trailing B if exists
                                if ((atts[mi][len-1] == 'B') || (atts[mi][len-1] == 'b')){
                                        len--;
                                }
                                
                                //find the unit of memory
                                if ((atts[mi][len-1] == 'G') || (atts[mi][len-1] == 'g')){
                                        unitType = 1;
                                        len --;
                                }
                                else if ((atts[mi][len-1] == 'M') || (atts[mi][len-1] == 'm')){
                                        unitType = 0;
                                        len --;
                                }
                                else if ((atts[mi][len-1] == 'T') || (atts[mi][len-1] == 't')){
                                        unitType = 2;
                                        len --;
                                }
                                mem = atoi(atts[mi]) * pow((double)1024, (double)unitType);
                        }


                        //add the host, but no duplicates
                        int hindex = hostsAdd(systemLayout->hostsStruct);
                        if (hostsSetName(systemLayout->hostsStruct, hindex, hname) == -1 ) {
                                state = error;
                                sprintf(errorMsg, "Could not add host %s", hname);
                                return;
                        }
                        hostsSetWeight(systemLayout->hostsStruct, hindex, weight);
                        hostsSetMemory(systemLayout->hostsStruct, hindex, mem);
                        printf("\tparser.c: host %s added to the Void enviroment, weight %d\n", hname, weight);
                        free(hname);
                        state = resources; //we go reading resources
                        currentHostIndex = hindex;
                break;
                case resources:
                {
                        //here we read resources for a given host
                        if (strcasecmp(name, "resource") != 0){
                                sprintf(errorMsg, "Error, expecting <resource tag>");
                                state = error;
                                return;
                        }

                        int rni = -1, i=0; //resource name index
                        char resourceName[MAX_RNAME_LENGTH+1];
                        //read resource name
                        while (atts[i] != NULL) {
                                if (strcasecmp("name", atts[i]) == 0){
                                        rni = i+1;
                                }
                                else {
                                        sprintf(errorMsg, "Error, expecting <resource name=\"\">");
                                        state = error;
                                        return;
                                }
                                i+=2;
                        }

                        if (rni == -1){
                                sprintf(errorMsg, "Resource name is mandatory");
                                state=error;
                                return;
                        }
                        else {
                                strncpy(resourceName, atts[rni], MAX_RNAME_LENGTH);
                        }

                        HostsStruct *hs = systemLayout->hostsStruct;
                        if (hostsAddResource(hs, currentHostIndex, resourceName) < 0){
                                sprintf(errorMsg, "Error adding resource %s: too many resources for host %s", 
                                                resourceName, hostsGetName(hs, currentHostIndex));
                                state = error;
                                return;
                        }
                        printf("\t\tparser.c: resource %s added to host %s\n", resourceName, hostsGetName(hs, currentHostIndex));
                        //no state change
                }
                break;
                case preplace:
                        //expect placement tag
                        if (strcasecmp("placement", name) == 0)
                                state = placement;
                        else {
                                strcpy(errorMsg, "Expecting <placement>");
                                state = error;
                        }
                break;
                case placement:
                {
                        char filterName[MAX_FNAME_LENGTH+1], libname[MAX_LNAME_LENGTH+1];
                        int nameInd = -1, libInd = -1, instInd=-1, i=0;
                        instances=-1;

                        // we read the filter entry here
                        if ( (strcasecmp("filter", name) != 0) ){
                                state = error;
                                strcpy(errorMsg, "Expecting <filter name=\"filtername\" [instances=\"N\" libname=\"library.so\"] >");
                                return;
                        }

                        //filter attributes
                        while (atts[i] != NULL){
                                if ( strcasecmp(atts[i], "name") == 0 ){
                                        nameInd = i+1;
                                        //mandatory
                                }
                                else if ( strcasecmp(atts[i], "libname") == 0 ){
                                        libInd = i+1;
                                        //optional: default is to use libNAME.so
                                }
                                else if ( strcasecmp(atts[i], "instances") == 0 ){
                                        instInd = i+1;
                                        //optional: defaults to 1
                                }
                                else {
                                        state = error;
                                        strcpy(errorMsg, "Expecting <filter name=\"filtername\" [instances=\"N\" libname=\"library.so\"] >");
                                        break;
                                }
                                i+=2;
                        }

                        //name is mandatory
                        if (nameInd == -1){
                                state = error;
                                strcpy(errorMsg, "Name attribute is mandatory, expecting <filter name=\"filtername\" [instances=\"N\" libname=\"library.so\"] >");
                                return;
                        }
                        else { //get the name
                                strncpy(filterName, atts[nameInd], MAX_FNAME_LENGTH);
                                filterName[MAX_FNAME_LENGTH] = '\0';
                        }

                        // if we did not receive the library name, we add lib and .so to filtername
                        if (libInd == -1){ 
                                sprintf(libname, "lib%s.so", filterName);
                        }
                        else { //else we use library from user
                                strncpy(libname, atts[libInd], MAX_LNAME_LENGTH);
                                libname[MAX_LNAME_LENGTH] = '\0';
                        }

                        //get optional number of instances
                        if (instInd == -1){
                                instances = -1; //default value, auto detect
                                remainingInstances = 1; //we spawn at least 1 instances
                        }
                        else {
                                instances = atoi(atts[instInd]);
                                remainingInstances = instances; //we'll spawn this number of instances
                        }

                        //create the filter!
                        currentFilter = createFilterSpec(filterName, libname);
                        if (instances == -1){
                                printf("\tparser.c: reading filter %s, library %s, auto number of instances\n", filterName, libname);
                        }
                        else {
                                printf("\tparser.c: reading filter %s, library %s, %d instances\n", filterName, libname, instances);
                        }

                        //update state
                        state = filter;
                }
                break;
                case filter:
                {
                        //read the hosts of each filter
                        if (strcasecmp("instance", name) != 0){
                                //error, did not receive host
                                state = error;
                                strcpy(errorMsg, "Expecting <instance demands=\"hostname or resource\" [qty=\"n\"]/>, n >");
                                return;
                        }

                        int demandInd = -1, numInstInd = -1; //attribute index
                        int i = 0;
                        
                        while (atts[i] != NULL){
                                // even indexes are attribute names
                                // odd indexes are values
                                //ex: <host name="bla"/>
                                //atts[0]=name, atts[1]=bla, atts[2]=NULL
                                if (strcasecmp(atts[i], "demands") == 0){
                                        demandInd = i+1;
                                }
                                else if (strcasecmp(atts[i], "numinstances") == 0){
                                        numInstInd = i+1;
                                } 
                                else {
                                        state = error;
                                        strcpy(errorMsg, "Expecting <host name=\"hostname\" [numinstances=\"n\"]/>, n > 0");
                                        return;
                                }
                                i+=2;
                        }

                        if (demandInd == -1){
                                state = error;
                                strcpy(errorMsg, "Instance must demand something, either a hostname or a resource");
                                return;
                        }

                        //we declared N instances, and are trying to spawn more
                        if ((instances != -1) && (remainingInstances <= 0)){
                                printf("\t\tparser.c: WARNING: ignoring instance, %d declared\n", instances);
                                return;
                        }

                        int numInstances = 1;
                        //how many instances, default value is 1
                        if (numInstInd != -1){
                                numInstances = atoi(atts[numInstInd]);
                        }
                        
                        for (i=0;i<numInstances;i++){
                                HostsStruct *hs = systemLayout->hostsStruct;
                                //resource name
                                char resourceName[MAX_RNAME_LENGTH+1];
                                strncpy(resourceName, atts[demandInd], MAX_RNAME_LENGTH);

                                //here we add the host to the filter
                                //first we try to get a host with the resource. If not found, we try to get the host with the given name
                                int hostIndex = hostsGetIndexByResource(hs, resourceName);
                                if (hostIndex == -1){
                                        //try to get host by name
                                        hostIndex = hostsGetIndexByName(hs, resourceName);
                                        if (hostIndex == -1){
                                                sprintf(errorMsg, "Error, resource %s invalid or host not found", resourceName);
                                                state = error;
                                                return;
                                        }
                                }

                                char hostname[MAX_HNAME_LENGTH+1];
                                strcpy(hostname, hostsGetName(hs, hostIndex));
                                printf("\t\tparser.c: host %s running this filter\n", hostname);

                                addHostToFilter(currentFilter, hs->hosts[hostIndex].name);
                                remainingInstances--;
                        }
                        break;
                }
                case prelay:
                        //reads <layout>
                        if (strcasecmp("layout", name) == 0)
                                state = layout;
                        else {
                                state = error;
                                strcpy(errorMsg, "Expecting <layout>");
                                return;
                        }
                break;
                case layout:
                        //reads stream
                        if (strcasecmp("stream", name) == 0){
                                state = stream;

                                //creates the stream
                                currentStream = createEmptyStreamSpec();
                        }
                        else {
                                state = error;
                                strcpy(errorMsg, "Expecting <stream>");
                                return;
                        }

                break;
                case stream:
                        //reads <from />
                        if (strcasecmp(name, "from") == 0){
                                int filInd = -1, portInd = -1, polInd = -1, polibInd = -1;
#ifdef VOID_TERM
                                int breakLoop = 0;
#endif
                                char filterName[MAX_FNAME_LENGTH+1], portName[MAX_PTNAME_LENGTH+1], 
                                        policyName[MAX_PLNAME_LENGTH+1], polibName[MAX_PLNAME_LENGTH+1];
                                int i=0;
                                //dont want to read junk
                                policyName[0] = '\0';
                                polibName[0] = '\0';
                                filterName[0] = '\0';
                                portName[0] = '\0';

                                while (atts[i] != NULL){
                                        if ( strcasecmp(atts[i], "filter") == 0 ){
                                                filInd = i+1;
                                                strncpy(filterName, atts[i+1], MAX_FNAME_LENGTH);
                                                filterName[MAX_FNAME_LENGTH] = '\0';
                                        }
                                        else if ( strcasecmp(atts[i], "port") == 0 ){
                                                portInd = i+1;
                                                strncpy(portName, atts[i+1], MAX_PTNAME_LENGTH);
                                                portName[MAX_PTNAME_LENGTH] = '\0';
                                        }
                                        else if ( strcasecmp(atts[i], "policy") == 0 ){
                                                polInd = i+1;
                                                strncpy(policyName, atts[i+1], MAX_PLNAME_LENGTH);
                                                policyName[MAX_PLNAME_LENGTH] = '\0';
                                        }
                                        else if ( strcasecmp(atts[i], "policyLib") == 0 ){
                                                polibInd = i+1;
                                                strncpy(polibName, atts[i+1], MAX_PLNAME_LENGTH);
                                                polibName[MAX_PLNAME_LENGTH] = '\0';
                                        }
#ifdef VOID_TERM
                                        else if ( strcasecmp(atts[i], "breakLoop") == 0){
                                                if ( strcasecmp(atts[i+1], "yes") == 0){
                                                        breakLoop = 1;  
                                                }else if ( strcasecmp(atts[i+1], "no") != 0){
                                                        state = error; // exist break loop but its not true or false
                                                }
                                        }
#endif
                                        else {
                                                //invalid attribute
                                                state = error;
                                        }

                                        i+=2;
                                }

                                if ( (filInd == -1) || (portInd == -1) || (state == error) ) {
                                        state = error;
                                        strcpy(errorMsg, "Expecting <from filter=\"filter_name\" port=\"port_name\" [policy=\"policy_name\" policyLib=\"\"] />");
                                }
                                else {
                                        //default policy
                                        if (strlen(policyName) == 0)
                                                strcpy(policyName, "rr");
                                        
                                        //lets set stream origin
                                        // fills stream FROM part
                                        if (!setFrom(currentStream,
                                                getFilterSpecByName(systemLayout, filterName),
                                                portName, policyName, polibName
#ifdef VOID_TERM
                                                , breakLoop
#endif
                                                )){
                                                state = error;
                                                strcpy(errorMsg, "Invalid Policy or labeled stream requires a policy lib name");
                                                return;
                                        }
                                        if (polInd != -1)
                                                printf("\tparser.c: filter %s:%s(%s) writes to ", filterName, portName, policyName);
                                        else
                                                printf("\tparser.c: filter %s:%s(default policy) writes to ", filterName, portName);

                                }
                        }
                        else {
                                state = error;
                                strcpy(errorMsg, "Expecting <from filter=\"filter_name\" port=\"port_name\" [policy=\"policy_name\"] />");
                        }

                break;
                case fromto:
                        //reads stream <to />
                        if (strcasecmp(name, "to") == 0){
                                int filInd = -1, portInd = -1, polInd = -1;
                                int i=0;
                                char filterName[MAX_FNAME_LENGTH+1], portName[MAX_PTNAME_LENGTH+1], 
                                        policyName[MAX_PLNAME_LENGTH+1];

                                while (atts[i] != NULL){
                                        if ( strcasecmp(atts[i], "filter") == 0 ){
                                                filInd = i+1;
                                                strncpy(filterName, atts[i+1], MAX_FNAME_LENGTH);
                                                filterName[MAX_FNAME_LENGTH] = '\0';
                                        }
                                        else if ( strcasecmp(atts[i], "port") == 0 ){
                                                portInd = i+1;
                                                strncpy(portName, atts[i+1], MAX_PTNAME_LENGTH);
                                                portName[MAX_PTNAME_LENGTH] = '\0';
                                        }
                                        else if ( strcasecmp(atts[i], "policy") == 0 ){
                                                polInd = i+1;
                                                strncpy(policyName, atts[i+1], MAX_PLNAME_LENGTH);
                                                policyName[MAX_PLNAME_LENGTH] = '\0';
                                        }
                                        else {
                                                //invalid attribute
                                                state = error;
                                        }
                                        i+=2;
                                }

                                if ( (filInd == -1) || (portInd == -1) || (state == error) ){
                                        state = error;
                                        strcpy(errorMsg, "Expecting <to filter=\"filter_name\" port=\"port_name\" [policy=\"policy_name\"] />");
                                }
                                else {

                                        // fills stream TO part
                                        if (!setTo(currentStream, 
                                                getFilterSpecByName(systemLayout, filterName), 
                                                portName, policyName)){
                                                state = error;
                                                strcpy(errorMsg, "Error setting stream destination");
                                                return;
                                        }
                                        if (polInd != -1)
                                                printf("filter %s:%s\n", filterName, portName);
                                        else
                                                printf("filter %s:%s\n", filterName, portName);
                                }
                        }
                        else {
                                state = error;
                                strcpy(errorMsg, "Expecting <to filter=\"filter_name\" port=\"port_name\" [policy=\"policy_name\"] />");
                        }
                break;
                case tostream:
                        // we cant open tag in this state
                        state = error;
                        strcpy(errorMsg, "Expecting </stream>");
                break;
                case preend:
                        // same
                        state = error;
                        strcpy(errorMsg, "Expecting </config>");
                break;
                case end:
                        //junk after </config>
                        strcpy(errorMsg, "Expecting eof after </config>");
                        state = error;
                break;
                default:
                break;
        }

}

/// this function is called whenever a tag is closed
void fechaTag(void *userData, const XML_Char *name){
        Layout *systemLayout = (Layout*)userData;

        lastState = state;
        
        switch (state){
                case hostdec:
                        //close hostdec
                        if ( strcasecmp("hostdec", name) == 0){
                                state = preplace;
                                printf("\tparser.c: ...\n");
                        }
                        else {
                                state = error;
                                strcpy(errorMsg, "Expecting </hostdec>");
                        }
                break;
                case resources:
                {
                        if (strcasecmp("resource", name) == 0){
                                //do nothing
                        }
                        else if ( strcasecmp("host", name) == 0){
                                state = hostdec; //go back to hostdec
                        }
                }
                break;
                case prelay:
                break;
                case filter:
                {
                        // host empty tag, no state change
                        // or filter close tag, change state
                        if ( strcasecmp("filter", name) == 0){
                                while (remainingInstances > 0){
                                        //spawn the remaing hosts
                                        HostsStruct *hs = systemLayout->hostsStruct;
                                        int hid = hostsGetIndex(hs);
                                        if (hid == -1){
                                                state = error;
                                                sprintf(errorMsg, "Error filling remaining hosts");
                                                return;
                                        }
                                        
                                        
                                        if (addHostToFilter(currentFilter, hostsGetName(hs, hid)) == -1){
                                                state = error;
                                                sprintf(errorMsg, "Error adding host %s to filter %s", hostsGetName(hs, hid), currentFilter->name);
                                                return;
                                        }

                                        printf("\t\tparser.c: instance %s(chosen randomly)\n", systemLayout->hostsStruct->hosts[hid].name);
                                        remainingInstances--;
                                }
                                
                                state = placement;
                                addFilterSpec(systemLayout, currentFilter);
                        }
                        else if ( strcasecmp("instance", name) == 0 ){
                                //do nothing
                                
                        }
                        else {
                                state = error;
                                strcpy(errorMsg, "Expecting </filter> or <instance />");
                        }
                }
                break;
                case placement:
                        if (strcasecmp("placement", name) == 0){
                                state = prelay;
                                printf("\tparser.c: ...\n");    
                        }
                        else {
                                strcpy(errorMsg, "Expecting </placement>");
                                state = error;
                        }
                break;
                case stream:
                        if ( strcasecmp("from", name) == 0 ){
                                state = fromto;
                        }
                        else {
                                strcpy(errorMsg, "Expecting <from />");
                                state = error;
                        }
                break;
                case fromto:
                        if ( strcasecmp("to", name) == 0 ){
                                state = tostream;
                        }
                        else {
                                strcpy(errorMsg, "Expecting <to />");
                                state = error;
                        }
                break;
                case tostream:
                        if ( strcasecmp("stream", name) == 0 ){
                                state = layout;
                                addStreamSpec(systemLayout, currentStream);
                        }
                        else {
                                strcpy(errorMsg, "Expecting </stream>");
                                state = error;
                        }

                break;
                case layout:
                        if ( strcasecmp("layout", name) == 0){
                                state = preend;
                        }
                        else {
                                strcpy(errorMsg, "Expecting </layout>");
                                state = error;
                        }
                break;
                case preend:
                        if (strcasecmp(name, "config") == 0)
                                state = end;
                break;
                case end:
                        //junk after </config>
                        state = error;
                break;
                default:
                break;
        }
}

int readConfig(char *fileName, Layout *l) {
        FILE *arq;
        char buffer[1]; //read char by char
        XML_Parser parser = XML_ParserCreate(NULL);
        
        arq = fopen(fileName, "ro");
        if (arq == NULL){
                char erro[200];
                sprintf(erro, "Error opening configuration file: %s", fileName);
                perror(erro);
                exit(1);
        }

        //handlers and user data
        XML_SetElementHandler(parser, abreTag, fechaTag);
        XML_SetUserData(parser, (void*)l);

        //loop till the end
        while ( (state != end) && (state != error) && (state != parseerror) && (!feof(arq)) ){
                fread(buffer, sizeof(char), 1, arq);

                if (XML_Parse(parser, buffer, 1, 0)== 0)
                        state = parseerror;
        }

        // possible errors: 
        // parseerror- XML parse error
        // error: parse error too, a tag Void does not recognize

        // last one: unexpected eof
        if (state == parseerror){
                //XML parse error
                printf("\tparser.c: parse error!!!\n");
                printf("\tparser.c: %s line %d\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser) );
                printf("\tparser.c: state = %s\n", stateNames[lastState]);
                return (-1);
        }
        else if (state == error){
                //DS parse error
                printf("\tparser.c: Parse error!!!\n");
                printf("\tparser.c: Wrong file format, line: %d\n", XML_GetCurrentLineNumber(parser));
                printf("\tparser.c: %s\n", errorMsg);
                printf("\tparser.c: State = %s\n", stateNames[lastState]);      
                return (-1);
        }
        else if (state != end){
                //eof b4 </config>
                printf("\tparser.c: Unexpected end of file!!!\n");
                printf("\tparser.c: State = %s\n", stateNames[lastState]);      
                return (-1);
        }

        // got here, ok!
        fclose(arq);

        //free the parser
        XML_ParserFree(parser);
        return 1;
}

---