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 get_sync_logicalvolumes($force_sync = false, $sharedonly = false)
{
$elements = array();
$criteria = new Criteria();
$criteria->add(EtvaNodeLogicalvolumePeer::NODE_ID, $this->etva_node->getId());
$db_node_lvs = EtvaNodeLogicalvolumePeer::doSelectJoinEtvaLogicalvolume($criteria);
$force_flag = $force_sync ? 1 : 0;
$response_lvs = $this->etva_node->soapSend(EtvaLogicalvolume_VA::GET_SYNC_LOGICALVOLUMES, array('force' => $force_flag));
if ($response_lvs['success']) {
$lvs = $response_lvs['response'];
foreach ($lvs as $k => $e) {
$lv_e = (array) $e;
if (!$sharedonly || $lv_e[EtvaLogicalvolume::STORAGE_TYPE_MAP] != EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP) {
$found = false;
foreach ($db_node_lvs as $data) {
$lv = $data->getEtvaLogicalvolume();
if ($lv_e[EtvaLogicalvolume::STORAGE_TYPE_MAP] == $lv->getStorageType()) {
if ($lv->getUuid() && $lv_e[EtvaLogicalvolume::UUID_MAP]) {
if ($lv->getUuid() == $lv_e[EtvaLogicalvolume::UUID_MAP]) {
$found = true;
}
} else {
if ($lv->getLvdevice() == $lv_e[EtvaLogicalvolume::LVDEVICE_MAP]) {
$found = true;
}
}
}
}
$etva_lv = new EtvaLogicalvolume();
$etva_volgroup = new EtvaVolumegroup();
$etva_volgroup->initData((array) $lv_e[EtvaLogicalvolume::VOLUMEGROUP_MAP]);
/*$vg_ar = $lv_e[EtvaLogicalvolume::VOLUMEGROUP_MAP];
$vg_type = $vg_ar[EtvaVolumegroup::STORAGE_TYPE_MAP];
$vg_uuid = $vg_ar[EtvaVolumegroup::UUID_MAP];
$vg_name = $vg_ar[EtvaVolumegroup::VG_MAP];
$etva_volgroup = EtvaVolumegroupPeer::retrieveByNodeTypeUUIDVg($this->etva_node->getId(), $vg_type, $vg_uuid, $vg_name);*/
$etva_lv->initData($lv_e);
$etva_lv->setEtvaVolumegroup($etva_volgroup);
$arr_e = $etva_lv->_VA();
$arr_e['registered'] = $found;
$elements[] = $arr_e;
}
}
}
foreach ($db_node_lvs as $data) {
$lv = $data->getEtvaLogicalvolume();
if (!$sharedonly || $lv->getStorageType() != EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP) {
$found = false;
foreach ($lvs as $k => $e) {
$lv_e = (array) $e;
if ($lv_e[EtvaLogicalvolume::STORAGE_TYPE_MAP] == $lv->getStorageType()) {
if ($lv->getUuid() && $lv_e[EtvaLogicalvolume::UUID_MAP]) {
if ($lv->getUuid() == $lv_e[EtvaLogicalvolume::UUID_MAP]) {
$found = true;
}
} else {
if ($lv->getLvdevice() == $lv_e[EtvaLogicalvolume::LVDEVICE_MAP]) {
$found = true;
}
}
}
}
if (!$found) {
$arr_e = $lv->_VA();
$arr_e['inconsistent'] = true;
$arr_e['registered'] = true;
$elements[] = $arr_e;
}
}
}
return $elements;
}
/**
* 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 executeJsonLvsTree(sfWebRequest $request)
{
$lvs = array();
$etva_node = EtvaNodePeer::retrieveByPK($request->getParameter('nid'));
if (!$etva_node) {
$msg_i18n = $this->getContext()->getI18N()->__('No data found');
$lvs[] = array('expanded' => true, 'text' => $msg_i18n, 'qtip' => $msg_i18n, 'leaf' => true);
$return = json_encode($lvs);
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
}
$criteria = new Criteria();
//$node_lvs = $etva_node->getEtvaLogicalvolumes($criteria);
$criteria->add(EtvaNodeLogicalvolumePeer::NODE_ID, $request->getParameter('nid'));
$criteria->addAnd(EtvaLogicalvolumePeer::LV, 'etva-isos', Criteria::NOT_EQUAL);
$criteria->addAnd(EtvaLogicalvolumePeer::LV, 'etva_isos', Criteria::NOT_EQUAL);
$criteria->addAnd(EtvaLogicalvolumePeer::LV, 'etvaisos', Criteria::NOT_EQUAL);
//$criteria->addJoin(EtvaNodeLogicalvolumePeer::LOGICALVOLUME_ID, EtvaLogicalvolumePeer::ID);
$criteria->addAscendingOrderByColumn(EtvaLogicalvolumePeer::LV);
$node_data_lvs = EtvaNodeLogicalvolumePeer::doSelectJoinEtvaLogicalvolume($criteria);
//$node_data_lvs = EtvaLogicalvolumePeer::doSelect($criteria);
$snapshots = array();
foreach ($node_data_lvs as $data_lv) {
$etva_lv = $data_lv->getEtvaLogicalvolume();
$vm_name = '';
$vm_state = '';
$etva_vg = $etva_lv->getEtvaVolumegroup();
$etva_server = $etva_lv->getEtvaServer();
if ($etva_server) {
$vm_name = $etva_server->getName();
$vm_state = $etva_server->getVmState();
}
//check data consistency....should be fine
if ($etva_vg) {
$id = $etva_lv->getId();
$text = $etva_lv->getLv();
$disabled = false;
if ($etva_lv->getInUse()) {
$qtip = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INUSE_, array('%name%' => $text, '%server%' => $vm_name));
} else {
if ($etva_lv->getMounted()) {
$qtip = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_SYSTEM_LV_, array('%name%' => $text));
$disabled = true;
} else {
if ($etva_lv->getSnapshotNodeId() && $etva_lv->getSnapshotNodeId() != $etva_node->getId()) {
$qtip = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_SNAPSHOT_INOTHERNODE_, array('%name%' => $text));
$disabled = true;
} else {
if ($etva_lv->getSnapshot()) {
$qtip = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_SNAPSHOT_LV_, array('%name%' => $text));
#$disabled = true;
} else {
if ($etva_lv->getInconsistent() || $data_lv->getInconsistent()) {
$qtip = $this->getContext()->getI18N()->__('Inconsistent');
$disabled = true;
} else {
$qtip = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_NOTINUSE_, array('%name%' => $text));
}
}
}
}
}
$pretty_size = $etva_lv->getSize();
$size = $etva_lv->getSize();
$vg = $etva_vg->getVg();
$vg_size = $etva_vg->getSize();
$vg_freesize = $etva_vg->getFreesize();
$cls = 'lv';
if ($etva_lv->getSnapshot()) {
$snapshots[] = array('id' => $id, 'cls' => $cls, 'iconCls' => 'task', 'text' => $text, 'size' => $size, 'prettysize' => $pretty_size, 'vgsize' => $vg_size, 'singleClickExpand' => true, 'type' => 'lv-snapshot', 'vg' => $vg, 'vgfreesize' => $vg_freesize, 'snapshot' => $etva_lv->getSnapshot(), 'vm_state' => $vm_state, 'disabled' => $disabled, 'origin' => $etva_lv->getOrigin(), 'format' => $etva_lv->getFormat(), 'storagetype' => $etva_vg->getStorageType(), 'snapshot_node_id' => $etva_lv->getSnapshotNodeId(), 'inconsistent' => $etva_lv->getInconsistent() || $data_lv->getInconsistent(), 'vm_name' => $vm_name, 'qtip' => $qtip, 'leaf' => true);
} else {
$per_usage = $etva_lv->getVirtualSize() / $etva_lv->getSize();
$lv_iconCls = 'devices-folder';
if ($etva_lv->getPerUsageSnapshots() >= EtvaLogicalvolume::PER_USAGESNAPSHOTS_CRITICAL) {
$lv_iconCls = 'devices-folder-error';
}
$lvs[] = array('id' => $id, 'cls' => $cls, 'iconCls' => $lv_iconCls, 'text' => $text, 'size' => $size, 'prettysize' => $pretty_size, 'vgsize' => $vg_size, 'singleClickExpand' => true, 'type' => 'lv', 'vg' => $vg, 'vgfreesize' => $vg_freesize, 'format' => $etva_lv->getFormat(), 'storagetype' => $etva_vg->getStorageType(), 'vm_state' => $vm_state, 'disabled' => $disabled, 'inconsistent' => $etva_lv->getInconsistent() || $data_lv->getInconsistent(), 'virtual_size' => $etva_lv->getVirtualSize(), 'size_snapshots' => $etva_lv->getSizeSnapshots(), 'per_usage' => $per_usage, 'per_usage_snapshots' => $etva_lv->getPerUsageSnapshots(), 'vm_name' => $vm_name, 'qtip' => $qtip, 'leaf' => true);
}
}
}
foreach ($snapshots as $sn) {
for ($i = 0; $i < sizeof($lvs); $i++) {
if ($sn['vg'] == $lvs[$i]['vg'] && $sn['origin'] == $lvs[$i]['text']) {
$lvs[$i]['leaf'] = false;
$lvs[$i]['expanded'] = true;
$lvs[$i]['children'][] = $sn;
$lvs[$i]['havesnapshots'] = true;
if ($sn['vm_name']) {
$lvs[$i]['havesnapshots_inuse'] = true;
}
if ($sn['vm_state'] == 'running') {
$lvs[$i]['havesnapshots_inuse_inrunningvm'] = true;
}
if ($sn['snapshot_node_id']) {
$lvs[$i]['snapshot_node_id'];
}
if ($sn['snapshot_node_id'] && $sn['snapshot_node_id'] != $etva_node->getId()) {
$lvs[$i]['qtip'] = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_LV_HAVESNAPSHOTS_INOTHERNODE_, array('%name%' => $lvs[$i]['text']));
$lvs[$i]['disabled'] = true;
}
}
}
}
//$return = json_encode(array(array('text'=>'Lvs','expanded'=>true,'children'=>$lvs)));
if (empty($lvs)) {
$msg_i18n = $this->getContext()->getI18N()->__('No data found');
$lvs[] = array('expanded' => true, 'text' => $msg_i18n, 'qtip' => $msg_i18n, 'leaf' => true);
}
$return = json_encode($lvs);
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
}
public function check_consistency(EtvaNode $etva_node, $sync_node_lvs, $sync_node_dtable, $sync_bulk_dtable)
{
$errors = array();
$etva_node->getId();
$etva_cluster = $etva_node->getEtvaCluster();
// get node database LVs
$node_lvs = $etva_node->getEtvaLogicalvolumes();
$node_inconsistent = 0;
foreach ($node_lvs as $lv) {
$error = array();
$uuid = $lv->getUuid();
$device = $lv->getLvdevice();
$etva_vg = $lv->getEtvaVolumegroup();
$vgname = $etva_vg->getVg();
$is_FileDiskVG = $vgname == sfConfig::get('app_volgroup_disk_flag') ? true : false;
// init
$inconsistent = 0;
// look at logical volumes list
$found_lvm = 0;
foreach ($sync_node_lvs as $hlv) {
$arr_hlv = (array) $hlv;
if ($arr_hlv[EtvaLogicalvolume::STORAGE_TYPE_MAP] == $lv->getStorageType()) {
if ($arr_hlv[EtvaLogicalvolume::UUID_MAP]) {
if ($arr_hlv[EtvaLogicalvolume::UUID_MAP] == $uuid) {
$found_lvm = 1;
}
} else {
if ($arr_hlv[EtvaLogicalvolume::LVDEVICE_MAP] == $device) {
$found_lvm = 1;
}
}
}
}
$inconsistent = $inconsistent || !$found_lvm;
if (!$found_lvm) {
$error['not_found_lvm'] = 1;
}
if (!$is_FileDiskVG) {
// if not file disk volume
// look at devices table
$clvdev = $device;
$clvdev = str_replace("/dev/", "", $clvdev);
$clvdev = str_replace("-", "--", $clvdev);
$clvdev = str_replace("/", "-", $clvdev);
$re_clvdev = "/" . $clvdev . ":/";
// found device table of node
$node_lv_dtable_aux = preg_grep($re_clvdev, $sync_node_dtable);
// ignore snapshots
$node_lv_dtable = preg_grep("/(?:(?! snapshot ).)/", $node_lv_dtable_aux);
// check if found
$found_node_dt = empty($node_lv_dtable) ? 0 : 1;
$inconsistent = $inconsistent || !$found_node_dt;
if (!$found_node_dt) {
$error['not_found_node_device_table'] = 1;
}
}
// update data-base
$etva_logicalvol = EtvaLogicalvolumePeer::retrieveByNodeTypeUUIDLv($etva_node->getId(), $lv->getStorageType(), $lv->getUuid(), $lv->getLv());
if ($etva_logicalvol) {
$etva_logicalvol->setInconsistent($inconsistent);
$etva_logicalvol->save();
}
$etva_node_logicalvol = EtvaNodeLogicalvolumePeer::retrieveByPK($etva_node->getId(), $lv->getId());
if ($etva_node_logicalvol) {
$etva_node_logicalvol->setInconsistent($inconsistent);
$etva_node_logicalvol->save();
}
if ($inconsistent) {
$message = sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => sprintf('device "%s" with uuid "%s"', $lv->getLvdevice(), $lv->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'] = $lv->getLvdevice();
$error['uuid'] = $lv->getUuid();
$error['message'] = $message;
}
if (!empty($error)) {
$errors[] = $error;
}
$node_inconsistent = $node_inconsistent || $inconsistent;
}
// get shared database LVs
$shared_lvs = $etva_cluster->getSharedLvs();
// check consistency for shared LVs
foreach ($shared_lvs as $lv) {
$error = array();
$uuid = $lv->getUuid();
$device = $lv->getLvdevice();
$etva_vg = $lv->getEtvaVolumegroup();
$vgname = $etva_vg->getVg();
// init
$inconsistent = 0;
// look at logical volumes list
$found_lvm = 0;
foreach ($sync_node_lvs as $hlv) {
$arr_hlv = (array) $hlv;
if ($arr_hlv[EtvaLogicalvolume::STORAGE_TYPE_MAP] == $lv->getStorageType()) {
if (isset($arr_hlv[EtvaLogicalvolume::UUID_MAP])) {
if ($arr_hlv[EtvaLogicalvolume::UUID_MAP] == $uuid) {
$found_lvm = 1;
}
} else {
if ($arr_hlv[EtvaLogicalvolume::LVDEVICE_MAP] == $device) {
$found_lvm = 1;
}
}
}
}
$inconsistent = $inconsistent || !$found_lvm;
if (!$found_lvm) {
$error['not_found_lvm'] = 1;
}
// look at devices table
$clvdev = $device;
$clvdev = str_replace("/dev/", "", $clvdev);
$clvdev = str_replace("-", "--", $clvdev);
$clvdev = str_replace("/", "-", $clvdev);
$re_clvdev = "/" . $clvdev . ":/";
// found device table of node
$node_lv_dtable_aux = preg_grep($re_clvdev, $sync_node_dtable);
// ignore snapshots
$node_lv_dtable = preg_grep("/(?:(?! snapshot ).)/", $node_lv_dtable_aux);
// check if found
$found_node_dt = empty($node_lv_dtable) ? 0 : 1;
$inconsistent = $inconsistent || !$found_node_dt;
if (!$found_node_dt) {
$error['not_found_node_device_table'] = 1;
}
// look at all nodes devices table
$found_all_nodes_dt = 1;
foreach ($sync_bulk_dtable as $e_id => $e_response) {
if ($e_response['success']) {
//response received ok
$dtable = (array) $e_response['response'];
// found device table of node
$lv_dtable = preg_grep($re_clvdev, $dtable);
$found = empty($lv_dtable) ? 0 : 1;
$is_eq = count($lv_dtable) == count($node_lv_dtable) ? 1 : 0;
if ($is_eq) {
foreach ($lv_dtable as $e_line) {
// TODO fix this
if (!in_array($e_line, $node_lv_dtable)) {
$is_eq = 0;
}
}
}
$found_all_nodes_dt = $found_all_nodes_dt && $found && $is_eq;
}
}
$inconsistent = $inconsistent || !$found_all_nodes_dt;
if (!$found_all_nodes_dt) {
$error['not_found_all_nodes_device_table'] = 1;
}
// update data-base
$etva_logicalvol = EtvaLogicalvolumePeer::retrieveByNodeTypeUUIDLv($etva_node->getId(), $lv->getStorageType(), $lv->getUuid(), $lv->getLv());
if ($etva_logicalvol) {
$etva_logicalvol->setInconsistent($inconsistent);
$etva_logicalvol->save();
}
$etva_node_logicalvol = EtvaNodeLogicalvolumePeer::retrieveByPK($etva_node->getId(), $lv->getId());
if ($etva_node_logicalvol) {
$etva_node_logicalvol->setInconsistent($inconsistent);
$etva_node_logicalvol->save();
}
if ($inconsistent) {
$message = sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_SHARED_INCONSISTENT_, array('%info%' => sprintf('device "%s" with uuid "%s"', $lv->getLvdevice(), $lv->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'] = $lv->getLvdevice();
$error['uuid'] = $lv->getUuid();
$error['message'] = $message;
}
if (!empty($error)) {
$errors[] = $error;
}
$node_inconsistent = $node_inconsistent || $inconsistent;
}
$return = array();
if ($node_inconsistent) {
$etva_node->setErrorMessage(self::LVINIT);
$return = array('success' => false, 'errors' => $errors);
} else {
$etva_node->clearErrorMessage(self::LVINIT);
$return = array('success' => true);
}
return $return;
}
