centralM
[ class tree: centralM ] [ index: centralM ] [ all elements ]

Source for file actions.class.php

Documentation is available at actions.class.php

  1. <?php
  2.  
  3. /**
  4.  * server actions.
  5.  *
  6.  * @package    centralM
  7.  * @subpackage server
  8.  * @author     Your name here
  9.  * @version    SVN: $Id: actions.class.php 12474 2008-10-31 10:41:27Z fabien $
  10.  */
  11. class serverActions extends sfActions
  12. {
  13.   // called by 'Add Server Wizard' button
  14.   public function executeCreatewin(sfWebRequest $request)
  15.   {
  16.       $this->etva_node EtvaNodePeer::retrieveByPk($request->getParameter('id'));
  17.       // remove session macs for cleanup the wizard
  18.       $this->getUser()->getAttributeHolder()->remove('macs_in_wizard');
  19.   }
  20.   
  21.  
  22.   public function executeView(sfWebRequest $request)
  23.   {
  24.       $etva_server EtvaServerPeer::retrieveByPk($request->getParameter('id'));
  25.       $this->forward404Unless($etva_server);
  26.       
  27.       $this->node_id $etva_server->getNodeId();
  28.  
  29.       
  30.       $this->server_id $request->getParameter('id');
  31.       $this->server_form new EtvaServerForm();
  32.       $this->server_tableMap EtvaServerPeer::getTableMap();
  33.  
  34.       $this->sfGuardGroup_tableMap sfGuardGroupPeer::getTableMap();
  35.  
  36.       $this->network_form new EtvaNetworkForm();
  37.       $this->network_tableMap EtvaNetworkPeer::getTableMap();
  38.  
  39.       $this->agent_form new EtvaAgentForm();
  40.       $this->agent_tableMap EtvaAgentPeer::getTableMap();
  41.  
  42.   }
  43.  
  44.  
  45.  public function executeJsonCreate(sfWebRequest $request)
  46.  {
  47.  
  48.    $server json_decode($request->getParameter('server'),true);
  49.  
  50.    $lvdev $server['Logicalvolume'];
  51.    unset($server['Logicalvolume']);
  52.  
  53.         
  54.         $node_id $server['NodeId'];
  55.  
  56.     $c new Criteria();
  57.  
  58.         $c->add(EtvaLogicalvolumePeer::NODE_ID$node_id);
  59.         $c->add(EtvaLogicalvolumePeer::LVDEVICE$lvdev);
  60.  
  61.         $etva_lv EtvaLogicalvolumePeer::doSelectOne($c);
  62.         $etva_lv->setInUse(1);
  63.         $etva_lv->save();
  64.  
  65.  
  66.         $lv_id $etva_lv->getId();
  67.  
  68.         $server['LogicalvolumeId'$lv_id;
  69.  
  70.  
  71.  
  72.    $serverMem $server['Mem'];
  73.    $serverMemB $serverMem 1024 1024;
  74.    
  75.    $node_id $server['NodeId'];
  76.  
  77.    $etva_node EtvaNodePeer::retrieveByPK($node_id);
  78.    $server['Ip'$etva_node->getIp();
  79.  
  80.    $etva_node_free_mem $etva_node->getMemfree();
  81.    $free $etva_node_free_mem $serverMemB;
  82.    $etva_node->setMemfree($free);
  83.    $etva_node->save();
  84.  
  85.  
  86.  //  $node_memfree = $server = json_decode($request->getParameter('server'),true);
  87.  
  88. // return print_r($server);
  89.  
  90.         $etva_server new EtvaServer();
  91.         
  92.         $etva_server->fromArray($server);
  93.         $etva_server->save();
  94.  
  95.      //7   $mac = EtvaMacPeer::retrieveByMac($object['Mac']);
  96.       //  $mac->setInUse(1);
  97.      //   $mac->save();
  98.  
  99.  
  100.     $result array('success'=>true,'object'=>$etva_server->toArray());
  101.     $result json_encode($result);
  102.  
  103.     $this->getContext()->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  104.  
  105.     return $this->renderText($result);
  106.   }
  107.  
  108.  
  109.   public function executeJsonCreate_old(sfWebRequest $request)
  110.   {
  111.      $isAjax $request->isXmlHttpRequest();
  112.  
  113.      // if(!$isAjax) return $this->redirect('@homepage');
  114.  
  115. //     if(!$request->isMethod('post')){
  116. //         $info = array('success'=>false,'errors'=>'Wrong parameters');
  117. //         $error = $this->setJsonError($info);
  118. //         return $this->renderText($error);
  119. //     }
  120.  
  121.      $this->form new EtvaServerForm();     
  122.  
  123.      $result $this->processJsonForm($request$this->form);
  124.  
  125.      if(!$result['success']){
  126.          $error $this->setJsonError($result);
  127.          return $this->renderText($error);
  128.      }
  129.  
  130.      $result json_encode($result);
  131.  
  132.      $this->getContext()->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  133.  
  134.      return $this->renderText($result);
  135.  
  136.   }
  137.  
  138.   public function executeJsonUpdateField(sfWebRequest $request)
  139.   {
  140.     $isAjax $request->isXmlHttpRequest();
  141.  
  142.     if(!$isAjaxreturn $this->redirect('@homepage');
  143.  
  144.     if(!$request->isMethod('post'&& !$request->isMethod('put')){
  145.          $info array('success'=>false,'errors'=>'Wrong parameters');
  146.          $error $this->setJsonError($info);
  147.          return $this->renderText($error);
  148.     }
  149.  
  150.     if(!$etva_server EtvaServerPeer::retrieveByPk($request->getParameter('id'))){
  151.         $error_msg sprintf('Object etva_server does not exist (%s).'$request->getParameter('id'));
  152.         $info array('success'=>false,'errors'=>$error_msg);
  153.         $error $this->setJsonError($info);
  154.         return $this->renderText($error);
  155.     }
  156.  
  157.     $etva_server->setByName($request->getParameter('field')$request->getParameter('value'));
  158.     $etva_server->save();
  159.  
  160.     $result array('success'=>true);
  161.     $result json_encode($result);
  162.     $this->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  163.     return $this->renderText($result);
  164.  
  165.   }
  166.  
  167.   public function executeJsonUpdate(sfWebRequest $request)
  168.   {
  169.     $isAjax $request->isXmlHttpRequest();
  170.  
  171.     if(!$isAjaxreturn $this->redirect('@homepage');
  172.  
  173.     $server ($request->getParameter('server'))json_decode($request->getParameter('server'),truearray();
  174.  
  175.     $etva_server new EtvaServer();
  176.     $etva_server->fromArray($server);
  177.     $etva_server->setNew(false);
  178.     
  179.     if($etva_server->validate()){
  180.         $etva_server->save();
  181.         $result array('success'=>true,'object'=>$etva_server->toArray());
  182.  
  183.     }else $result array('success'=>false);
  184.  
  185. //    if(!$etva_server = EtvaServerPeer::retrieveByPk($request->getParameter('id'))){
  186. //        $error_msg = sprintf('Object etva_server does not exist (%s).', $request->getParameter('id'));
  187. //        $info = array('success'=>false,'errors'=>$error_msg);
  188. //        $error = $this->setJsonError($info);
  189. //        return $this->renderText($error);
  190. //    }
  191. //
  192. //    $etva_server->setByName($request->getParameter('field'), $request->getParameter('value'));
  193. //    $etva_server->save();
  194.  
  195.     
  196.     $result json_encode($result);
  197.     $this->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  198.     return $this->renderText($result);
  199.  
  200.   }
  201.  
  202.   public function executeJsonDelete(sfWebRequest $request)
  203.   {
  204.     $isAjax $request->isXmlHttpRequest();
  205.  
  206.     if(!$isAjaxreturn $this->redirect('@homepage');
  207.  
  208.     if(!$etva_server EtvaServerPeer::retrieveByPk($request->getParameter('id'))){
  209.         $error_msg sprintf('Object etva_server does not exist (%s).'$request->getParameter('id'));
  210.         $info array('success'=>false,'errors'=>$error_msg);
  211.         $error $this->setJsonError($info);
  212.         return $this->renderText($error);
  213.     }
  214.  
  215.     $etva_server_mem $etva_server->getMem();
  216.     $etva_server_memB $etva_server_mem 1024 1024;
  217.  
  218.  
  219.  
  220.     $etva_node EtvaNodePeer::retrieveByPK($etva_server->getNodeId());
  221.     $etva_node_memfree $etva_node->getMemfree();
  222.  
  223.     $free $etva_node_memfree $etva_server_memB;
  224.     
  225.     $etva_node->setMemfree($free);
  226.  
  227.     $etva_node->save();
  228.  
  229.     $etva_server->delete();
  230.  
  231.     $result array('success'=>true);
  232.     $result json_encode($result);
  233.     $this->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  234.     return $this->renderText($result);
  235.   }
  236.  
  237.  
  238.   public function executeJsonGridInfo(sfWebRequest $request)
  239.   {
  240.     $isAjax $request->isXmlHttpRequest();
  241.  
  242.     if(!$isAjaxreturn $this->redirect('@homepage');
  243.     $elements array();
  244.  
  245.     $criteria new Criteria();
  246.     $criteria->add(EtvaServerPeer::ID$request->getParameter('id'));
  247.  
  248.     $this->etva_server EtvaServerPeer::doSelectJoinsfGuardGroup($criteria);
  249.  
  250.  
  251.     $serverGroup $this->etva_server[0]->getsfGuardGroup();
  252.     $serverGroupName $serverGroup->getName();
  253.     $elements[0$this->etva_server[0]->toArray();
  254.     $elements[0]['SfGuardGroupName'$serverGroupName;
  255.  
  256.     $final array('total' =>   count($elements),'data'  => $elements);
  257.     $result json_encode($final);
  258.  
  259.     $this->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  260.  
  261.     return $this->renderText($result);
  262.  
  263.   }
  264.  
  265.   public function executeJsonGrid(sfWebRequest $request)
  266.   {
  267.     $isAjax $request->isXmlHttpRequest();
  268.  
  269.     if(!$isAjaxreturn $this->redirect('@homepage');
  270.  
  271.     $limit $this->getRequestParameter('limit'10);
  272.     $page floor($this->getRequestParameter('start'0$limit)+1;
  273.  
  274.     // pager
  275.     $this->pager new sfPropelPager('EtvaServer'$limit);
  276.     $c new Criteria();
  277.  
  278.     $this->addSortCriteria($c);
  279.     $this->addNodeCriteria($c);
  280.  
  281.     $this->pager->setCriteria($c);
  282.     $this->pager->setPage($page);
  283.  
  284.     $this->pager->setPeerMethod('doSelectJoinsfGuardGroup');
  285.     $this->pager->setPeerCountMethod('doCountJoinsfGuardGroup');
  286.  
  287.     $this->pager->init();
  288.  
  289.  
  290.     $elements array();
  291.     $i 0;
  292.  
  293.     # Get data from Pager
  294.     foreach($this->pager->getResults(as $item){
  295.              $serverGroup $item->getsfGuardGroup();
  296.              $serverGroupName $serverGroup->getName();
  297.                 
  298.              $elements[$i$item->toArray();
  299.              $elements[$i]['SfGuardGroupName'$serverGroupName;
  300.              $i++;
  301.     }
  302.  
  303.  
  304.     $final array(
  305.       'total' =>   $this->pager->getNbResults(),
  306.       'data'  => $elements
  307.     );
  308.  
  309.     $result json_encode($final);
  310.  
  311.     $this->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  312.     return $this->renderText($result);
  313.  
  314.   }
  315.  
  316.   protected function addSortCriteria($criteria)
  317.   {
  318.     if ($this->getRequestParameter('sort')==''return;
  319.  
  320.     $column EtvaServerPeer::translateFieldName(sfInflector::camelize($this->getRequestParameter('sort'))BasePeer::TYPE_PHPNAMEBasePeer::TYPE_COLNAME);
  321.  
  322.     if ('asc' == strtolower($this->getRequestParameter('dir')))
  323.       $criteria->addAscendingOrderByColumn($column);
  324.     else
  325.       $criteria->addDescendingOrderByColumn($column);
  326.   }
  327.  
  328.   protected function addNodeCriteria($criteria)
  329.   {
  330.         
  331.     $nodeID $this->getRequestParameter("nid");
  332.     $criteria->add(EtvaServerPeer::NODE_ID$nodeID);  
  333.   }
  334.  
  335.  
  336.   protected function processJsonForm(sfWebRequest $requestsfForm $form)
  337.   {
  338.     // get submitted form elements
  339.     $form_elems $request->getParameter($form->getName());
  340.     // retrieve mac pool elements number
  341.     // $mac_pool = $request->getParameter('mac_pool');
  342.  
  343.     //generate random macs and add to form elements
  344. //    if(isset($mac_pool)){
  345. //        $macs = $this->generateMacPool($mac_pool);
  346. //        $macs = implode(',',$macs);
  347. //
  348. //        $form_elems['mac_addresses'] = $macs;
  349. //    }
  350.  
  351.     $form->bind($form_elems$request->getFiles($form->getName()));
  352.  
  353.     if ($form->isValid())
  354.     {
  355.           $etva_server $form->save();
  356.  
  357.           //$result = array('success'=>true,'insert_id'=>$etva_server->getId());
  358.           $result array('success'=>true'object'=>$etva_server->toArray());
  359.           return $result;
  360.  
  361.     }
  362.     else{
  363.         $errors array();
  364.         foreach ($form->getErrorSchema(as $field => $error)
  365.                         $errors[$field$error->getMessage();
  366.           $result array('success'=>false,'errors'=>$errors);
  367.           return $result;
  368.     }
  369.  
  370.  
  371.   }
  372.  
  373.   private function setJsonError($info,$statusCode 400){
  374.  
  375.       $this->getContext()->getResponse()->setStatusCode($statusCode);
  376.       $error json_encode($info);
  377.       $this->getContext()->getResponse()->setHttpHeader("X-JSON"'()');
  378.       return $error;
  379.  
  380.   }
  381.  
  382.  
  383.   public function executeJsonTree(sfWebRequest $request)
  384.   {
  385.     $isAjax $request->isXmlHttpRequest();
  386.  
  387.     if(!$isAjaxreturn $this->redirect('@homepage');
  388.      
  389.     $tree $this->generateTree();
  390.     $json json_encode($tree);
  391.     return $this->renderText ($json);
  392.      
  393.   }
  394.  
  395.   protected function generateTree()
  396.   {
  397.       $nodes EtvaNodePeer::getWithServers();
  398.      
  399.       $aux array();
  400.       foreach ($nodes as $node){
  401.  
  402.           $aux_servers array();
  403.           foreach ($node->getServers(as $i => $server){
  404.                         $child_id 's'.$server->getID();
  405.                         $aux_servers[array('text'=>$server->getName(),'id'=>$child_id,'url'=> $this->getController()->genUrl('server/view?id='.$server->getID()),
  406.                             'leaf'=>true);
  407.           }
  408.  
  409.           if(empty($aux_servers)){
  410.               $aux[array('text'=>$node->getName(),'id'=>$node->getID(),'url'=>$this->getController()->genUrl('node/view?id='.$node->getID()),
  411.                 'children'=>$aux_servers,'expanded'=>true,'cls'=> 'x-tree-node-collapsed');
  412.           }else $aux[array('text'=>$node->getName(),'id'=>$node->getID(),'url'=>$this->getController()->genUrl('node/view?id='.$node->getID()),
  413.                         'singleClickExpand'=>true,'children'=>$aux_servers);
  414.  
  415.       }
  416.       return $aux;
  417.  
  418.   }
  419.  
  420.  
  421.   public function executeJsonMacs(sfWebRequest $request)
  422.   {
  423.     $isAjax $request->isXmlHttpRequest();
  424.  
  425.     if(!$isAjaxreturn $this->redirect('@homepage');
  426.  
  427.     $num_macs $request->getParameter('size');
  428.  
  429.     $query ($this->getRequestParameter('query'))json_decode($this->getRequestParameter('query'),truearray();
  430.     
  431.     $macs implode(',',$macs);
  432.  
  433.     
  434.  
  435.     $result json_encode($macs);
  436.  
  437.     $this->getResponse()->setHttpHeader("X-JSON"'()')// set a header, (although it is empty, it is nicer than without a correct header. Filling the header with the result will not be parsed by extjs as far as I have seen).
  438.     return $this->renderText($result);
  439.  
  440.   }
  441.  
  442.   /*
  443.    *
  444.    */
  445.  
  446.  
  447.   public function executeUpdate(EtvaNode $node$vms)
  448.   {
  449.   
  450.  
  451.  
  452.  
  453.  
  454.    // if(SF_ENVIRONMENT == 'soap'){
  455.  
  456.         // $vlans = $request->getParameter('vlans');
  457.         // $vms = $request->getParameter('vms');
  458.  
  459.         $vms_uids array();
  460.  
  461.         
  462.         
  463.         $vms !empty($vms$vms array();        
  464.         
  465.         foreach($vms as $vm){
  466.             $vms_uids[$vm->uuid;
  467.         }
  468.  
  469. // die(print_r($vms_uids));
  470.  
  471.         $node_servers $node->getEtvaServers();
  472.  
  473.  
  474.  
  475.         // return $node_vlans;
  476.         // $result = 'Success';
  477.         $new_servers =array();
  478.         foreach($node_servers as $node_server){
  479.  
  480.  
  481.             if(!in_array($node_server->getUid(),$vms_uids)){
  482.  
  483.  
  484.                      $server_uuid $node_server->getUid();
  485.                      
  486.             $server_name $node_server->getName();
  487.             $server_path $node_server->getDisk();
  488.             $server_ram $node_server->getMem();
  489.             $server_cpuset $node_server->getCpuset();
  490.  
  491.             $server_networks $node_server->getEtvaNetworks();
  492.  
  493.             
  494.  
  495.             $server_location $node_server->getLocation();
  496.             $networks_string array();
  497.  
  498.             foreach($server_networks as $server_network){
  499.               $networks_string['name='.$server_network->getVlan().','.
  500.                                    'macaddr='.$server_network->getMac();
  501.             }
  502.  
  503.             $network_string implode(';',$networks_string);
  504.          
  505.  
  506.             
  507.  
  508.             $new_servers[$server_namearray(
  509.                                     'uuid'=>$server_uuid,
  510.                                     'name'=>$server_name,
  511.                                     'path'=>$server_path,
  512.                                     'ram'=>$server_ram,
  513.                                     'cpuset'=>$server_cpuset,
  514.                                     'network'=>$network_string,
  515.                                     'nettype'=>'network',
  516.                                     'location'=>$server_location
  517.               );
  518.  
  519.  
  520.  
  521.             }
  522.  
  523.  
  524.  
  525.         }
  526.  
  527.  
  528.         return $new_servers;
  529.  
  530.     }
  531.  
  532.   public function executeSoapUpdate(sfWebRequest $request)
  533.   {
  534.  
  535.  
  536.     if(SF_ENVIRONMENT == 'soap'){
  537.         
  538.  
  539.         $vms $request->getParameter('vms');        
  540.  
  541.         $c new Criteria();
  542.         $c->add(EtvaNodePeer::UID ,$request->getParameter('uid'));
  543.  
  544.  
  545.         if(!$etva_node EtvaNodePeer::doSelectOne($c)){
  546.             $error_msg sprintf('Object etva_node does not exist (%s).'$request->getParameter('uid'));
  547.             $error array('success'=>false,'errors'=>$error_msg);
  548.  
  549.             return $error;
  550.         }
  551.         
  552.  
  553.           return $this->executeUpdate($etva_node$vms);
  554.  
  555. //        // foreach ($node->getServers() as $i => $server){
  556. //        $node_servers = $etva_node->getServers();
  557. //        // $node_vlans = EtvaVlanPeer::doSelect(new Criteria());
  558. //
  559. //        // return $node_vlans;
  560. //        $servers_name = array();
  561. //
  562. //        foreach($node_servers as $node_server){
  563. //            $servers_name[] = $node_server->getName();
  564. //        }
  565. //
  566. //
  567. //
  568. //        foreach($vms as $name=>$vm){
  569. //             // return $name;
  570. //            // print("a ".$vlan['name']);
  571. //            $v = in_array($name,$servers_name);
  572. //
  573. //            if(!in_array($name,$servers_name)){
  574. //                try{
  575. //                $disk = $vm->Disks->arrayi-0;
  576. //                $disk = $disk->path;
  577. //                $etva_server = new EtvaServer();
  578. //                $etva_server->setName($name);
  579. //                $etva_server->setVncPort($vm->vnc_port);
  580. //                $etva_server->setUid($vm->uuid);
  581. //                $etva_server->setMem($vm->memory);
  582. //                $etva_server->setDisk($disk);
  583. //                $etva_server->setRcpu($vm->cpuset);
  584. //                $etva_server->setIp('0');
  585. //                $etva_server->setState($vm->state);
  586. //                $etva_server->setNodeId($etva_node->getId());
  587. //                $etva_server->setSfGuardGroupId(1);
  588. //            //    return 'retornou agora :-)';
  589. //                $etva_server->save();}
  590. //            catch(Exception $e){
  591. //                    return $e;
  592. //                }
  593. //            }
  594. //        }
  595.  
  596.  
  597.     //    $etva_node->setByName($request->getParameter('field'), $request->getParameter('value'),BasePeer::TYPE_FIELDNAME);
  598.      //   $etva_node->save();
  599.  
  600.     //    $result = array('success'=>true);
  601.       //  return $result;
  602.     }
  603.   }
  604.  
  605.  
  606.  
  607.  
  608. //  public function executefrUpdate(EtvaNode $node, $vms)
  609. //  {
  610. //
  611. //
  612. //
  613. //
  614. //
  615. ////
  616. ////      $this->request->setParameter('params', $new_server);
  617. ////      $this->request->setParameter('method', '');
  618. ////      $this->request->setParameter('id', $node->getId());
  619. ////
  620. ////      $action = sfContext::getInstance()->getController()->getAction('node','getSoap');
  621. ////      $result = $action->executeGetSoap($this->request);
  622. //
  623. //
  624. //
  625. //
  626. //
  627. //        // foreach ($node->getServers() as $i => $server){
  628. //        $node_servers = $node->getEtvaServers();
  629. //        // $node_vlans = EtvaVlanPeer::doSelect(new Criteria());
  630. //
  631. //        // return $node_vlans;
  632. //       // $servers_name = array();
  633. //
  634. //       // foreach($node_servers as $node_server){
  635. //       //     $servers_name[] = $node_server->getName();
  636. //       // }
  637. //
  638. //        $vms_uids = array();
  639. //        foreach($vms as $vm){
  640. //            $vms_uids[] = $vm->uuid;
  641. //        }
  642. //
  643. //
  644. //
  645. //
  646. //
  647. //        foreach($node_servers as $node_server){
  648. //
  649. //             // return $name;
  650. //            // print("a ".$vlan['name']);
  651. //          //  $v = in_array($vm->name,$servers_name);
  652. //        //  print $vm->name;
  653. //            $server_uuid = $node_server->getUid();
  654. //            $server_name = $node_server->getName();
  655. //            $server_path = $node_server->getDisk();
  656. //            $server_ram = $node_server->getMem();
  657. //            $server_cpuset = $node_server->getCpuset();
  658. //
  659. //            $server_networks = $etva_server->getEtvaNetworks();
  660. //            $server_location = $etva_server->getLocation();
  661. //            $networks_string = array();
  662. //
  663. //            foreach($server_networks as $server_network){
  664. //              $networks_string[] = array('name'=>$server_network->getVlan(),
  665. //                                         'macaddr'=>$server_network->getMac());
  666. //            }
  667. //
  668. //            $network_string = implode(';',$networks_string);
  669. //
  670. //
  671. //
  672. //
  673. //            if(!in_array($server_uid,$vms_uids)){
  674. //                try{
  675. //
  676. //
  677. //
  678. //                     $new_server = array(
  679. //                        'uuid'=>$server_uuid,
  680. //                        'name'=>$server_name,
  681. //                        'path'=>$server_path,
  682. //                        'ram'=>$server_ram,
  683. //                        'cpuset'=>$server_cpuset,
  684. //                        'network'=>$network_string,
  685. //                        'nettype'=>'network',
  686. //                        'location'=>$server_location
  687. //                       );
  688. //
  689. //
  690. //                    $this->request->setParameter('params', $new_server);
  691. //                    $this->request->setParameter('id', $node->getId());
  692. //
  693. //                    $action = sfContext::getInstance()->getController()->getAction('node','getSoap');
  694. //                    $result = $action->executeGetSoap($this->request);
  695. //                        return $result;
  696. //                    $disk = $vm->Disks;
  697. //                    $disk_index = 'arrayi-0';
  698. //                   // print $disk->$v->path;
  699. //          //      $variables = get_object_vars($vm->Disks);
  700. ////$keys = array_keys($variables);
  701. //// $value = $variables->$keys[0];
  702. ////print_r($keys[0]);
  703. ////print $variables[$keys[0]]->arrayi-0;
  704. //
  705. //                // $disk = $vm->Disks->arrayi-0;
  706. //              //  $disk = $disk->path;
  707. //                $etva_server = new EtvaServer();
  708. //                $etva_server->setName($vm->name);
  709. //                $etva_server->setVncPort($vm->vnc_port);
  710. //                $etva_server->setUid($vm->uuid);
  711. //                $etva_server->setMem($vm->memory);
  712. //                $etva_server->setDisk($disk->$disk_index->path);
  713. //
  714. //                if(isset($vm->cpuset))
  715. //                    $etva_server->setRcpu($vm->cpuset);
  716. //
  717. //                if(isset($vm->vcpu))
  718. //                    $etva_server->setVcpu($vm->vcpu);
  719. //
  720. //                $etva_server->setIp('0');
  721. //                $etva_server->setState($vm->state);
  722. //                $etva_server->setNodeId($node->getId());
  723. //                $etva_server->setSfGuardGroupId(1);
  724. //            //    return 'retornou agora :-)';
  725. //                if($etva_server->validate()){
  726. //                    $etva_server->save();
  727. //
  728. //                      $server_networks = $etva_server->getEtvaNetworks();
  729. //                      $networks_id = array();
  730. //
  731. //                      foreach($server_networks as $server_network){
  732. //                        $networks_id[] = $server_network->getPort();
  733. //                      }
  734. //
  735. //                      $vm_networks = $vm->Network;
  736. //
  737. //                      foreach($vm_networks as $vm_net){
  738. //
  739. //                          if(!in_array($vm_net->i,$networks_id)){
  740. //
  741. //                              $etva_network = new EtvaNetwork();
  742. //                              $etva_network->setServerId($etva_server->getId());
  743. //                              $etva_network->setPort($vm_net->i);
  744. //                              $etva_network->setMac($vm_net->macaddr);
  745. //                              $etva_network->setVlan($vm_net->name);
  746. //                              $etva_network->save();
  747. //
  748. //
  749. //
  750. //                            }
  751. //
  752. //                      }
  753. //
  754. //
  755. //
  756. //                }
  757. //
  758. //
  759. //            }
  760. //            catch(Exception $e){
  761. //                    return "ddd".$e;
  762. //                }
  763. //            }
  764. //        }
  765. //
  766. //
  767. //    //    $etva_node->setByName($request->getParameter('field'), $request->getParameter('value'),BasePeer::TYPE_FIELDNAME);
  768. //     //   $etva_node->save();
  769. //
  770. //        $result = array('success'=>true);
  771. //        return $result;
  772. //    }
  773.  
  774.  
  775.  
  776.   public function executeUpdate_old(EtvaNode $node$vms)
  777.   {
  778.  
  779.  
  780.  
  781.  
  782. //for ($i = 0; $i < count($vms); $i++) {
  783.  
  784. //$arr[] = get_object_vars($vms[$i]);
  785.  
  786. //}
  787.  
  788.  
  789.        
  790.  
  791.         // foreach ($node->getServers() as $i => $server){
  792.         $node_servers $node->getEtvaServers();
  793.         // $node_vlans = EtvaVlanPeer::doSelect(new Criteria());
  794.  
  795.         // return $node_vlans;
  796.         $servers_name array();
  797.  
  798.         foreach($node_servers as $node_server){
  799.             $servers_name[$node_server->getName();
  800.         }
  801.  
  802.  
  803.         if(!empty($vms))
  804.         foreach($vms as $vm){
  805.             
  806.              // return $name;
  807.             // print("a ".$vlan['name']);
  808.           //  $v = in_array($vm->name,$servers_name);
  809.         //  print $vm->name;
  810.  
  811.             if(!in_array($vm->name,$servers_name)){
  812.                 try{
  813.  
  814.                     $disk $vm->Disks;
  815.                     $disk_index 'arrayi-0';
  816.                    // print $disk->$v->path;
  817.           //      $variables = get_object_vars($vm->Disks);
  818. //$keys = array_keys($variables);
  819. // $value = $variables->$keys[0];
  820. //print_r($keys[0]);
  821. //print $variables[$keys[0]]->arrayi-0;
  822.  
  823.                 // $disk = $vm->Disks->arrayi-0;
  824.               //  $disk = $disk->path;
  825.                 $etva_server new EtvaServer();
  826.                 $etva_server->setName($vm->name);
  827.                 $etva_server->setVncPort($vm->vnc_port);
  828.                 $etva_server->setUid($vm->uuid);
  829.                 $etva_server->setMem($vm->memory);
  830.                 $etva_server->setDisk($disk->$disk_index->path);
  831.  
  832.                 if(isset($vm->cpuset))
  833.                     $etva_server->setRcpu($vm->cpuset);
  834.  
  835.                 if(isset($vm->vcpu))
  836.                     $etva_server->setVcpu($vm->vcpu);
  837.  
  838.                 $etva_server->setIp('0');
  839.                 $etva_server->setState($vm->state);
  840.                 $etva_server->setNodeId($node->getId());
  841.                 $etva_server->setSfGuardGroupId(1);
  842.             //    return 'retornou agora :-)';
  843.                 if($etva_server->validate()){
  844.                     $etva_server->save();
  845.  
  846.                       $server_networks $etva_server->getEtvaNetworks();
  847.                       $networks_id array();
  848.  
  849.                       foreach($server_networks as $server_network){
  850.                         $networks_id[$server_network->getPort();
  851.                       }
  852.  
  853.                       $vm_networks $vm->Network;
  854.  
  855.                       foreach($vm_networks as $vm_net){
  856.  
  857.                           if(!in_array($vm_net->i,$networks_id)){
  858.                               
  859.                               $etva_network new EtvaNetwork();
  860.                               $etva_network->setServerId($etva_server->getId());
  861.                               $etva_network->setPort($vm_net->i);
  862.                               $etva_network->setMac($vm_net->macaddr);
  863.                               $etva_network->setVlan($vm_net->name);
  864.                               $etva_network->save();
  865.                               
  866.                               
  867.  
  868.                             }
  869.  
  870.                       }
  871.  
  872.                      
  873.  
  874.                 }
  875.                 
  876.                
  877.             }
  878.             catch(Exception $e){
  879.                     return "ddd".$e;
  880.                 }
  881.             }
  882.         }
  883.  
  884.  
  885.     //    $etva_node->setByName($request->getParameter('field'), $request->getParameter('value'),BasePeer::TYPE_FIELDNAME);
  886.      //   $etva_node->save();
  887.  
  888.         $result array('success'=>true);
  889.         return $result;
  890.     }
  891.  
  892.   
  893.   
  894.  
  895.  
  896. }

Documentation generated on Fri, 19 Jun 2009 10:45:35 +0100 by phpDocumentor 1.4.2