frammenti di razionalità

In questi giorni mi sono “immerso” nello studio del Python, un interessante linguaggio di scripting che mi ero promesso di imparare data la sua crescente diffusione nel mondo del software open (e non).

La rete mi ha aiutato tantissimo: su Internet trovate tonnellate di documentazione, a partire dal sito ufficiale del linguaggio.

Come prima prova con Python, ho provato ad implementare registerimage-1.0.2, il software che ho scritto per automatizzare la registrazione delle immagini virtuali del progetto VirtualBox Images con il software VirtualBox della SUN.

La cosa che colpisce del Python è la semplicità enorme di codificazione; abituato a certe “astrusità” del C, programmare in Python è molto semplice e scorrevole.

Ecco un piccolo confronto tra l’implementazione in C di una funzione di registerimage-1.0.2 e quella in Python.

La funzione in questione effettua un parsing del file di configurazione della macchina virtuale che si vuole registrare per ottenere i parametri salienti della macchina virtuale stessa.

Versione C:

vm_parameters* get_machine_parameters(char *docname) {
    printf("%s\ndocname: %s\n",__FUNCTION__,docname);
    vm_parameters *param;

    xmlDocPtr doc;
    xmlNodePtr cur, cur2,cur3;

    param=new_vm_parameters();

    doc = xmlParseFile(docname);

    if (!doc) {
        fprintf(stderr,"Document not parsed successfully. \n");
        return NULL;
    }

    cur = xmlDocGetRootElement(doc);

    if (!cur) {
        fprintf(stderr,"empty document\n");
        xmlFreeDoc(doc);
        return NULL;
    }

    if (xmlStrcmp(cur->name, BAD_CAST "VirtualBox")) {
        fprintf(stderr,"document of the wrong type");
        xmlFreeDoc(doc);
        return NULL;
    }

    cur = cur->xmlChildrenNode;

    while (cur) {

        if (!xmlStrcmp(cur->name, BAD_CAST "Machine")){
            param->machine_uuid=xmlStrdup(xmlGetProp(cur, BAD_CAST "uuid"));
            param->machine_name=xmlStrdup(xmlGetProp(cur, BAD_CAST "name"));

            //printf("uuid=%s\n",param->machine_uuid);
            //printf("machine name=%s\n",param->machine_name);

            cur2=cur->xmlChildrenNode;

            while(cur2){
                if (!xmlStrcmp(cur2->name, BAD_CAST "HardDiskAttachments")){

                    cur3=cur2->xmlChildrenNode;

                    while(cur3){
                        if (!xmlStrcmp(cur3->name, BAD_CAST "HardDiskAttachment"))
                            param->hd_id=xmlStrdup(xmlGetProp(cur3,BAD_CAST "hardDisk"));

                            //printf("hardDisk=%s\n",param->hd_id);

                        cur3 = cur3->next;
                    }

                }
                cur2 = cur2->next;
            }

        }

        cur = cur->next;
    }

    xmlFreeDoc(doc);

    return param;
}

Versione Python:

def getMachineParameters(docname):
    try:
        param = MachineParameters()
        xmldoc = minidom.parse(docname)

        root = xmldoc.documentElement

        if root.nodeName == "VirtualBox":
            machineNode = root.childNodes[1]

            param["uuid"] = machineNode.getAttribute("uuid" )
            param["name"] = machineNode.getAttribute("name" )

            machineNodeChildrens = machineNode.childNodes

            for i in machineNodeChildrens:
                if i.nodeName == "HardDiskAttachments":
                    for j in i.childNodes:
                        if j.nodeName == "HardDiskAttachment":
                            param["hdid"] = j.getAttribute("hardDisk" )

                            return param

        else:
            print "Document of the wrong type"
            return None

    except IOError:
        print "Error parsing ", docname
        return None

La versione C della funzione usa la libxml2, mentre quella Python usa il modulo xml.dom.minidom.