public function preDelete(PropelPDO $con = null) { /* * delete lvs that are not shared....numVgs=1 only * */ $criteria = new Criteria(); $criteria->add(EtvaLogicalvolumePeer::CLUSTER_ID, $this->getClusterId()); $criteria->addGroupByColumn(EtvaNodeLogicalvolumePeer::LOGICALVOLUME_ID); $criteria->addAsColumn('numLvs', 'COUNT(' . EtvaNodeLogicalvolumePeer::LOGICALVOLUME_ID . ')'); $criteria->addHaving($criteria->getNewCriterion(EtvaNodeLogicalvolumePeer::LOGICALVOLUME_ID, 'numLvs=1', Criteria::CUSTOM)); $records = EtvaNodeLogicalvolumePeer::doSelectJoinEtvaLogicalvolume($criteria); foreach ($records as $record) { $etva_lv = $record->getEtvaLogicalvolume(); if ($record->getNodeId() == $this->getId()) { $etva_lv->delete(); } } /* * delete vgs that are not shared....numVgs=1 only * */ $criteria = new Criteria(); $criteria->add(EtvaVolumegroupPeer::CLUSTER_ID, $this->getClusterId()); $criteria->addGroupByColumn(EtvaNodeVolumegroupPeer::VOLUMEGROUP_ID); $criteria->addAsColumn('numVgs', 'COUNT(' . EtvaNodeVolumegroupPeer::VOLUMEGROUP_ID . ')'); $criteria->addHaving($criteria->getNewCriterion(EtvaNodeVolumegroupPeer::VOLUMEGROUP_ID, 'numVgs=1', Criteria::CUSTOM)); $records = EtvaNodeVolumegroupPeer::doSelectJoinEtvaVolumegroup($criteria); foreach ($records as $record) { $etva_vg = $record->getEtvaVolumegroup(); if ($record->getNodeId() == $this->getId()) { $etva_vg->delete(); } } /* * delete pvs that are not shared....numVgs=1 only * */ $criteria = new Criteria(); $criteria->add(EtvaPhysicalvolumePeer::CLUSTER_ID, $this->getClusterId()); $criteria->addGroupByColumn(EtvaNodePhysicalvolumePeer::PHYSICALVOLUME_ID); $criteria->addAsColumn('numPvs', 'COUNT(' . EtvaNodePhysicalvolumePeer::PHYSICALVOLUME_ID . ')'); $criteria->addHaving($criteria->getNewCriterion(EtvaNodePhysicalvolumePeer::PHYSICALVOLUME_ID, 'numPvs=1', Criteria::CUSTOM)); $records = EtvaNodePhysicalvolumePeer::doSelectJoinEtvaPhysicalvolume($criteria); foreach ($records as $record) { $etva_pv = $record->getEtvaPhysicalvolume(); if ($record->getNodeId() == $this->getId()) { $etva_pv->delete(); } } // delete rra node dir and cpu load rrd $this->deleteRRAFiles(); return true; }
public function check_consistency(EtvaNode $etva_node, $sync_node_pvs) { $errors = array(); $etva_node->getId(); $etva_cluster = $etva_node->getEtvaCluster(); // get node database PVs //$node_pvs = $etva_node->getEtvaPhysicalvolumes(); $node_pvs = $etva_node->getEtvaNodePhysicalvolumes(); // get shared database PVs $shared_pvs = $etva_cluster->getSharedPvs(); $node_inconsistent = 0; foreach ($node_pvs as $rpv) { $pv = $rpv->getEtvaPhysicalvolume(); $error = array(); $uuid = $pv->getUuid(); $device = $pv->getDevice(); // init $inconsistent = 0; // look at physical volumes list $found_lvm = 0; foreach ($sync_node_pvs as $hpv) { $arr_hpv = (array) $hpv; if ($arr_hpv[EtvaPhysicalvolume::STORAGE_TYPE_MAP] == $pv->getStorageType()) { if (isset($arr_hpv[EtvaPhysicalvolume::UUID_MAP])) { if ($arr_hpv[EtvaPhysicalvolume::UUID_MAP] == $uuid) { $found_lvm = 1; } } else { if ($arr_hpv[EtvaPhysicalvolume::DEVICE_MAP] == $device) { $found_lvm = 1; } } } } $inconsistent = $inconsistent || !$found_lvm; if (!$found_lvm) { $error['not_found_lvm'] = 1; } /* TODO * check when have multipath */ $found_shared_lvm = 0; $inconsistent_shared_pvs = 0; foreach ($shared_pvs as $s_pv) { $s_uuid = $s_pv->getUuid(); $s_device = $s_pv->getDevice(); if ($s_uuid == $uuid) { if ($s_pv->getStorageType() != $pv->getStorageType()) { $inconsistent_shared_pvs = 1; } else { $found_shared_lvm = 1; } } else { if ($s_pv->getStorageType() == $pv->getStorageType()) { if ($arr_hpv[EtvaPhysicalvolume::DEVICE_MAP] == $device) { $found_shared_lvm = 1; } } } } if ($pv->getStorageType() != EtvaPhysicalvolume::STORAGE_TYPE_LOCAL_MAP) { $inconsistent = $inconsistent || !$found_shared_lvm; if (!$found_shared_lvm) { $error['not_found_shared_lvm'] = 1; } } $inconsistent = $inconsistent || $inconsistent_shared_pvs; if ($inconsistent_shared_pvs) { $error['diff_storage_type'] = 1; } // update data-base $etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByNodeTypeUUIDDevice($etva_node->getId(), $pv->getStorageType(), $pv->getUuid(), $pv->getDevice()); if ($etva_physicalvol) { $etva_physicalvol->setInconsistent($inconsistent); $etva_physicalvol->save(); } $etva_node_physicalvol = EtvaNodePhysicalvolumePeer::retrieveByPK($etva_node->getId(), $pv->getId()); if ($etva_node_physicalvol) { $etva_node_physicalvol->setInconsistent($inconsistent); $etva_node_physicalvol->save(); } if ($inconsistent) { $message = sfContext::getInstance()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => sprintf('device "%s" with uuid "%s"', $pv->getDevice(), $pv->getUuid()))); if ($error['not_found_shared_lvm'] || $error['diff_storage_type']) { $message = sfContext::getInstance()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_SHARED_INCONSISTENT_, array('%info%' => sprintf('device "%s" with uuid "%s"', $pv->getDevice(), $pv->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['device'] = $pv->getDevice(); $error['device_id'] = $pv->getId(); $error['uuid'] = $pv->getUuid(); $error['message'] = $message; } if (!empty($error)) { $errors[] = $error; } $node_inconsistent = $node_inconsistent || $inconsistent; } // check consistency for shared PVs foreach ($shared_pvs as $pv) { $error = array(); $uuid = $pv->getUuid(); $device = $pv->getDevice(); // init $inconsistent = 0; // look at physical volumes list $found_lvm = 0; foreach ($sync_node_pvs as $hpv) { $arr_hpv = (array) $hpv; if ($arr_hpv[EtvaPhysicalvolume::STORAGE_TYPE_MAP] == $pv->getStorageType()) { if (isset($arr_hpv[EtvaPhysicalvolume::UUID_MAP])) { if ($arr_hpv[EtvaPhysicalvolume::UUID_MAP] == $uuid) { $found_lvm = 1; } } else { if ($arr_hpv[EtvaPhysicalvolume::DEVICE_MAP] == $device) { $found_lvm = 1; } } } } $inconsistent = $inconsistent || !$found_lvm; if (!$found_lvm) { $error['not_found_lvm'] = 1; } /* TODO * check when have multipath */ // update data-base $etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByNodeTypeUUIDDevice($etva_node->getId(), $pv->getStorageType(), $pv->getUuid(), $pv->getDevice()); if ($etva_physicalvol) { $etva_physicalvol->setInconsistent($inconsistent); $etva_physicalvol->save(); } $etva_node_physicalvol = EtvaNodePhysicalvolumePeer::retrieveByPK($etva_node->getId(), $pv->getId()); if ($etva_node_physicalvol) { $etva_node_physicalvol->setInconsistent($inconsistent); $etva_node_physicalvol->save(); } if ($inconsistent) { $message = sfContext::getInstance()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_SHARED_INCONSISTENT_, array('%info%' => sprintf('device "%s" with uuid "%s"', $pv->getDevice(), $pv->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['device'] = $pv->getDevice(); $error['device_id'] = $pv->getId(); $error['uuid'] = $pv->getUuid(); $error['message'] = $message; } if (!empty($error)) { $errors[] = $error; } $node_inconsistent = $node_inconsistent || $inconsistent; } $return = array(); if ($node_inconsistent) { $etva_node->setErrorMessage(self::PVINIT); $return = array('success' => false, 'errors' => $errors); } else { $etva_node->clearErrorMessage(self::PVINIT); $return = array('success' => true); } return $return; //($node_inconsistent) ? false : true; }
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); }
/** * Return pre-formatted data for tree-column extjs * * $request may contain the following keys: * - nid: nid (virtAgent node ID) * @return array json array */ public function executeJsonVgsTree(sfWebRequest $request) { $criteria = new Criteria(); $criteria->add(EtvaNodeVolumeGroupPeer::NODE_ID, $request->getParameter('nid')); $node_vgs = EtvaNodeVolumeGroupPeer::doSelectJoinEtvaVolumegroup($criteria); $volumes = array(); foreach ($node_vgs as $data) { $node_id = $data->getNodeId(); $vg = $data->getEtvaVolumegroup(); $pvs_tree = array(); $etva_vp = $vg->getEtvaVolumePhysicals(); foreach ($etva_vp as $vp) { $pv = $vp->getEtvaPhysicalvolume(); if ($pv) { $id = $pv->getId(); $np = EtvaNodePhysicalvolumePeer::retrieveByPK($node_id, $id); //error_log(sprintf('node_id=%s id=%s',$node_id, $id)); /* TODO * mark this as inconsistence */ $elem = $np ? $np->getDevice() : $pv->getDevice(); $pvdevice = $pv->getPv(); $pretty_size = $size = $pv->getPvsize(); $qtip = ''; $cls = 'dev-pv'; $pvs_tree[] = array('id' => $id, 'cls' => $cls, 'iconCls' => 'task', 'text' => $elem, 'pv' => $pvdevice, 'size' => $size, 'prettysize' => $pretty_size, 'singleClickExpand' => true, 'type' => 'dev-pv', 'qtip' => $qtip, 'leaf' => true); } } $id = $vg->getVg(); $vgid = $vg->getId(); $qtip = ''; $cls = 'vg'; $pretty_size = $size = $vg->getSize(); $free_size = $vg->getFreesize(); $expanded = empty($pvs_tree) ? true : false; $type = $vg->getStorageType(); $is_DiskVG = $id == sfConfig::get('app_volgroup_disk_flag') ? 1 : 0; if ($is_DiskVG) { $type = 'file'; } /* TODO improve this */ if ($vg->getInconsistent()) { $qtip .= ' [INCONSISTENT]'; $cls = 'vg-inc'; } $inuse = $vg->hasLogicalVolumesInUse(); $volumes[] = array('id' => $id, 'expanded' => $expanded, 'vgid' => $vgid, 'iconCls' => 'devices-folder', 'cls' => $cls, 'text' => $id, 'type' => $type, 'size' => $size, 'prettysize' => $pretty_size, 'freesize' => $free_size, 'singleClickExpand' => true, 'qtip' => $qtip, 'children' => $pvs_tree, 'inuse' => $inuse); } if (empty($volumes)) { $msg_i18n = $this->getContext()->getI18N()->__('No data found'); $volumes[] = array('expanded' => true, 'text' => $msg_i18n, 'qtip' => $msg_i18n, 'leaf' => true); } $return = json_encode($volumes); $this->getResponse()->setHttpHeader('Content-type', 'application/json'); return $this->renderText($return); }