Virtlab:Řídící server/Mapping.php.inc

Z VirtlabWiki

Tato třída implementuje vlastní namapování laboratorních prvků na prvky v logické topologii, tak aby byly splněny všechny podmínky.

Zatím není plně dokončeno - pokud mapovaní nelze provést je proveden jen vypis oznamení.

Obsah 1 Proměnné 2 Metody 3 Příklady 4 Zdrojový kód

Proměnné

equipment 

odkaz na objekt virtlabParserEquipment, který poskytuje data o laboratorních prvcích

topology 

odkaz na objekt virtlabParserTopology, který poskytuje data o logické topologii

Metody

function __construct(virtlabParserEquipment $equip, virtlabParserTopology $topol) 

konstruktor třídy v PHP5. Jako parametry očekává objekty jednotlivých parseru - virtuální topologie a vybavení

public function Evaluate($device) 

vrátí vypočtenou hodnotu (tu ovlivnňuje typ laboratorního prvku, počet rozhrani, ...) zadaného lab. prvku. Nastavení konstant třídy virtlabValues ovlivní výslednou hodnotu.

public function DevicesValue() 

vrátí pole všech laboratorních prvků s jejich vypočtenou hodnotou

public function Availability($device, $vertex) 

zjistí, zda-li může být zadaný laboratorní prvek, zařízením v logické topologii. Pokud ano, vrátí pole s určením, která rozhraní mohou být použita, na kterých linkách logické topologie. Pokud ne, vrátí číslo chyby - definováno ve třídě virtlabValues.

private function Mapping($map2, &$vysledek) 

rekurzivní funkce, která se snaží mapovat. Ve dvojrozměrné poli $map2 je uloženo, který vertex může být realizován jakými device. Případný vysledek mapovaní je uložen do proměnné $vysledek. (viz příklady) Pozn.: tato funkce je psána obecně, takže je ve druhém kroku je znovu použita na mapovaní LINKA-ROZHRANÍ. Podrobnější informace k algoritmu rekuzivní funkce jsou zde.

public function Map() 

funkce obstarávající celý algoritmus mapování.

Příklady

Výsledný výstup:

$mapper->Map();
r21:s0/0 r11:s0/0 
r21:s0/1 r10:s0/0 
r42:gi7 r21:fa3 
r41:gi7 r21:fa2 
r41:gi6 r11:gi1 
r42:gi6 r10:gi1 
r42:gi5 r11:gi0 
r41:gi5 r10:gi0 

Poznámka: podrobné výpisy z průběhu algoritmu, jsou zde.

Zdrojový kód

<?php

class virtlabMapping {
    private $equipment = NULL;
    private $topology  = NULL;

    function __construct(virtlabParserEquipment $equip, virtlabParserTopology $topol) {
        $this->equipment = $equip;
        $this->topology = $topol;
    }//konstruktor

    public function Evaluate($device) {
        $hodnota = 0;
        $eq = $this->equipment;	//pointer to equipment

        $temp = $eq->getDeviceFeatures($device);
        $hodnota += count($temp) * virtlabValues::DeviceFeature;

        $temp = $eq->getDeviceInterfacesFeatures($device);
        $hodnota += count($temp) * virtlabValues::InterfaceFeature;

        for($i = $eq->getDeviceInterfacesCount($device) - 1; $i >= 0; $i--) {
            $technology = $eq->getDeviceInterfaceTechnology($device, $i);

            if($technology == "ethernet") {
                $inf = virtlabValues::InterfaceTechnologyEthernet;
                $ether_type = $eq->getDeviceInterfaceEthertype($device, $i);
                if($ether_type == "legacy") 
                    $inf *= virtlabValues::EthertypeMultiplerLegacy;
                else if($ether_type == "fast")
                    $inf *= virtlabValues::EthertypeMultiplerFast;
                else if($ether_type == "gigabit")
                    $inf *= virtlabValues::EthertypeMultiplerGigabit;
                else $inf *= 0; //error

                $hodnota += $inf;
            }//if:ethernet
            else if($technology == "serial") {
                $inf = virtlabValues::InterfaceTechnologySerial;
                $bps = $eq->getDeviceInterfaceMaxbps($device, $i);

                if(is_null($bps)) $bps = virtlabValues::defaultMaxbps; //error

                if((int)$bps < virtlabValues::bpsDefault)
                    $inf = (int)((double)$inf * virtlabValues::bpsLower);
                else if((int)$bps > virtlabValues::bpsDefault)
                    $inf = (int)((double)$inf * virtlabValues::bpsBigger);

                $hodnota += $inf;
            }//else-if:serial
        }//for-interfaces
        return $hodnota;
    }//function-Evaluate


    public function DevicesValue() {
        $tmp = array();
        $devices = $this->equipment->getDevicesList();
        foreach($devices as $device) {
            $tmp[$device] = $this->Evaluate($device);
        }//foreach
        return $tmp;
    }//function-DevicesValue


    public function Availability($device, $vertex) {
        $device_idx = NULL;
        $eq = $this->equipment; //pointer to equipment
        $to = $this->topology;  //pointer to topology

        $eq->getDeviceByName($device, &$device_idx);


        //type
        $tmp_e = $eq->getDeviceType($device_idx);
        $tmp_t = $to->getVertexType($vertex);
        if($tmp_e != $tmp_t) return virtlabValues::badType;
        //print("Same type\n");


        //platform
        $tmp_e = $eq->getDevicePlatform($device_idx);
        $tmp_t = $to->getVertexPlatforms($vertex, 1);
        $tmp_platf = 0;
        if(!is_null($tmp_t)) {
            foreach($tmp_t as $hodnota) {
                $pattern = "/" . $hodnota . "/";
                if(preg_match($pattern, $tmp_e)) {
                    $tmp_platf = 1;
                    break;
                }//if-preg_match
            }//foreach
            if(!$tmp_platf) return virtlabValues::badPlatform;
        }//if-compare
        unset($tmp_platf);
        //print("Good platform\n");


        //OS
        $tmp_e = $eq->getDeviceOS($device, 1);
        $tmp_t = $to->getVertexOS($vertex, 1);     
        $pattern = "/" . $tmp_t . "/";
        if(!preg_match($pattern, $tmp_e)) return virtlabValues::badOS;
        unset($pattern);
        //print("Good OS\n");


        //device features
        $tmp_e = $eq->getDeviceFeatures($device);
        $tmp_t = $to->getVertexFeatures($vertex);
        if(count(array_diff((array)$tmp_t,(array)$tmp_e)) > 0) return virtlabValues::noDeviceFeature;
        //print("Device features-OK\n");


        //enough interfaces
        $tmp_t_if = array();
        $tmp_e_if = array();
        $tmp_t = $to->getEdgesByVertex($vertex);
        foreach($tmp_t as $edge_idx => $edge) {
            $tmp_tech = $to->getEdgeTechnology($edge_idx);
            array_push($tmp_t_if, $tmp_tech);
        }//foreach
        for($i = $eq->getDeviceInterfacesCount($device) - 1; $i>=0; $i--) {
            $tmp_tech = $eq->getDeviceInterfaceTechnology($device, $i);
            array_push($tmp_e_if, $tmp_tech);
        }//for
        $tmp_res = array_porovnej($tmp_t_if, $tmp_e_if);	//intersect of multisets
        if(count($tmp_res) != 0) return virtlabValues::notEnoughInterfaces;
        unset($tmp_t_if, $tmp_e_if, $tmp_res);


        //interfaces
        $tmp_t = $to->getEdgesByVertex($vertex);
        $result = array();
        foreach($tmp_t as $idx => $edge) {
            $result[$edge] = array();

            for($i = $eq->getDeviceInterfacesCount($device) - 1; $i >= 0; $i--) {

                $tmp_e_fea = $eq->getDeviceInterfaceFeatures($device, $i);
                if(is_null($tmp_e_fea)) $tmp_e_fea = array();
                $tmp_t_fea = $to->getEdgeFeatures($idx);
                if(is_null($tmp_t_fea)) $tmp_t_fea = array();
                if(array_diff($tmp_t_fea, $tmp_e_fea)) continue;  //uncompatible interface features -> next interface

                if($eq->getDeviceInterfaceTechnology($device, $i) == $to->getEdgeTechnology($idx)) {
                    if($to->getEdgeTechnology($idx) == "serial") {
                        if(is_null($to->getEdgeMinbps($idx))) {
                            $result[$edge][$i] = $eq->getDeviceInterfaceName($device, $i);
                            continue; 
                        }//if-minbps=NULL
                
                        if(is_null($eq->getDeviceInterfaceMaxbps($device, $i)))
                            $tmp_maxbps = virtlabValues::defaultMaxbps;	//error avoidance
                        else $tmp_maxbps = $eq->getDeviceInterfaceMaxbps($device, $i);
                        if($to->getEdgeMinbps($idx) > $tmp_maxbps) continue;	//slow serial interface -> next inteface
                        
                        $result[$edge][$i] = $eq->getDeviceInterfaceName($device, $i);

                    }//if-technology=serial
                    else if($to->getEdgeTechnology($idx) == "ethernet") {
                       if(is_null($to->getEdgeEthertype($idx))) {
                           $result[$edge][$i] = $eq->getDeviceInterfaceName($device, $i);
                           continue;
                       }//if-ethertype-topology=NULL

                       if(is_null($eq->getDeviceInterfaceEthertype($device, $i)))
                           $tmp_e_ethertype = virtlabValues::defaultEthertype;	//error avoidance
                       else $tmp_e_ethertype = $eq->getDeviceInterfaceEthertype($device, $i);

                       $tmp_t_ethertype = $to->getEdgeEthertype($idx);

                       //if slower ethernet -> next interface
                       if($tmp_t_ethertype == "fast" && $tmp_e_ethertype == "legacy") continue;
                       else if($tmp_t_ethertype == "gigabit" && $tmp_e_ethertype == "legacy") continue;
                       else if($tmp_t_ethertype == "gigabit" && $tmp_e_ethertype == "fast") continue;

                        $result[$edge][$i] = $eq->getDeviceInterfaceName($device, $i);
                    }//if-technology=ethernet
                }//if-same technology
            }//for - interfaces
        }//foreach

        foreach($result as $hodnota) {
            if(!$hodnota) return virtlabValues::VertexDeviceMismatch;	//some edge has no compatible interface
        }//foreach

        return $result;
    }//function

    private function Mapping($map2, &$vysledek) {//recursive
        foreach($map2 as $vertex => $devices) {
            if(count($devices) == 0) return 0; //some vertex cannot be mapped
        }//foreach

        if(count($map2) == 1) {
            foreach($map2 as $vertex => $devices) {
                if(count($devices) == 0) return 0; //cannot be mapped       
                foreach($devices as $device => $cena) {
                    $tmp["vertex"] = $vertex;
                    $tmp["device"] = $device;
                    array_push($vysledek, $tmp);
                    return 1;
                }//foreach
            }//foreach
        }//if - count=1
        else {
            foreach($map2 as $vertex => $devices) { //exist vertex with one possibly device
                if(count($devices) == 1) {
                    foreach($devices as $device => $cena) {
                        MatrixClear($map2, $vertex, $device);
                        if($this->Mapping($map2, $vysledek)) { //if mapping $vertex to $device is good
                            $tmp["vertex"] = $vertex;
                            $tmp["device"] = $device;
                            array_push($vysledek, $tmp);
                            return 1;
                        }//if
                        else return 0; //bad choice
                    }//foreach
                }//if
            }//foreach-vertex with one poss device
            
            foreach($map2 as $vertex => $devices) { 
                foreach($devices as $device => $cena) {
                    MatrixClear($map2,$vertex,$device);
                    if($this->Mapping($map2, $vysledek)) {
                        $tmp["vertex"] = $vertex;
                        $tmp["device"] = $device;
                        array_push($vysledek, $tmp);
                        return 1;
                    }//if
                }//foreach
                return 0; //no mapping is possible
            }//general
        }//else
    }//function


    public function Map() {
        $devices = $this->equipment->getDevicesList();
        $vertexes = $this->topology->getVertexesList();
        
        $map = array();
        foreach($vertexes as $vertex) {
            foreach($devices as $device) {
                $vysledek = $this->Availability($device,$vertex);
        
                if(is_array($vysledek)) $map[$vertex][$device] = $vysledek;
                else $map[$vertex][$device] = 0;
            }//foreach
        }//foreach

        //print("<pre> "); print_r($map); print(" </pre>");

        $map2 = array();
        foreach($map as $vertex => $devices) {
            foreach($devices as $device => $infs) {
                if(is_array($infs))
                    $map2[$vertex][$device] = $this->Evaluate($device);
            }//foreach
        }//foreach

        foreach($map2 as $idx => $devices) {
            asort($devices,SORT_NUMERIC);
            reset($devices);
            $map2[$idx] = $devices;
        }//foreach - sort

        //print("<pre> "); print_r($map2); print(" </pre>");


        $ahoj = array();
        if($this->Mapping($map2,$ahoj)) {
            //print("<pre> "); print_r($ahoj); print(" </pre>");
        }
        else print("Smula");


        $hotovo = array();
        foreach($ahoj as $spojeni) {
            $ahoj2 = array();
            if($this->Mapping($map[$spojeni["vertex"]][$spojeni["device"]],$ahoj2)) {//map interfaces
                $hotovo[$spojeni["vertex"]]["device"] = $spojeni["device"];
                foreach($ahoj2 as $linka) {
                    $hotovo[$spojeni["vertex"]]["links"][$linka["vertex"]] = $this->equipment->getDeviceInterfaceName($spojeni["device"], $linka["device"]);
                }//foreach
            }//if
            else print("Smula");
        }//foreach
        
        //print("<pre> "); print_r($hotovo); print(" </pre>");


        print("<pre>");
        $tmp = $this->topology->getEdgesList();
        foreach($tmp as $edge_idx => $edge) {
            $vertexes = $this->topology->getEdgeVertexes($edge_idx);
            foreach($vertexes as $vertex) {
                print($hotovo[$vertex]["device"] . ":" . $hotovo[$vertex]["links"][$edge] . " ");
            }
            print("\n");
        }
        print("</pre>");
    }//function
}//class
?>