public function send_reload(EtvaNode $etva_node) { $method = self::POOL_RELOAD; $etva_pool = $this->etva_pool; $params = $etva_pool->_VA(); $response = $etva_node->soapSend($method, $params); $result = $this->processResponse($etva_node, $response, $method, $params); return $result; }
public function soapSend($method, $params = null, EtvaNode $except_node = null, $forceRequest = false, $rcv_timeout = 0, $all = false) { $c = new Criteria(); if ($except_node) { $c->add(EtvaNodePeer::UUID, $except_node->getUuid(), Criteria::ALT_NOT_EQUAL); } if (!$all) { $c->add(EtvaNodePeer::INITIALIZE, EtvaNode::INITIALIZE_OK, Criteria::EQUAL); } $c->add(EtvaNodePeer::CLUSTER_ID, $this->getId()); $all_nodes = EtvaNodePeer::doSelect($c); $responses = array(); foreach ($all_nodes as $node) { $responses[$node->getId()] = $node->soapSend($method, $params, $forceRequest, $rcv_timeout); } return $responses; }
private static function ElectNode(EtvaNode $etva_node) { $cluster_id = $etva_node->getClusterId(); $etva_cluster = EtvaClusterPeer::retrieveByPK($cluster_id); return EtvaNode::getFirstActiveNode($etva_cluster); }
private function check_pvs(EtvaNode $etva_node) { $node_response = $etva_node->soapSend('getpvs_arr', array('force' => 1)); if (!$node_response['success']) { $errors = $node_response['error']; Etva::getLogMessage(array('info' => ''), EtvaPhysicalvolumePeer::_ERR_INCONSISTENT_); //$etva_node->setErrorMessage(EtvaPhysicalvolume_VA::LVINIT); $message = $this->getContext()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_SOAPUPDATE_, array('%info%' => $node_response['info'])); sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR))); $response = array('success' => false, 'error' => $message, 'agent' => $etva_node->getName()); $return = $this->setJsonError($response); return $this->renderText($return); } //verify if cluster has any logical volume that belongs to another cluster... $cluster_id = $etva_node->getClusterId(); $my_pvs = $node_response['response']; $my_pvs = (array) $my_pvs; foreach ($my_pvs as $my_pv) { $pv_info = (array) $my_pv; if ($pv_info['type'] == EtvaPhysicalvolume::STORAGE_TYPE_LOCAL_MAP) { continue; } $c_uuid = new criteria(); $c_uuid->add(EtvaPhysicalvolumePeer::UUID, $pv_info['uuid']); $c_uuid->addAnd(EtvaPhysicalvolumePeer::CLUSTER_ID, $cluster_id, Criteria::NOT_EQUAL); $e_pv = EtvaPhysicalvolumePeer::doSelectOne($c_uuid); if ($e_pv) { $c_c = new Criteria(); $c_c->add(EtvaClusterPeer::ID, $e_pv->getClusterId()); $etva_cluster = EtvaClusterPeer::doSelectOne($c_c); $msg_i18n = $this->getContext()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_INIT_OTHER_CLUSTER_, array('%name%' => $etva_cluster->getName())); $response = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n); $return = $this->setJsonError($response); return $this->renderText($return); } } }
public function getVolumegroupInfo(EtvaNode $etva_node, $bulk_responses) { foreach ($bulk_responses as $node_id => $node_response) { if ($node_id == $etva_node->getId()) { if ($node_response['success']) { $vgs = (array) $node_response['response']; $found = false; foreach ($vgs as $vgInfo) { $vg_info = (array) $vgInfo; $vg_type = $vg_info[EtvaVolumegroup::STORAGE_TYPE_MAP]; $vg_name = $vg_info[EtvaVolumegroup::VG_MAP]; if ($vg_type == $this->etva_vg->getStorageType()) { if ($vg_type == EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP) { if ($vg_name == $this->etva_vg->getVg()) { $found = true; } } else { if (isset($vg_info[EtvaVolumegroup::UUID_MAP])) { $vg_uuid = $vg_info[EtvaVolumegroup::UUID_MAP]; if ($vg_uuid == $this->etva_vg->getUuid()) { $found = true; } } else { if ($vg_name == $this->etva_vg->getVg()) { $found = true; } } } } if ($found) { return $vg_info; } } } } } return null; }
public function send_expand(EtvaNode $etva_node) { $msg_ok_type = EtvaPhysicalvolumePeer::_OK_EXPAND_; $msg_err_type = EtvaPhysicalvolumePeer::_ERR_EXPAND_; $method = self::DEVICERESIZE; $etva_pv_uuid = $this->etva_pv->getUuid(); $etva_pv_type = $this->etva_pv->getStorageType(); $etva_pv_device = $this->etva_pv->getDevice(); $params = array('device' => $etva_pv_device, 'uuid' => $etva_pv_uuid); // check if physical volume is shared $shared = $this->etva_pv->getStorageType() != EtvaPhysicalvolume::STORAGE_TYPE_LOCAL_MAP; $etva_cluster = $etva_node->getEtvaCluster(); $bulk_responses = array(); if ($shared) { // call resize at all nodes $bulk_responses = $etva_cluster->soapSend($method, $params); } else { $node_id = $etva_node->getId(); // call resize $bulk_responses[$node_id] = $etva_node->soapSend($method, $params); } // sync physical volumes size $errors = $this->send_update($etva_node); if (!empty($errors)) { $result = array('success' => false, 'errors' => $errors); $msg_i18n = Etva::makeNotifyLogMessage($etva_node->getName(), $msg_err_type, array('name' => $this->etva_pv->getName(), 'info' => '')); $result['error'] = $msg_i18n; return $result; } else { //notify system log $message = Etva::getLogMessage(array('name' => $this->etva_pv->getName()), $msg_ok_type); $msg_i18n = sfContext::getInstance()->getI18N()->__($msg_ok_type, array('%name%' => $this->etva_pv->getName())); 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 $result; } }
public function putMaintenance(EtvaNode $etva_sparenode = null, $off = false) { if (!$etva_sparenode || $etva_sparenode->isNodeFree() && $etva_sparenode->getState() == EtvaNode::NODE_ACTIVE) { // if has sparenode, migrate all servers only if node is free and is active // else do right distribution of servers for each node $this->migrateAllServers($etva_sparenode, $off); } // put node in maintenance $this->etva_node->setState(EtvaNode::NODE_MAINTENANCE); $this->etva_node->save(); }
public function fix_consistency(EtvaNode $etva_node) { $ok = 1; $etva_lv = $this->etva_lv; $lv = $etva_lv->getLv(); $etva_vg = $etva_lv->getEtvaVolumegroup(); /* $vgInfo = $returned_object[EtvaLogicalvolume::VOLUMEGROUP_MAP]; $vg_info = (array) $vgInfo;*/ // removes logical volume $insert_id = $etva_lv->getId(); $uuid = $etva_lv->getUuid(); $lv_type = $etva_lv->getStorageType(); $etva_lv->delete(); // remove snapshots $snapshotsObject = $returned_object['SNAPSHOTS']; $snapshotsArray = (array) $snapshotsObject; foreach ($snapshotsArray as $slv_obj) { $slv = (array) $slv_obj; if ($etva_slv = $etva_node->retrieveLogicalvolumeByLv($slv[EtvaLogicalvolume::LV_MAP])) { $etva_slv->delete(); } } /*$etva_vg->initData($vg_info); $etva_vg->save();*/ if ($lv_type != EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP) { /* * need syncronize device table */ $this->sync_device_table_afterremove($etva_node); /* * if storage type not local send update to nodes... */ $bulk_update = $this->send_update($etva_node); if (!empty($bulk_update)) { $errors = $this->get_missing_lv_devices(); $msg_i18n = $errors ? $errors['message'] : sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_SHARED_INCONSISTENT_, array('%info%' => ' processResponse')); $response = array('success' => false, 'agent' => $etva_node->getName(), 'info' => $msg_i18n, 'msg_i18n' => $msg_i18n); $ok = 0; } } // Update volume groups $vg_va = new EtvaVolumegroup_VA($etva_vg); $bulk_update = $vg_va->send_update($etva_node); // TODO call fix consistency volume group if ($ok == 0) { $result = $response; $errors = $this->get_missing_lv_devices(); if ($errors) { $message = $errors['message']; sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR))); return array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $message, 'action' => 'reload', 'info' => $message); } else { $message = Etva::getLogMessage(array('name' => $lv, 'info' => $response['info']), $msg_err_type); $msg_i18n = sfContext::getInstance()->getI18N()->__($msg_err_type, array('%name%' => $lv, '%info%' => $response['info'])); $result['error'] = $msg_i18n; sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR))); return $result; } } else { //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' => $response['agent'], 'response' => $msg_i18n, 'insert_id' => $insert_id, 'uuid' => $uuid); return $result; } }
public function remove_snapshot(EtvaNode $etva_node, $snapshot) { return $etva_node->soapSend(self::SERVER_REMOVE_SNAPSHOT, array('uuid' => $this->etva_server->getUuid(), 'name' => $this->etva_server->getName(), 'snapshot' => $snapshot)); }
public function canAssignTo(EtvaNode $etva_node) { $nodes_toassign = $this->listNodesAssignTo(); foreach ($nodes_toassign as $i => $node) { if ($etva_node->getId() == $node->getId()) { return true; } } return false; }