Exemplo n.º 1
0
 protected function execute($arguments = array(), $options = array())
 {
     $context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $connection = $databaseManager->getDatabase($options['connection'])->getConnection();
     // add your code here
     // get parameters
     $lv = $arguments['name'];
     $size = $arguments['size'];
     $vg = $arguments['volumegroup'];
     $node_id = $options['node'];
     $format = $options['format'];
     $persnapshotusage = $options['persnapshotusage'];
     /*
      * check if lv is a file disk instead
      * if is a file disk check if special volume group exists. if not create
      */
     $is_DiskFile = $vg == sfConfig::get('app_volgroup_disk_flag') ? 1 : 0;
     // get etva_node
     $etva_node = EtvaNodePeer::getOrElectNodeFromArray(array_merge($options, $arguments));
     if (!$etva_node) {
         $msg_i18n = $context->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $node_id));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $this->log("[ERROR] " . $error['error']);
         return $error;
     }
     // get logical volume
     if ($etva_lv = $etva_node->retrieveLogicalvolumeByLv($lv)) {
         $msg_type = $is_DiskFile ? EtvaLogicalvolumePeer::_ERR_DISK_EXIST_ : EtvaLogicalvolumePeer::_ERR_LV_EXIST_;
         $msg = Etva::getLogMessage(array('name' => $lv), $msg_type);
         $msg_i18n = $context->getI18N()->__($msg_type, array('%name%' => $lv));
         $error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $this->log("[ERROR] " . $error['error']);
         return $error;
     }
     if (!($etva_vg = $etva_node->retrieveVolumegroupByVg($vg))) {
         $msg = Etva::getLogMessage(array('name' => $vg), EtvaVolumegroupPeer::_ERR_NOTFOUND_);
         $msg_i18n = $context->getI18N()->__(EtvaVolumegroupPeer::_ERR_NOTFOUND_, array('%name%' => $vg));
         $error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $this->log("[ERROR] " . $error['error']);
         return $error;
     }
     // prepare soap info....
     $etva_lv = new EtvaLogicalvolume();
     $etva_lv->setEtvaVolumegroup($etva_vg);
     $etva_lv->setLv($lv);
     $lv_va = new EtvaLogicalvolume_VA($etva_lv);
     $response = $lv_va->send_create($etva_node, $size, $format, $persnapshotusage);
     if (!$response['success']) {
         $this->log("[ERROR] " . $response['error']);
     } else {
         $this->log("[INFO] " . $response['response']);
     }
     return $response;
 }
Exemplo n.º 2
0
 private function updateRemovedLogicalVolumes(EtvaNode $etva_node, $server_lvs)
 {
     $etva_server = $this->etva_server;
     $etva_cluster = $etva_node->getEtvaCluster();
     foreach ($server_lvs as $logicalvol) {
         // if logical volume is shared
         if ($logicalvol->getStorageType() != EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP) {
             $lvdevice = $logicalvol->getLvdevice();
             // remove device in each node
             $etva_cluster->soapSend('device_remove', array('device' => $lvdevice), $etva_node);
         }
     }
     $lv_va = new EtvaLogicalvolume_VA();
     $lv_va->send_update($etva_node);
 }
Exemplo n.º 3
0
 public function executeJsonUnregister(sfWebRequest $request)
 {
     $msg_ok_type = EtvaLogicalvolumePeer::_OK_UNREGISTER_;
     $msg_err_type = EtvaLogicalvolumePeer::_ERR_UNREGISTER_;
     // get node id
     if (!($etva_node = EtvaNodePeer::retrieveByPK($request->getParameter('nid')))) {
         // ... or elect from cluster context
         $etva_node = EtvaNodePeer::getOrElectNode($request);
     }
     if (!$etva_node) {
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $node_log = Etva::getLogMessage(array('id' => $nid), EtvaNodePeer::_ERR_NOTFOUND_ID_);
         //notify system log
         $this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $node_log, 'priority' => EtvaEventLogger::ERR)));
         // if is a CLI soap request return json encoded data
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($error);
         }
         // if is browser request return text renderer
         $error = $this->setJsonError($error);
         return $this->renderText($error);
     }
     $lv = $request->getParameter('lv');
     $vg = $request->getParameter('vg');
     $uuid = $request->getParameter('uuid');
     if (!($etva_logicalvolume = $etva_node->retrieveLogicalvolume($uuid, $vg, $lv))) {
         //lv is the logical volume name
         $msg = Etva::getLogMessage(array('name' => $lv), EtvaLogicalvolumePeer::_ERR_NOTFOUND_);
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_NOTFOUND_, array('%name%' => $lv));
         $error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
         //notify system log
         $message = Etva::getLogMessage(array('name' => $lv, 'info' => $msg), EtvaLogicalvolumePeer::_ERR_UNREGISTER_);
         $this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         // if is a CLI soap request return json encoded data
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($error);
         }
         // if is browser request return text renderer
         $error = $this->setJsonError($error);
         return $this->renderText($error);
     }
     $etva_lv_va = new EtvaLogicalvolume_VA($etva_logicalvolume);
     $response = $etva_lv_va->unregister($etva_node);
     if (!$response['success']) {
         $msg_i18n = $this->getContext()->getI18N()->__($msg_err_type, array('%name%' => $lv));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $node_log = Etva::getLogMessage(array('name' => $lv), $msg_err_type);
         //notify system log
         $this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $node_log, 'priority' => EtvaEventLogger::ERR)));
         // if is a CLI soap request return json encoded data
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($error);
         }
         // if is browser request return text renderer
         $error = $this->setJsonError($error);
         return $this->renderText($error);
     }
     //notify system log
     $message = Etva::getLogMessage(array('name' => $lv), $msg_ok_type);
     $msg_i18n = sfContext::getInstance()->getI18N()->__($msg_ok_type, array('%name%' => $lv));
     sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message)));
     $result = array('success' => true, 'agent' => $etva_node->getName(), 'response' => $msg_i18n);
     $return = json_encode($result);
     if (sfConfig::get('sf_environment') == 'soap') {
         return $return;
     }
     $this->getResponse()->setHttpHeader('Content-type', 'application/json');
     return $this->renderText($return);
 }
Exemplo n.º 4
0
 public function executeJsonImport(sfWebRequest $request)
 {
     $nid = $request->getParameter('nid');
     $import_data = json_decode($request->getParameter('import'), true);
     $server = $import_data;
     $vnc_keymap = EtvaSettingPeer::retrieveByPk('vnc_keymap');
     $server['vnc_keymap'] = $vnc_keymap->getValue();
     $server['uuid'] = EtvaServerPeer::generateUUID();
     $server['name'] = $import_data['name'];
     $server['vm_type'] = $import_data['vm_type'];
     $server['ip'] = '000.000.000.000';
     $server['boot'] = 'filesystem';
     $import_data['uuid'] = $server['uuid'];
     $import_data['vnc_keymap'] = $server['vnc_keymap'];
     // import validation check
     $result = $this->jsonImportCheck($request);
     if (!$result['success']) {
         // if is a CLI soap request return json encoded data
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($result);
         }
         // if is browser request return text renderer
         $error = $this->setJsonError($result);
         return $this->renderText($error);
     }
     if (!($etva_node = EtvaNodePeer::retrieveByPK($nid))) {
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         //notify event log
         $node_log = Etva::getLogMessage(array('id' => $nid), EtvaNodePeer::_ERR_NOTFOUND_ID_);
         $message = Etva::getLogMessage(array('info' => $node_log), OvfEnvelope_VA::_ERR_IMPORT_);
         $this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         // if is a CLI soap request return json encoded data
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($error);
         }
         // if is browser request return text renderer
         $error = $this->setJsonError($error);
         return $this->renderText($error);
     }
     $disks = $import_data['disks'];
     $collVgs = array();
     foreach ($disks as $id => $info) {
         $vg = $info['vg'];
         $lv = $info['lv'];
         if ($etva_lv = $etva_node->retrieveLogicalvolumeByLv($lv)) {
             $msg_type = $is_DiskFile ? EtvaLogicalvolumePeer::_ERR_DISK_EXIST_ : EtvaLogicalvolumePeer::_ERR_LV_EXIST_;
             $msg = Etva::getLogMessage(array('name' => $lv), $msg_type);
             $msg_i18n = $this->getContext()->getI18N()->__($msg_type, array('%name%' => $lv));
             $error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
             //notify system log
             $message = Etva::getLogMessage(array('name' => $lv, 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
             $this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
             // if is a CLI soap request return json encoded data
             if (sfConfig::get('sf_environment') == 'soap') {
                 return json_encode($error);
             }
             // if is browser request return text renderer
             $error = $this->setJsonError($error);
             return $this->renderText($error);
         }
         if (!($etva_vg = $etva_node->retrieveVolumegroupByVg($vg))) {
             $msg = Etva::getLogMessage(array('name' => $vg), EtvaVolumegroupPeer::_ERR_NOTFOUND_);
             $msg_i18n = $this->getContext()->getI18N()->__(EtvaVolumegroupPeer::_ERR_NOTFOUND_, array('%name%' => $vg));
             $error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
             //notify system log
             $message = Etva::getLogMessage(array('name' => $lv, 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
             $this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
             // if is a CLI soap request return json encoded data
             if (sfConfig::get('sf_environment') == 'soap') {
                 return json_encode($error);
             }
             // if is browser request return text renderer
             $error = $this->setJsonError($error);
             return $this->renderText($error);
         }
         // fix lv path
         $is_DiskFile = $vg == sfConfig::get('app_volgroup_disk_flag') ? 1 : 0;
         $import_data['disks'][$id]['lv'] = $is_DiskFile ? $etva_node->getStoragedir() . '/' . $lv : $lv;
         $collVgs[$vg] = $etva_vg;
     }
     $networks = $import_data['networks'];
     $networks_va = $import_data['networks'];
     $collNetworks = array();
     $i = 0;
     // check if networks are available
     foreach ($networks as $network) {
         if ($etva_vlan = EtvaVlanPeer::retrieveByPk($network['vlan_id'])) {
             $import_data['networks'][$i]['network'] = $etva_vlan->getName();
             $import_data['networks'][$i]['macaddr'] = $network['mac'];
         }
         $etva_mac = EtvaMacPeer::retrieveByMac($network['mac']);
         /*
          * TODO improve this to add Mac Address to the pool
          */
         if (!$etva_mac || !$etva_vlan) {
             $msg = Etva::getLogMessage(array(), EtvaNetworkPeer::_ERR_);
             $msg_i18n = $this->getContext()->getI18N()->__(EtvaNetworkPeer::_ERR_, array());
             if (!$etva_mac) {
                 $msg = Etva::getLogMessage(array('%mac%' => $network['mac']), EtvaMacPeer::_ERR_INVALID_MAC_);
                 $msg_i18n = $this->getContext()->getI18N()->__(EtvaMacPeer::_ERR_INVALID_MAC_, array('%mac%' => $network['mac']));
             }
             $error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
             //notify event log
             $message = Etva::getLogMessage(array('name' => $server['name'], 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
             $this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
             // if is a CLI soap request return json encoded data
             if (sfConfig::get('sf_environment') == 'soap') {
                 return json_encode($error);
             }
             // if is browser request return text renderer
             $error = $this->setJsonError($error);
             return $this->renderText($error);
         }
         if ($etva_mac->getInUse()) {
             $msg = Etva::getLogMessage(array('%name%' => $etva_mac->getMac()), EtvaMacPeer::_ERR_ASSIGNED_);
             $msg_i18n = $this->getContext()->getI18N()->__(EtvaMacPeer::_ERR_ASSIGNED_, array('%name%' => $etva_mac->getMac()));
             $error = array('success' => false, 'agent' => $etva_node->getName(), 'info' => $msg_i18n, 'error' => $msg_i18n);
             //notify event log
             $message = Etva::getLogMessage(array('name' => $server['name'], 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
             $this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
             // if is a CLI soap request return json encoded data
             if (sfConfig::get('sf_environment') == 'soap') {
                 return json_encode($error);
             }
             // if is browser request return text renderer
             $error = $this->setJsonError($error);
             return $this->renderText($error);
         }
         $etva_network = new EtvaNetwork();
         $etva_network->fromArray($network, BasePeer::TYPE_FIELDNAME);
         $collNetworks[] = $etva_network;
         $i++;
     }
     $env = new OvfEnvelope_VA();
     $env->fromArray($import_data);
     /* get server copy VA server representation */
     $params = $env->_VA();
     $method = 'vm_ovf_import_may_fork';
     $response = $etva_node->soapSend($method, $params);
     if (!$response['success']) {
         $error_decoded = $response['error'];
         $result = $response;
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaServerPeer::_ERR_CREATE_, array('%name%' => $server['name'], '%info%' => $error_decoded));
         $result['error'] = $msg_i18n;
         //notify event log
         $message = Etva::getLogMessage(array('name' => $server['name'], 'info' => $response['info']), EtvaServerPeer::_ERR_CREATE_);
         $this->dispatcher->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($result);
         }
         $return = $this->setJsonError($result);
         return $this->renderText($return);
     }
     $response_decoded = (array) $response['response'];
     $returned_object = (array) $response_decoded['_obj_'];
     $returned_lvs = (array) $returned_object['LVS'];
     $collLvs = array();
     foreach ($returned_lvs as $disk) {
         $disk_array = (array) $disk;
         $vg_info = (array) $disk_array[EtvaLogicalvolume::VOLUMEGROUP_MAP];
         $vg = $vg_info[EtvaVolumegroup::VG_MAP];
         $fake_lv_response = array('success' => true, 'response' => array('_obj_' => $disk_array));
         // create logical volume
         $etva_lv = new EtvaLogicalvolume();
         $etva_lv->setEtvaVolumegroup($collVgs[$vg]);
         $lv_va = new EtvaLogicalvolume_VA($etva_lv);
         $lv_response = $lv_va->processResponse($etva_node, $fake_lv_response, 'lvcreate');
         if (!$lv_response['success']) {
             $return = $this->setJsonError($lv_response);
             return $this->renderText($return);
         }
         $collLvs[] = $etva_lv;
     }
     $etva_server = new EtvaServer();
     $etva_server->fromArray($server, BasePeer::TYPE_FIELDNAME);
     $user_groups = $this->getUser()->getGroups();
     $server_sfgroup = array_shift($user_groups);
     //if user has group then put one of them otherwise put DEFAULT GROUP ID
     if ($server_sfgroup) {
         $etva_server->setsfGuardGroup($server_sfgroup);
     } else {
         $etva_server->setsfGuardGroup(sfGuardGroupPeer::getDefaultGroup());
     }
     foreach ($collNetworks as $coll) {
         $etva_server->addEtvaNetwork($coll);
     }
     $i = 0;
     foreach ($collLvs as $coll) {
         $server_disk = new EtvaServerLogical();
         $server_disk->setEtvaLogicalvolume($coll);
         $server_disk->setBootDisk($i);
         $etva_server->addEtvaServerLogical($server_disk);
         $i++;
     }
     //update some data from agent response
     $vm = (array) $returned_object['VM'];
     $etva_server->initData($vm);
     //$etva_server->setEtvaNode($etva_node);
     $etva_server->setEtvaCluster($etva_node->getEtvaCluster());
     try {
         $etva_server->save();
     } catch (Exception $e) {
         $msg = $e->getMessage();
         $result = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg, 'info' => $msg);
         $return = $this->setJsonError($result);
         return $this->renderText($return);
     }
     // assign To etva_node
     $etva_server->assignTo($etva_node);
     $msg_i18n = $this->getContext()->getI18N()->__(EtvaServerPeer::_OK_CREATE_, array('%name%' => $server['name']));
     $message = Etva::getLogMessage(array('name' => $server['name']), EtvaServerPeer::_OK_CREATE_);
     $this->dispatcher->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message)));
     $result = array('success' => true, 'agent' => $response['agent'], 'insert_id' => $etva_server->getId(), 'response' => $msg_i18n);
     $return = json_encode($result);
     $this->getResponse()->setHttpHeader('Content-type', 'application/json');
     // if is browser request return text renderer
     return $this->renderText($return);
 }
Exemplo n.º 5
0
 public function register(EtvaNode $etva_node, $vg_info = null)
 {
     $etva_cluster = $etva_node->getEtvaCluster();
     // check if volumegroup is shared
     $shared = $this->etva_vg->getStorageType() != EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP;
     // force to load volume groups
     $bulk_responses = array();
     if ($shared) {
         $bulk_responses = $etva_cluster->soapSend(self::GET_SYNC_VOLUMEGROUPS, array('force' => 1));
     } else {
         $node_id = $etva_node->getId();
         $bulk_responses[$node_id] = $etva_node->soapSend(self::GET_SYNC_VOLUMEGROUPS, array('force' => 1));
     }
     $vg_info_sync = $this->getVolumegroupInfo($etva_node, $bulk_responses);
     // merge vg info
     if ($vg_info_sync) {
         $vg_info = $vg_info ? array_merge($vg_info_sync, $vg_info) : $vg_info_sync;
     }
     // set vg info if needed
     if ($vg_info) {
         $this->etva_vg->initData($vg_info);
     }
     // for none local storage devices
     if ($shared) {
         // check if all nodes see that
         $check_res = $this->check_all_see_it($etva_node, $bulk_responses);
         if (!$check_res['success']) {
             return array('success' => false, 'errors' => $check_res['errors'], 'debug' => 'check_all_see_it');
         }
     }
     $etva_volgroup = $this->etva_vg;
     // set cluster
     $etva_cluster = $etva_node->getEtvaCluster();
     $etva_volgroup->setEtvaCluster($etva_cluster);
     // save it
     $etva_volgroup->save();
     // create relation node_volumegorup
     $etva_node_volgroup = new EtvaNodeVolumegroup();
     $etva_node_volgroup->setEtvaVolumegroup($etva_volgroup);
     $etva_node_volgroup->setEtvaNode($etva_node);
     $etva_node_volgroup->save();
     if ($vg_info) {
         /*
          * associate pvs with vg and update info
          */
         $pvs = isset($vg_info[EtvaVolumegroup::PHYSICALVOLUMES_MAP]) ? (array) $vg_info[EtvaVolumegroup::PHYSICALVOLUMES_MAP] : array();
         foreach ($pvs as $pv => $pvInfo) {
             $pv_info = (array) $pvInfo;
             $pv_type = $pv_info[EtvaPhysicalvolume::STORAGE_TYPE_MAP];
             $pv_uuid = isset($pv_info[EtvaPhysicalvolume::UUID_MAP]) ? $pv_info[EtvaPhysicalvolume::UUID_MAP] : '';
             $pv_device = $pv_info[EtvaPhysicalvolume::DEVICE_MAP];
             //error_log(sprintf("node name=%s id=%d device=%s uuid=%s type=%s",$etva_node->getName(),$etva_node->getId(),$pv_device,$pv_uuid,$pv_type));
             //get physical volume based on node, type, uuid and device
             $etva_physical = EtvaPhysicalvolumePeer::retrieveByNodeTypeUUIDDevice($etva_node->getId(), $pv_type, $pv_uuid, $pv_device);
             if (!$etva_physical) {
                 $etva_physical = new EtvaPhysicalvolume();
             }
             $etva_physical->setEtvaCluster($etva_cluster);
             $etva_physical->initData($pv_info);
             $etva_physical->save();
             $etva_node_physical = EtvaNodePhysicalvolumePeer::retrieveByPK($etva_node->getId(), $etva_physical->getId());
             if (!$etva_node_physical) {
                 $etva_node_physical = new EtvaNodePhysicalvolume();
             }
             $etva_node_physical->setEtvaPhysicalvolume($etva_physical);
             $etva_node_physical->setEtvaNode($etva_node);
             $etva_node_physical->setDevice($pv_device);
             $etva_node_physical->save();
             $etva_volgroup_physical = EtvaVolumePhysicalPeer::retrieveByPK($etva_volgroup->getId(), $etva_physical->getId());
             if (!$etva_volgroup_physical) {
                 $etva_volgroup_physical = new EtvaVolumePhysical();
             }
             $etva_volgroup_physical->setEtvaPhysicalvolume($etva_physical);
             $etva_volgroup_physical->setEtvaVolumegroup($etva_volgroup);
             $etva_volgroup_physical->save();
         }
     }
     // for no local storage type
     $errors = $this->sync_update($bulk_responses);
     if (!empty($errors)) {
         return array('success' => false, 'errors' => $errors);
     }
     // update logical volumes
     $lv_va = new EtvaLogicalvolume_VA();
     $lv_errors = $lv_va->send_update($etva_node, true, $shared);
     if (!empty($lv_errors)) {
         return array('success' => false, 'errors' => $lv_errors);
     }
     return array('success' => true);
 }
 protected function execute($arguments = array(), $options = array())
 {
     $context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
     parent::execute($arguments, $options);
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $connection = $databaseManager->getDatabase($options['connection'])->getConnection();
     // add your code here
     $this->log('Checking shared storage cluster consistency...' . "\n");
     $ok = 1;
     $affected = 0;
     $errors = array();
     $clusters = EtvaClusterPeer::doSelect(new Criteria());
     foreach ($clusters as $cluster) {
         $bulk_response_lvs = $cluster->soapSend('getlvs_arr', array('force' => 1));
         $bulk_response_dtable = $cluster->soapSend('device_table');
         $lv_va = new EtvaLogicalvolume_VA();
         foreach ($bulk_response_lvs as $node_id => $node_response) {
             if ($node_response['success']) {
                 //response received ok
                 $lvs = (array) $node_response['response'];
                 $node = EtvaNodePeer::retrieveByPK($node_id);
                 //$consist = $lv_va->check_shared_consistency($node,$lvs);
                 $response_dtable = (array) $bulk_response_dtable[$node_id];
                 $dtable = array();
                 if ($response_dtable['success']) {
                     $dtable = (array) $response_dtable['response'];
                     //$consist_dtable = $lv_va->check_shared_devicetable_consistency($node,$dtable,$bulk_response_dtable);
                 }
                 $check_res = $lv_va->check_consistency($node, $lvs, $dtable, $bulk_response_dtable);
                 if (!$check_res['success']) {
                     $err = $check_res['errors'];
                     $msg = sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => ''));
                     $err_msg = sprintf(" node with id=%s is not consistent: %s \n", $node_id, $msg);
                     $errors[] = array('message' => $err_msg, 'debug' => $err);
                     $affected++;
                     $node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
                 } else {
                     $node->clearErrorMessage(EtvaLogicalvolume_VA::LVINIT);
                 }
                 /*if( !$consist || !$consist_dtable ){
                                     $errors = $lv_va->get_missing_lv_devices();
                                     $msg = $errors ? $errors['message'] :
                                                     sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_,array('%info%'=>''));
                 
                                     $err_msg = sprintf( " node with id=%s is not consistent: %s \n", $node_id, $msg );
                                     $errors[] = array( 'message'=> $err_msg, 'debug'=>array( 'consist_lvs'=>$consist, 'consist_dtable'=>$consist_dtable ) );
                                     $affected++;
                                     $node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
                                 } else {
                                     $node->clearErrorMessage(EtvaLogicalvolume_VA::LVINIT);
                                 }*/
             } else {
                 $errors[] = $node_response;
                 $affected++;
             }
         }
         $bulk_response_pvs = $cluster->soapSend('hash_phydisks', array('force' => 1));
         $pv_va = new EtvaPhysicalvolume_VA();
         foreach ($bulk_response_pvs as $node_id => $node_response) {
             if ($node_response['success']) {
                 //response received ok
                 $pvs = (array) $node_response['response'];
                 $node = EtvaNodePeer::retrieveByPK($node_id);
                 $check_res = $pv_va->check_consistency($node, $pvs);
                 if (!$check_res['success']) {
                     $err = $check_res['errors'];
                     $msg = sfContext::getInstance()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => ''));
                     $err_msg = sprintf(" node with id=%s is not consistent: %s \n", $node_id, $msg);
                     $errors[] = array('message' => $err_msg, 'debug' => $err);
                     $affected++;
                     $node->setErrorMessage(EtvaPhysicalvolume_VA::PVINIT);
                 } else {
                     $node->clearErrorMessage(EtvaPhysicalvolume_VA::PVINIT);
                 }
             } else {
                 $errors[] = $node_response;
                 $affected++;
             }
         }
         $bulk_responses_vgs = $cluster->soapSend('getvgpvs', array('force' => 1));
         $vg_va = new EtvaVolumegroup_VA();
         foreach ($bulk_response_vgs as $node_id => $node_response) {
             if ($node_response['success']) {
                 //response received ok
                 $vgs = (array) $node_response['response'];
                 $node = EtvaNodePeer::retrieveByPK($node_id);
                 $check_res = $vg_va->check_consistency($node, $vgs);
                 if (!$check_res['success']) {
                     $err = $check_res['errors'];
                     $msg = sfContext::getInstance()->getI18N()->__(EtvaVolumegroupPeer::_ERR_INCONSISTENT_, array('%info%' => ''));
                     $err_msg = sprintf(" node with id=%s is not consistent: %s \n", $node_id, $msg);
                     $errors[] = array('message' => $err_msg, 'debug' => $err);
                     $affected++;
                     $node->setErrorMessage(EtvaVolumegroup_VA::VGINIT);
                 } else {
                     $node->clearErrorMessage(EtvaVolumegroup_VA::VGINIT);
                 }
             } else {
                 $errors[] = $node_response;
                 $affected++;
             }
         }
     }
     if (!empty($errors)) {
         $this->log($message);
     } else {
         // log the message!
         $this->log("The check shared storage cluster consistency task ran!", 6);
     }
 }
Exemplo n.º 7
0
 public function executeJsonInit(sfWebRequest $request)
 {
     $id = $request->getParameter('id');
     $etva_node = EtvaNodePeer::retrieveByPK($id);
     $res = $this->check_pvs($etva_node);
     if ($res) {
         return $res;
     }
     $res = $this->check_vgs($etva_node);
     if ($res) {
         return $res;
     }
     $res = $this->check_lvs($etva_node);
     if ($res) {
         return $res;
     }
     $node_response = $etva_node->soapSend('getlvs_arr', array('force' => 1));
     if (!$node_response['success']) {
         $errors = $node_response['error'];
         Etva::getLogMessage(array('info' => ''), EtvaLogicalvolumePeer::_ERR_INCONSISTENT_);
         $etva_node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
         $message = Etva::getLogMessage(array('info' => $node_response['info']), EtvaLogicalvolumePeer::_ERR_SOAPUPDATE_);
         sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_SOAPUPDATE_, array('%info%' => $node_response['info']));
         $response = array('success' => false, 'error' => $msg_i18n, 'agent' => $etva_node->getName());
         $return = $this->setJsonError($response);
         return $this->renderText($return);
     }
     $dtable = array();
     $response_dtable = $etva_node->soapSend('device_table');
     if (!$response_dtable['success']) {
         $errors = $response_dtable['error'];
         Etva::getLogMessage(array('info' => ''), EtvaLogicalvolumePeer::_ERR_INCONSISTENT_);
         $etva_node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
         $message = Etva::getLogMessage(array('info' => $response_dtable['info']), EtvaLogicalvolumePeer::_ERR_SOAPUPDATE_);
         sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_SOAPUPDATE_, array('%info%' => $response_dtable['info']));
         $response = array('success' => false, 'error' => $msg_i18n, 'agent' => $etva_node->getName());
         $return = $this->setJsonError($response);
         return $this->renderText($return);
     }
     $lvs = (array) $node_response['response'];
     $dtable = (array) $response_dtable['response'];
     $etva_cluster = $etva_node->getEtvaCluster();
     $bulk_response_dtable = $etva_cluster->soapSend('device_table');
     $lv_va = new EtvaLogicalvolume_VA();
     $check_res = $lv_va->check_consistency($etva_node, $lvs, $dtable, $bulk_response_dtable);
     if (!$check_res['success']) {
         $errors = $check_res['errors'];
         $inconsistent_message = Etva::getLogMessage(array('info' => print_r($errors, true)), EtvaLogicalvolumePeer::_ERR_INCONSISTENT_);
         $inconsistent_message_i18n = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => ''));
         $etva_node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
         $message = Etva::getLogMessage(array('info' => $inconsistent_message), EtvaLogicalvolumePeer::_ERR_SOAPUPDATE_);
         sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_SOAPUPDATE_, array('%info%' => $inconsistent_message_i18n));
         //$response = array('success'=>false,'error'=>$errors);
         $response = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $return = $this->setJsonError($response);
     }
     //accept node
     $cmd = $request->getParameter('cmd');
     if (!$etva_node) {
         $msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $id));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         //notify event log
         $node_log = Etva::getLogMessage(array('id' => $id), EtvaNodePeer::_ERR_NOTFOUND_ID_);
         $message = Etva::getLogMessage(array('name' => '', 'cmd' => $cmd, 'info' => $node_log), EtvaNodePeer::_ERR_INITIALIZE_CMD_);
         $this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
         // if is browser request return text renderer
         $error = $this->setJsonError($error);
         return $this->renderText($error);
     }
     $node_va = new EtvaNode_VA($etva_node);
     $response = $node_va->send_initialize();
     if ($response['success']) {
         $return = json_encode($response);
         // if the request is made throught soap request...
         if (sfConfig::get('sf_environment') == 'soap') {
             return $return;
         }
         // if is browser request return text renderer
         $this->getResponse()->setHttpHeader('Content-type', 'application/json');
         return $this->renderText($return);
     } else {
         if (sfConfig::get('sf_environment') == 'soap') {
             return json_encode($response);
         }
         $return = $this->setJsonError($response);
         return $this->renderText($return);
     }
 }
Exemplo n.º 8
0
 public function systemCheck()
 {
     $etva_node = $this->etva_node;
     $method = self::SYSTEMCHECK;
     $response = $etva_node->soapSend($method, null, true);
     $success = $response['success'];
     $return = array();
     if (!$success) {
         //notify system log
         $message = Etva::makeNotifyLogMessage($etva_node->getName(), EtvaNodePeer::_ERR_SYSTEMCHECK_, array('name' => $etva_node->getName(), 'info' => $response['info']));
         $return = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $message, 'info' => $message);
         return $return;
     }
     $node_response = $etva_node->soapSend('getlvs_arr', array('force' => 1));
     if (!$node_response['success']) {
         $errors = $node_response['error'];
         $etva_node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
         $msg_i18n = Etva::makeNotifyLogMessage($etva_node->getName(), EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('info' => $node_response['info']), EtvaNodePeer::_ERR_SYSTEMCHECK_, array('name' => $etva_node->getName()));
         $return = array('success' => false, 'error' => $msg_i18n, 'agent' => $etva_node->getName());
         return $return;
     }
     $dtable = array();
     $response_dtable = $etva_node->soapSend('device_table');
     if (!$response_dtable['success']) {
         $errors = $response_dtable['error'];
         $etva_node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
         $msg_i18n = Etva::makeNotifyLogMessage($etva_node->getName(), EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('info' => $response_dtable['info']), EtvaNodePeer::_ERR_SYSTEMCHECK_, array('name' => $etva_node->getName()));
         $return = array('success' => false, 'error' => $msg_i18n, 'agent' => $etva_node->getName());
         return $return;
     }
     $lvs = (array) $node_response['response'];
     $dtable = (array) $response_dtable['response'];
     $etva_cluster = $etva_node->getEtvaCluster();
     $bulk_response_dtable = $etva_cluster->soapSend('device_table');
     $lv_va = new EtvaLogicalvolume_VA();
     $check_res = $lv_va->check_consistency($etva_node, $lvs, $dtable, $bulk_response_dtable);
     if (!$check_res['success']) {
         $errors = $check_res['errors'];
         $etva_node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
         $msg_i18n = Etva::makeNotifyLogMessage($etva_node->getName(), EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('info' => print_r($errors, true)), EtvaNodePeer::_ERR_SYSTEMCHECK_, array('name' => $etva_node->getName()));
         $return = array('success' => false, 'error' => $msg_i18n, 'agent' => $etva_node->getName(), 'info' => $msg_i18n);
         return $return;
     }
     $etva_node->setState(EtvaNode::NODE_ACTIVE);
     $etva_node->save();
     //notify system log
     $message = Etva::makeNotifyLogMessage($etva_node->getName(), EtvaNodePeer::_OK_SYSTEMCHECK_, array('name' => $etva_node->getName()), null, array(), EtvaEventLogger::INFO);
     $return = array('success' => true, 'agent' => $etva_node->getName(), 'response' => $message);
     return $return;
 }
Exemplo n.º 9
0
 protected function execute($arguments = array(), $options = array())
 {
     $context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $connection = $databaseManager->getDatabase($options['connection'])->getConnection();
     // add your code here
     // get node
     $node_id = $options['node'];
     $etva_node = EtvaNodePeer::getOrElectNodeFromArray(array_merge($options, $arguments));
     if (!$etva_node) {
         $msg_i18n = $context->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $node_id));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $this->log("[ERROR] " . $error['error']);
         return $error;
     }
     // logical volume to clone
     $lv = $arguments['logicalvolume'];
     $vg = $options['volumegroup'];
     // check if a logical volume exists
     if (!($etva_lv = $etva_node->retrieveLogicalvolumeByAny($lv, $vg))) {
         $msg = Etva::getLogMessage(array('name' => $lv), EtvaLogicalvolumePeer::_ERR_NOTFOUND_);
         $msg_i18n = $context->getI18N()->__(EtvaLogicalvolumePeer::_ERR_NOTFOUND_, array('%name%' => $lv));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $this->log("[ERROR] " . $error['error']);
         return $error;
     }
     // original logical volume
     $original_lv = $arguments['original'];
     $original_vg = $options['original-volumegroup'];
     // if cannot find logical volume
     if (!($etva_original_lv = $etva_node->retrieveLogicalvolumeByAny($original_lv, $original_vg))) {
         $msg = Etva::getLogMessage(array('name' => $original_lv), EtvaLogicalvolumePeer::_ERR_NOTFOUND_);
         $msg_i18n = $context->getI18N()->__(EtvaLogicalvolumePeer::_ERR_NOTFOUND_, array('%name%' => $original_lv));
         $error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
         $this->log("[ERROR] " . $error['error']);
         return $error;
     }
     // prepare soap info....
     $lv_va = new EtvaLogicalvolume_VA($etva_lv);
     $response = $lv_va->send_clone($etva_node, $etva_original_lv);
     if (!$response['success']) {
         $this->log("[ERROR] " . $response['error']);
     } else {
         $this->log("[INFO] " . $response['response']);
     }
     return $response;
 }
 protected function execute($arguments = array(), $options = array())
 {
     $context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
     parent::execute($arguments, $options);
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $connection = $databaseManager->getDatabase($options['connection'])->getConnection();
     // add your code here
     // Update nodes logical volumes
     $this->log('[INFO] Update nodes logical volumes info...' . "\n");
     $list_nodes = EtvaNodeQuery::create()->find();
     foreach ($list_nodes as $node) {
         $lv_va = new EtvaLogicalvolume_VA();
         $lv_errors = $lv_va->send_update($node, false, false);
     }
     // Check servers with snapshots
     $this->log('[INFO] Checking Servers with snapshots...' . "\n");
     $errors_arr = array();
     $list_servers = EtvaServerQuery::create()->find();
     foreach ($list_servers as $server) {
         $server_lvs = $server->getEtvaLogicalvolumes();
         foreach ($server_lvs as $lv) {
             if ($lv->getPerUsageSnapshots() >= EtvaLogicalvolume::PER_USAGESNAPSHOTS_CRITICAL) {
                 $this->log('[ERROR] Logical volume \'' . $lv->getLvdevice() . '\' of server \'' . $server->getName() . '\' is in CRITICAL with ' . sprintf('%g%%', round($lv->getPerUsageSnapshots() * 100)) . ' of usage by snapshots ');
                 array_push($errors_arr, array('server_name' => $server->getName(), 'lvdevice' => $lv->getLvdevice(), 'per_usage_snapshots' => $lv->getPerUsageSnapshots(), 'status_id' => EtvaServer::USAGESNAPSHOTS_STATUS_CRITICAL, 'status_str' => EtvaServer::USAGESNAPSHOTS_STATUS_CRITICAL_STR));
             } else {
                 if ($lv->getPerUsageSnapshots() >= EtvaLogicalvolume::PER_USAGESNAPSHOTS_WARNING) {
                     $this->log('[ERROR] Logical volume \'' . $lv->getLvdevice() . '\' of server \'' . $server->getName() . '\' is in WARNING with ' . sprintf('%g%%', round($lv->getPerUsageSnapshots() * 100)) . ' of usage by snapshots ');
                     array_push($errors_arr, array('server_name' => $server->getName(), 'lvdevice' => $lv->getLvdevice(), 'per_usage_snapshots' => $lv->getPerUsageSnapshots(), 'status_id' => EtvaServer::USAGESNAPSHOTS_STATUS_WARNING, 'status_str' => EtvaServer::USAGESNAPSHOTS_STATUS_WARNING_STR));
                 } else {
                     $this->log('[INFO] Logical volume \'' . $lv->getLvdevice() . '\' of server \'' . $server->getName() . '\' is in NORMAL with ' . sprintf('%g%%', round($lv->getPerUsageSnapshots() * 100)) . ' of usage by snapshots ');
                     #array_push($errors_arr, array('server_name'=>$server->getName(),'lvdevice'=>$lv->getLvdevice(),'per_usage_snapshots'=>$lv->getPerUsageSnapshots(),'status_id'=>EtvaServer::USAGESNAPSHOTS_STATUS_CRITICAL,'status_str'=>EtvaServer::USAGESNAPSHOTS_STATUS_CRITICAL_STR));
                 }
             }
         }
     }
     if (!empty($errors_arr)) {
         $message = "";
         foreach ($errors_arr as $err) {
             if ($server_name != $err['server_name']) {
                 $server_name = $err['server_name'];
                 $message = $message . "Server '{$server_name}':\r\n";
             }
             $message = $message . " Logical volume '" . $err['lvdevice'] . "' in state '" . $err['status_str'] . "' with " . sprintf('%g%%', round($err['per_usage_snapshots'] * 100)) . " usage of snapshots.\r\n";
         }
         $from = EtvaSettingPeer::retrieveByPK(EtvaSettingPeer::_ALERT_EMAIL_FROM_)->getValue();
         if (!$from) {
             $from = '*****@*****.**';
         }
         $to = EtvaSettingPeer::retrieveByPK(EtvaSettingPeer::_ALERT_EMAIL_)->getValue();
         if (!$to) {
             $to = '*****@*****.**';
         }
         $subject_prefix = EtvaSettingPeer::retrieveByPK(EtvaSettingPeer::_ALERT_SUBJECT_PREFIX_)->getValue();
         if (!$subject_prefix) {
             $subject_prefix = 'Nuxis -';
         }
         #$to = "*****@*****.**";
         $subject = $subject_prefix . " " . "Servers snapshots usage report";
         $headers = "From: {$from}\r\n";
         mail($to, $subject, $message, $headers);
         $this->log("[INFO] Email with report sent to {$to}");
     } else {
         $this->log("[INFO] No errors to report");
     }
 }