public function getSharedVgs() { /* * * get shared vgs of defined cluster. */ $criteria = new Criteria(); $criteria->add(EtvaClusterPeer::ID, $this->getId()); $criteria->addJoin(EtvaVolumegroupPeer::CLUSTER_ID, EtvaClusterPeer::ID); $criteria->add(EtvaVolumegroupPeer::STORAGE_TYPE, EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL); $etva_shared_vgs = EtvaVolumegroupPeer::doSelect($criteria); return $etva_shared_vgs; }
public function clearStorage() { $c = new Criteria(); $c->add(EtvaNodeLogicalvolumePeer::NODE_ID, $this->getId()); EtvaLogicalvolumePeer::doDelete($c); $c = new Criteria(); $c->add(EtvaNodeVolumegroupPeer::NODE_ID, $this->getId()); EtvaVolumegroupPeer::doDelete($c); $c = new Criteria(); $c->add(EtvaNodePhysicalvolumePeer::NODE_ID, $this->getId()); EtvaPhysicalvolumePeer::doDelete($c); }
public function setVolumegroup($v) { if (!($etva_cluster = $this->getEtvaCluster())) { return; } $criteria = new Criteria(); $criteria->add(EtvaVolumegroupPeer::CLUSTER_ID, $etva_cluster->getId()); $volgroup_array = (array) $v; $vg_uuid = $volgroup_array['uuid']; $etva_volgroup = $this->getEtvaVolumegroup(); if (!$etva_volgroup) { $etva_volgroup = EtvaVolumegroupPeer::retrieveByUUID($vg_uuid, $criteria); } $etva_volgroup->initData($volgroup_array); if ($etva_volgroup) { $this->volumegroup = $etva_volgroup; } return $this; }
public static function getOrElectNodeFromArray($arguments) { // get parameters $nid = isset($arguments['node']) ? $arguments['node'] : null; $cid = isset($arguments['cluster']) ? $arguments['cluster'] : null; $level = isset($arguments['level']) ? $arguments['level'] : null; $vg = isset($arguments['volumegroup']) ? $arguments['volumegroup'] : null; $dev = isset($arguments['device']) ? $arguments['device'] : null; $lv = isset($arguments['logicalvolume']) ? $arguments['logicalvolume'] : null; // check level - back compatibility if (!$level) { $level = 'node'; } if ($level == 'cluster') { $etva_cluster = EtvaClusterPeer::retrieveByPK($cid); return EtvaNode::getFirstActiveNode($etva_cluster); } elseif ($level == 'node') { $etva_node = EtvaNodePeer::retrieveByPK($nid); if ($lv) { $c = new Criteria(); $c->add(EtvaLogicalvolumePeer::STORAGE_TYPE, EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL); $etva_lv = EtvaLogicalvolumePeer::retrieveByLv($lv, $c); return $etva_lv ? EtvaNodePeer::ElectNode($etva_node) : $etva_node; } elseif ($dev) { $c = new Criteria(); $c->add(EtvaPhysicalvolumePeer::STORAGE_TYPE, EtvaPhysicalvolume::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL); $etva_pv = EtvaPhysicalvolumePeer::retrieveByDevice($dev, $c); return $etva_pv ? EtvaNodePeer::ElectNode($etva_node) : $etva_node; } elseif ($vg) { $c = new Criteria(); $c->add(EtvaVolumeGroupPeer::STORAGE_TYPE, EtvaVolumeGroup::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL); $etva_vg = EtvaVolumegroupPeer::retrieveByVg($vg, $c); return $etva_vg ? EtvaNodePeer::ElectNode($etva_node) : $etva_node; } else { return $etva_node; } } }
public function check_consistency(EtvaNode $etva_node, $sync_node_vgs) { $errors = array(); $etva_node->getId(); $etva_cluster = $etva_node->getEtvaCluster(); // get node database VGs $node_vgs = $etva_node->getEtvaNodeVolumegroups(); // get shared database VGs $shared_vgs = $etva_cluster->getSharedVgs(); $node_inconsistent = 0; foreach ($node_vgs as $rvg) { $vg = $rvg->getEtvaVolumegroup(); $error = array(); $uuid = $vg->getUuid(); $vgname = $vg->getVg(); // init $inconsistent = 0; // look at volume groups list $found_lvm = 0; foreach ($sync_node_vgs as $hvg) { $arr_hvg = (array) $hvg; if ($arr_hvg[EtvaVolumegroup::STORAGE_TYPE_MAP] == $vg->getStorageType()) { if (isset($arr_hvg[EtvaVolumegroup::UUID_MAP])) { if ($arr_hvg[EtvaVolumegroup::UUID_MAP] == $uuid) { $found_lvm = 1; } } else { if ($arr_hvg[EtvaVolumegroup::VG_MAP] == $vgname) { $found_lvm = 1; } } } } $inconsistent = $inconsistent || !$found_lvm; if (!$found_lvm) { $error['not_found_lvm'] = 1; } $found_shared_lvm = 0; $inconsistent_shared_vgs = 0; foreach ($shared_vgs as $s_vg) { $s_uuid = $s_vg->getUuid(); if ($s_uuid == $uuid) { if ($s_vg->getStorageType() != $vg->getStorageType()) { $inconsistent_shared_vgs = 1; } else { $found_shared_lvm = 1; } } else { if ($s_vg->getStorageType() == $vg->getStorageType()) { if ($arr_hvg[EtvaVolumegroup::VG_MAP] == $vgname) { $found_shared_lvm = 1; } } } } if ($vg->getStorageType() != EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP) { $inconsistent = $inconsistent || !$found_shared_lvm; if (!$found_shared_lvm) { $error['not_found_shared_lvm'] = 1; } } $inconsistent = $inconsistent || $inconsistent_shared_vgs; if ($inconsistent_shared_vgs) { $error['diff_storage_type'] = 1; } // update data-base $etva_volumegroup = EtvaVolumegroupPeer::retrieveByNodeTypeUUIDVg($etva_node->getId(), $vg->getStorageType(), $vg->getUuid(), $vg->getVg()); if ($etva_volumegroup) { $etva_volumegroup->setInconsistent($inconsistent); $etva_volumegroup->save(); } $etva_node_volumegroup = EtvaNodeVolumegroupPeer::retrieveByPK($etva_node->getId(), $vg->getId()); if ($etva_node_volumegroup) { $etva_node_volumegroup->setInconsistent($inconsistent); $etva_node_volumegroup->save(); } if ($inconsistent) { $message = sfContext::getInstance()->getI18N()->__(EtvaVolumegroupPeer::_ERR_INCONSISTENT_, array('%info%' => sprintf('volume group "%s" with uuid "%s"', $vg->getVg(), $vg->getUuid()))); if ($error['not_found_shared_lvm'] || $error['diff_storage_type']) { $message = sfContext::getInstance()->getI18N()->__(EtvaVolumegroupPeer::_ERR_SHARED_INCONSISTENT_, array('%info%' => sprintf('volume group "%s" with uuid "%s"', $vg->getVg(), $vg->getUuid()))); } sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR))); $error['node'] = array('name' => $etva_node->getName(), 'id' => $etva_node->getId(), 'uuid' => $etva_node->getUuid()); $error['volumegroup'] = $vg->getVg(); $error['uuid'] = $vg->getUuid(); $error['message'] = $message; } if (!empty($error)) { $errors[] = $error; } $node_inconsistent = $node_inconsistent || $inconsistent; } // check consistency for shared Volume groups foreach ($shared_vgs as $vg) { $error = array(); $uuid = $vg->getUuid(); $vgname = $vg->getVg(); // init $inconsistent = 0; // look at physical volumes list $found_lvm = 0; foreach ($sync_node_vgs as $hvg) { $arr_hvg = (array) $hvg; if ($arr_hvg[EtvaVolumegroup::STORAGE_TYPE_MAP] == $vg->getStorageType()) { if (isset($arr_hvg[EtvaVolumegroup::UUID_MAP])) { if ($arr_hvg[EtvaVolumegroup::UUID_MAP] == $uuid) { $found_lvm = 1; } } else { if ($arr_hvg[EtvaVolumegroup::VG_MAP] == $vgname) { $found_lvm = 1; } } } } $inconsistent = $inconsistent || !$found_lvm; if (!$found_lvm) { $error['not_found_lvm'] = 1; } // update data-base $etva_volumegroup = EtvaVolumegroupPeer::retrieveByNodeTypeUUIDVg($etva_node->getId(), $vg->getStorageType(), $vg->getUuid(), $vg->getVg()); if ($etva_volumegroup) { $etva_volumegroup->setInconsistent($inconsistent); $etva_volumegroup->save(); } $etva_node_volumegroup = EtvaNodeVolumegroupPeer::retrieveByPK($etva_node->getId(), $vg->getId()); if ($etva_node_volumegroup) { $etva_node_volumegroup->setInconsistent($inconsistent); $etva_node_volumegroup->save(); } if ($inconsistent) { $message = sfContext::getInstance()->getI18N()->__(EtvaVolumegroupPeer::_ERR_SHARED_INCONSISTENT_, array('%info%' => sprintf('volumegroup "%s" with uuid "%s"', $vg->getVg(), $vg->getUuid()))); sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR))); $error['node'] = array('name' => $etva_node->getName(), 'id' => $etva_node->getId(), 'uuid' => $etva_node->getUuid()); $error['volumegroup'] = $vg->getVg(); $error['uuid'] = $vg->getUuid(); $error['message'] = $message; } if (!empty($error)) { $errors[] = $error; } $node_inconsistent = $node_inconsistent || $inconsistent; } $return = array(); if ($node_inconsistent) { $etva_node->setErrorMessage(self::VGINIT); $return = array('success' => false, 'errors' => $errors); } else { $etva_node->clearErrorMessage(self::VGINIT); $return = array('success' => true); } return $return; }
private function check_vgs(EtvaNode $etva_node) { $node_response = $etva_node->soapSend('getvgs_arr', array('force' => 1)); if (!$node_response['success']) { $errors = $node_response['error']; Etva::getLogMessage(array('info' => ''), EtvaVolumegroupPeer::_ERR_INCONSISTENT_); $etva_node->setErrorMessage(EtvaVolumegroup_VA::LVINIT); $message = Etva::getLogMessage(array('info' => $node_response['info']), EtvaVolimegroupPeer::_ERR_SOAPUPDATE_); sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR))); $response = array('success' => false, 'error' => $errors); $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_vgs = $node_response['response']; $my_vgs = (array) $my_vgs; foreach ($my_vgs as $my_vg) { $vg_info = (array) $my_vg; //ignore in case of a local device if ($vg_info['type'] == EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP) { continue; } $c_uuid = new criteria(); $c_uuid->add(EtvaVolumegroupPeer::UUID, $vg_info['uuid']); $c_uuid->addAnd(EtvaVolumegroupPeer::CLUSTER_ID, $cluster_id, Criteria::NOT_EQUAL); $e_vg = EtvaVolumegroupPeer::doSelectOne($c_uuid); if ($e_vg) { $c_c = new Criteria(); $c_c->add(EtvaClusterPeer::ID, $e_vg->getClusterId()); $etva_cluster = EtvaClusterPeer::doSelectOne($c_c); $msg_i18n = $this->getContext()->getI18N()->__(EtvaVolumegroupPeer::_ERR_INIT_OTHER_CLUSTER_, array('%name%' => $etva_cluster->getName())); // $res = "Volume group exists on cluster ".$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 executeJsonListFree(sfWebRequest $request) { $cid = $request->getParameter('cid'); $level = $request->getParameter('level'); $nid = $request->getParameter('nid'); $gtMB = $request->getParameter('gtMB'); if (!$level) { //back compatibility $level = 'node'; } $elements = array(); $criteria = new Criteria(); if ($level == 'node') { $criteria->add(EtvaNodeVolumegroupPeer::NODE_ID, $nid); $criteria->addJoin(EtvaNodeVolumegroupPeer::VOLUMEGROUP_ID, EtvaVolumegroupPeer::ID); } elseif ($level == 'cluster') { $criteria->add(EtvaVolumegroupPeer::CLUSTER_ID, $cid); $criteria->addAnd(EtvaVolumeGroupPeer::STORAGE_TYPE, EtvaVolumeGroup::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL); } else { return; } $criteria->add(EtvaVolumegroupPeer::FREESIZE, 0, Criteria::NOT_EQUAL); if ($gtMB) { $criteria->addAnd(EtvaVolumegroupPeer::FREESIZE, intval($gtMB) * 1024 * 1024, Criteria::GREATER_THAN); } $nodisk = $request->getParameter('nodisk'); if ($nodisk) { $criteria->add(EtvaVolumegroupPeer::VG, sfConfig::get('app_volgroup_disk_flag'), Criteria::NOT_EQUAL); } $etva_vgs = EtvaVolumegroupPeer::doSelect($criteria); if (!$etva_vgs && !$gtMB) { $msg_i18n = $this->getContext()->getI18N()->__(EtvaVolumegroupPeer::_NOTAVAILABLE_); $info = array('success' => false, 'error' => $msg_i18n); $error = $this->setJsonError($info); //,204); // 204 => no content return $this->renderText($error); } foreach ($etva_vgs as $elem) { $id = $elem->getId(); $size = $elem->getFreesize(); $txt = $elem->getVg(); $elements[] = array('id' => $id, 'name' => $txt, 'value' => $size); } $result = array('total' => count($elements), 'data' => $elements); $return = json_encode($result); $this->getResponse()->setHttpHeader('Content-type', 'application/json'); return $this->renderText($return); }
public function initialize(EtvaNode $etva_node, $lvs, $dtable, $bulk_dtable) { $etva_cluster = $etva_node->getEtvaCluster(); $logical_names = array(); $errors = array(); /* * check lv consistency */ $check_res = $this->check_consistency($etva_node, $lvs, $dtable, $bulk_dtable); if (!$check_res['success']) { $errors = $check_res['errors']; $inconsistent_message = sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => '')); $etva_node->setErrorMessage(self::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))); // dont stop process //return array('success'=>false,'error'=>$errors); } /* * check shared lvs consistency */ /*$consist = $this->check_shared_consistency($etva_node,$lvs); $consist_dtable = $this->check_shared_devicetable_consistency($etva_node,$dtable,$bulk_dtable); if(!$consist || !$consist_dtable){ $errors = $this->get_missing_lv_devices($etva_node); $inconsistent_message = $errors ? $errors['message'] : sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_,array('%info%'=>'initialize')); $etva_node->setErrorMessage(self::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))); // dont stop process //return array('success'=>false,'error'=>$errors); }*/ foreach ($lvs as $lvInfo) { if (!empty($lvInfo)) { $lv_info = (array) $lvInfo; // set mounted 0 when not mounted if (!isset($lv_info[EtvaLogicalvolume::MOUNTED_MAP])) { $lv_info[EtvaLogicalvolume::MOUNTED_MAP] = 0; } //error_log("device " . $lv_info[EtvaLogicalvolume::LVDEVICE_MAP] . " EtvaLogicalvolume::MOUNTED_MAP " . $lv_info[EtvaLogicalvolume::MOUNTED_MAP]); $lv_dev = $lv_info[EtvaLogicalvolume::LVDEVICE_MAP]; $lv_type = $lv_info[EtvaLogicalvolume::STORAGE_TYPE_MAP]; $lv_uuid = isset($lv_info[EtvaLogicalvolume::UUID_MAP]) ? $lv_info[EtvaLogicalvolume::UUID_MAP] : ''; // vg info $vg_info = (array) $lv_info[EtvaLogicalvolume::VOLUMEGROUP_MAP]; $vg_name = $vg_info[EtvaVolumegroup::VG_MAP]; $vg_type = $vg_info[EtvaVolumegroup::STORAGE_TYPE_MAP]; $vg_uuid = isset($vg_info[EtvaVolumegroup::UUID_MAP]) ? $vg_info[EtvaVolumegroup::UUID_MAP] : ''; //get volume group based on node, type, uuid and vg $etva_volgroup = EtvaVolumegroupPeer::retrieveByNodeTypeUUIDVg($etva_node->getId(), $vg_type, $vg_uuid, $vg_name); if ($etva_volgroup) { if ($lv_type == EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP) { $etva_logicalvol = EtvaLogicalvolumePeer::retrieveByNodeTypeLvDevice($etva_node->getId(), $lv_type, $lv_dev); } else { $etva_logicalvol = EtvaLogicalvolumePeer::retrieveByUUID($lv_uuid); } if (!$etva_logicalvol) { // no lv in db...so create new one $etva_node_logicalvol = new EtvaNodeLogicalvolume(); $etva_logicalvol = new EtvaLogicalvolume(); } else { //if lv already in DB we need to make sure if already exists association with node. if not create new one $etva_node_logicalvol = EtvaNodeLogicalvolumePeer::retrieveByPK($etva_node->getId(), $etva_logicalvol->getId()); if (!$etva_node_logicalvol) { $etva_node_logicalvol = new EtvaNodeLogicalvolume(); } } $etva_logicalvol->initData($lv_info); $etva_logicalvol->setEtvaVolumegroup($etva_volgroup); $etva_logicalvol->setEtvaCluster($etva_cluster); $etva_logicalvol->save(); $etva_node_logicalvol->setEtvaLogicalvolume($etva_logicalvol); $etva_node_logicalvol->setEtvaNode($etva_node); $etva_node_logicalvol->save(); $logical_names[] = $etva_logicalvol->getLv(); } } } if (!empty($errors)) { // if have some errors, return it return array('success' => false, 'error' => $errors); } else { /* * check if is an appliance restore operation... */ $apli = new Appliance(); $action = $apli->getStage(Appliance::RESTORE_STAGE); if ($action) { $apli->setStage(Appliance::RESTORE_STAGE, Appliance::VA_UPDATE_LVS); } $etva_node->clearErrorMessage(self::LVINIT); $message = Etva::getLogMessage(array('info' => implode(', ', $logical_names)), EtvaLogicalvolumePeer::_OK_SOAPUPDATE_); sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message))); return array('success' => true, 'response' => $logical_names); } }