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); }
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; }