protected function execute($arguments = array(), $options = array())
{
$context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$connection = $databaseManager->getDatabase($options['connection'])->getConnection();
// add your code here
// get parameters
$lv = $arguments['name'];
$size = $arguments['size'];
$vg = $arguments['volumegroup'];
$node_id = $options['node'];
$format = $options['format'];
$persnapshotusage = $options['persnapshotusage'];
/*
* check if lv is a file disk instead
* if is a file disk check if special volume group exists. if not create
*/
$is_DiskFile = $vg == sfConfig::get('app_volgroup_disk_flag') ? 1 : 0;
// get etva_node
$etva_node = EtvaNodePeer::getOrElectNodeFromArray(array_merge($options, $arguments));
if (!$etva_node) {
$msg_i18n = $context->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $node_id));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
// get logical volume
if ($etva_lv = $etva_node->retrieveLogicalvolumeByLv($lv)) {
$msg_type = $is_DiskFile ? EtvaLogicalvolumePeer::_ERR_DISK_EXIST_ : EtvaLogicalvolumePeer::_ERR_LV_EXIST_;
$msg = Etva::getLogMessage(array('name' => $lv), $msg_type);
$msg_i18n = $context->getI18N()->__($msg_type, array('%name%' => $lv));
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
if (!($etva_vg = $etva_node->retrieveVolumegroupByVg($vg))) {
$msg = Etva::getLogMessage(array('name' => $vg), EtvaVolumegroupPeer::_ERR_NOTFOUND_);
$msg_i18n = $context->getI18N()->__(EtvaVolumegroupPeer::_ERR_NOTFOUND_, array('%name%' => $vg));
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
// prepare soap info....
$etva_lv = new EtvaLogicalvolume();
$etva_lv->setEtvaVolumegroup($etva_vg);
$etva_lv->setLv($lv);
$lv_va = new EtvaLogicalvolume_VA($etva_lv);
$response = $lv_va->send_create($etva_node, $size, $format, $persnapshotusage);
if (!$response['success']) {
$this->log("[ERROR] " . $response['error']);
} else {
$this->log("[INFO] " . $response['response']);
}
return $response;
}
protected function execute($arguments = array(), $options = array())
{
$context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$connection = $databaseManager->getDatabase($options['connection'])->getConnection();
// add your code here
// get node
$node_id = $options['node'];
$etva_node = EtvaNodePeer::getOrElectNodeFromArray(array_merge($options, $arguments));
if (!$etva_node) {
$msg_i18n = $context->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $node_id));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
// logical volume to clone
$lv = $arguments['logicalvolume'];
$vg = $options['volumegroup'];
// check if a logical volume exists
if (!($etva_lv = $etva_node->retrieveLogicalvolumeByAny($lv, $vg))) {
$msg = Etva::getLogMessage(array('name' => $lv), EtvaLogicalvolumePeer::_ERR_NOTFOUND_);
$msg_i18n = $context->getI18N()->__(EtvaLogicalvolumePeer::_ERR_NOTFOUND_, array('%name%' => $lv));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
// original logical volume
$original_lv = $arguments['original'];
$original_vg = $options['original-volumegroup'];
// if cannot find logical volume
if (!($etva_original_lv = $etva_node->retrieveLogicalvolumeByAny($original_lv, $original_vg))) {
$msg = Etva::getLogMessage(array('name' => $original_lv), EtvaLogicalvolumePeer::_ERR_NOTFOUND_);
$msg_i18n = $context->getI18N()->__(EtvaLogicalvolumePeer::_ERR_NOTFOUND_, array('%name%' => $original_lv));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
// prepare soap info....
$lv_va = new EtvaLogicalvolume_VA($etva_lv);
$response = $lv_va->send_clone($etva_node, $etva_original_lv);
if (!$response['success']) {
$this->log("[ERROR] " . $response['error']);
} else {
$this->log("[INFO] " . $response['response']);
}
return $response;
}
public function initialize(EtvaNode $etva_node, $vgs, $force_regist = false)
{
$etva_cluster = $etva_node->getEtvaCluster();
$volumegroup_names = array();
$errors = array();
/*
* check shared vgs consistency
*/
$check_res = $this->check_consistency($etva_node, $vgs);
if (!$check_res['success']) {
$errors = $check_res['errors'];
$inconsistent_message = Etva::getLogMessage(array('info' => ''), EtvaVolumegroupPeer::_ERR_INCONSISTENT_);
$etva_node->setErrorMessage(self::VGINIT);
$message = Etva::getLogMessage(array('info' => $inconsistent_message), EtvaVolumegroupPeer::_ERR_SOAPUPDATE_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
//return array('success'=>false,'error'=>$errors);
}
/*$consist = $this->check_shared_consistency($etva_node,$vgs);
if(!$consist){
$errors = $this->missing_vgs[$etva_node->getId()];
$inconsistent_message = Etva::getLogMessage(array('info'=>''), EtvaVolumegroupPeer::_ERR_INCONSISTENT_);
$etva_node->setErrorMessage(self::VGINIT);
$message = Etva::getLogMessage(array('info'=>$inconsistent_message), EtvaVolumegroupPeer::_ERR_SOAPUPDATE_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(),'event.log',array('message' =>$message,'priority'=>EtvaEventLogger::ERR)));
return array('success'=>false,'error'=>$errors);
}*/
foreach ($vgs as $vgInfo) {
$vg_info = (array) $vgInfo;
$vg_name = $vg_info[EtvaVolumegroup::VG_MAP];
$vg_type = $vg_info[EtvaVolumegroup::STORAGE_TYPE_MAP];
//error_log(sprintf("node name=%s id=%d vg_name=%s uuid=%s type=%s",$etva_node->getName(),$etva_node->getId(),$vg_name,$vg_info[EtvaVolumegroup::UUID_MAP],$vg_type));
//error_log(print_r($vg_info,true));
if ($vg_type == EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP) {
$etva_volgroup = EtvaVolumegroupPeer::retrieveByNodeTypeVg($etva_node->getId(), $vg_type, $vg_name);
} else {
$vg_uuid = $vg_info[EtvaVolumegroup::UUID_MAP];
$etva_volgroup = EtvaVolumegroupPeer::retrieveByUUID($vg_uuid);
}
if ($force_regist && !$etva_volgroup) {
// no vg in db... and force registration ... so create new one
$etva_node_volgroup = new EtvaNodeVolumegroup();
$etva_volgroup = new EtvaVolumegroup();
} else {
if ($etva_volgroup) {
//if vg already in DB we need to make sure if already exists association with node. if not create new one
$etva_node_volgroup = EtvaNodeVolumegroupPeer::retrieveByPK($etva_node->getId(), $etva_volgroup->getId());
if (!$etva_node_volgroup) {
$etva_node_volgroup = new EtvaNodeVolumegroup();
}
}
}
if ($etva_volgroup) {
// only if vg in db...
$etva_volgroup->initData($vg_info);
$etva_volgroup->setEtvaCluster($etva_cluster);
$etva_node_volgroup->setEtvaVolumegroup($etva_volgroup);
$etva_node_volgroup->setEtvaNode($etva_node);
$etva_node_volgroup->save();
/*
* associate pvs with vg
*/
$pvs = isset($vg_info[EtvaVolumegroup::PHYSICALVOLUMES_MAP]) ? (array) $vg_info[EtvaVolumegroup::PHYSICALVOLUMES_MAP] : array();
foreach ($pvs as $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];
//get physical volume based on node, type, uuid and device
$etva_physical = EtvaPhysicalvolumePeer::retrieveByNodeTypeUUIDDevice($etva_node->getId(), $pv_type, $pv_uuid, $pv_device);
$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();
}
$volumegroup_names[] = $etva_volgroup->getVg();
}
}
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_VGS);
}
$etva_node->clearErrorMessage(self::VGINIT);
$message = Etva::getLogMessage(array('info' => implode(', ', $volumegroup_names)), EtvaVolumegroupPeer::_OK_SOAPUPDATE_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message)));
return array('success' => true, 'response' => $volumegroup_names);
}
}
public function executeIsoJsonDelete(sfWebRequest $request)
{
$directory = sfConfig::get("config_isos_dir");
$file = $request->getParameter('file');
$file_path = $directory . '/' . $file;
$sys_msg = exec('stat -c "%F" ' . escapeshellarg($file_path), $sys_call);
if (empty($sys_call)) {
$info_message = Etva::getLogMessage(array('name' => $file, 'info' => ''), ETVA::_ERR_ISO_PROBLEM_);
$msg_i18n = $this->getContext()->getI18N()->__(ETVA::_ERR_ISO_DELETE_, array('%info%' => $info_message));
$msg = array('success' => false, 'message' => $msg_i18n);
$response = json_encode($msg);
return $this->renderText($response);
}
$errors = Etva::verify_iso_usage($file);
if ($errors) {
$info_message = Etva::getLogMessage(array('name' => $file, 'info' => ETVA::_CDROM_INUSE_), ETVA::_ERR_ISO_INUSE_);
$message = Etva::getLogMessage(array('info' => $info_message), ETVA::_ERR_ISO_DELETE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$i18n_br_sep = implode('<br>', $errors);
$i18n_sp_sep = implode(' ', $errors);
$i18n_iso_br_msg = $this->getContext()->getI18N()->__(ETVA::_ERR_ISO_INUSE_, array('%name%' => $file, '%info%' => '<br>' . $i18n_br_sep));
$i18n_iso_sp_msg = $this->getContext()->getI18N()->__(ETVA::_ERR_ISO_INUSE_, array('%name%' => $file, '%info%' => $i18n_sp_sep));
$message_i18n = $this->getContext()->getI18N()->__(ETVA::_ERR_ISO_PROBLEM_, array('%name%' => $file, '%info%' => ''));
$msg = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'message' => $message_i18n, 'info' => $i18n_iso_br_msg, 'error' => $i18n_iso_sp_msg);
$error = $this->setJsonError($msg);
return $this->renderText($error);
}
if ($file && $request->isMethod('post') && stristr($sys_msg, 'file')) {
if (unlink($file_path)) {
$msg = array('success' => true);
} else {
$msg = array('success' => false, 'message' => $msg_i18n);
}
} else {
$msg = array('success' => false, 'message' => $msg_i18n);
}
$response = json_encode($msg);
return $this->renderText($response);
}
public function executeJsonUpdate(sfWebRequest $request)
{
// create node entry
$id = $request->getParameter('id');
$etva_node = EtvaNodePeer::retrieveByPK($id);
if (!$etva_node) {
$form = new EtvaNodeForm();
} else {
$form = new EtvaNodeForm($etva_node);
}
$data = (array) json_decode($request->getParameter($form->getName()));
if ($data['name'] && $data['name'] != $etva_node->getName()) {
// if name changed
$node_va = new EtvaNode_VA($etva_node);
$response = $node_va->send_change_name($data['name']);
// send to VA to change name
if (!$response['success']) {
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($response);
}
$return = $this->setJsonError($response);
return $this->renderText($return);
}
}
try {
$etva_node->fromArray($data, BasePeer::TYPE_FIELDNAME);
$etva_node->save();
} catch (Exception $e) {
$result = array('success' => false, 'error' => array('node' => $e->getMessage()), 'obj' => $etva_cluster);
$error = $this->setJsonError($result);
return $this->renderText($error);
}
$name = $etva_node->getName();
$i18n_msg = $msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_OK_UPDATE_, array('%name%' => $name));
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $name), EtvaNodePeer::_OK_UPDATE_))));
$return = array('success' => true, 'agent' => sfConfig::get('config_acronym'), 'response' => $i18n_msg, 'node_id' => $etva_node->getId());
$return = json_encode($return);
error_log("getFencingconf_cmd " . $etva_node->getFencingconf_cmd('status'));
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
}
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;
}
}
/**
* Used to process soap requests => updateVirtAgentVlans
*
* Updates vlan info sent by virt Agent
*
* Replies with succcess
*
* $request may contain the following keys:
* - uid: uid (virtAgent sending request uid)
* - vlans (object containing vlans info)
* @return array array(new vlans)
*/
public function executeSoapUpdate(sfWebRequest $request)
{
if (sfConfig::get('sf_environment') == 'soap') {
//get config data file
$etva_data = Etva::getEtvaModelFile();
//check etva model type
$etvamodel = $etva_data['model'];
$vlans = $request->getParameter('vlans');
$vlans_names = array();
foreach ($vlans as $vlanInfo) {
$vlan_data = (array) $vlanInfo;
$vlans_names[] = $vlan_data['name'];
}
$c = new Criteria();
$c->add(EtvaNodePeer::UUID, $request->getParameter('uuid'));
if (!($etva_node = EtvaNodePeer::doSelectOne($c))) {
$error_msg = sprintf('Object etva_node does not exist (%s).', $request->getParameter('uuid'));
$node_log = Etva::getLogMessage(array('name' => $request->getParameter('uuid')), EtvaNodePeer::_ERR_NOTFOUND_UUID_);
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('info' => $node_log), EtvaVlanPeer::_ERR_SOAPUPDATE_), 'priority' => EtvaEventLogger::ERR)));
$error = array('success' => false, 'error' => $error_msg);
return $error;
}
$node_initialize = $etva_node->getInitialize();
if ($node_initialize != EtvaNode_VA::INITIALIZE_OK) {
$error_msg = sprintf('Etva node initialize status: %s', $node_initialize);
$error = array('success' => false, 'error' => $error_msg);
return $error;
}
/*
* checks if CM vlans exists on node info Vlans
* return vlans to be created on node
*
*/
// filter results by cluster
$vlan_criteria = new Criteria();
$vlan_criteria->add(EtvaVlanPeer::CLUSTER_ID, $etva_node->getClusterId());
$etva_vlans = EtvaVlanPeer::doSelect($vlan_criteria);
$new_vlans = array();
foreach ($etva_vlans as $etva_vlan) {
if (!in_array($etva_vlan->getName(), $vlans_names)) {
$data = array('name' => $etva_vlan->getName(), 'ifout' => $etva_vlan->getIntf());
/*
* if model type == enterprise send vlan ID and untagged/tagged option
*/
if (strtolower($etvamodel) != 'standard') {
$data['vlanid'] = $etva_vlan->getVlanId();
$tagged = $etva_vlan->getTagged();
if ($tagged) {
$data['vlan_tagged'] = 1;
} else {
$data['vlan_untagged'] = 1;
}
}
$new_vlans[$etva_vlan->getName()] = $data;
}
}
$vlans_names = array_keys($new_vlans);
$vlans = implode(', ', $vlans_names);
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $etva_node->getName(), 'info' => $vlans), EtvaVlanPeer::_OK_SOAPUPDATE_), 'priority' => EtvaEventLogger::INFO)));
return $new_vlans;
}
// end soap request
}
public function executeJsonUnregister(sfWebRequest $request)
{
$msg_ok_type = EtvaLogicalvolumePeer::_OK_UNREGISTER_;
$msg_err_type = EtvaLogicalvolumePeer::_ERR_UNREGISTER_;
// get node id
if (!($etva_node = EtvaNodePeer::retrieveByPK($request->getParameter('nid')))) {
// ... or elect from cluster context
$etva_node = EtvaNodePeer::getOrElectNode($request);
}
if (!$etva_node) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$node_log = Etva::getLogMessage(array('id' => $nid), EtvaNodePeer::_ERR_NOTFOUND_ID_);
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $node_log, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$lv = $request->getParameter('lv');
$vg = $request->getParameter('vg');
$uuid = $request->getParameter('uuid');
if (!($etva_logicalvolume = $etva_node->retrieveLogicalvolume($uuid, $vg, $lv))) {
//lv is the logical volume name
$msg = Etva::getLogMessage(array('name' => $lv), EtvaLogicalvolumePeer::_ERR_NOTFOUND_);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_NOTFOUND_, array('%name%' => $lv));
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify system log
$message = Etva::getLogMessage(array('name' => $lv, 'info' => $msg), EtvaLogicalvolumePeer::_ERR_UNREGISTER_);
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$etva_lv_va = new EtvaLogicalvolume_VA($etva_logicalvolume);
$response = $etva_lv_va->unregister($etva_node);
if (!$response['success']) {
$msg_i18n = $this->getContext()->getI18N()->__($msg_err_type, array('%name%' => $lv));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$node_log = Etva::getLogMessage(array('name' => $lv), $msg_err_type);
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $node_log, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
//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' => $etva_node->getName(), 'response' => $msg_i18n);
$return = json_encode($result);
if (sfConfig::get('sf_environment') == 'soap') {
return $return;
}
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
}
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 send_assign(EtvaNode $to_etva_node)
{
$etva_server = $this->etva_server;
$from_etva_node = $etva_server->getEtvaNode();
$etva_server->setUnassigned(0);
// mark server as unassigned
$method = self::SERVER_MOVE;
$err_op = EtvaServerPeer::_ERR_ASSIGNED_;
$preHaveMem = $this->haveMemoryAvailable($method, $to_etva_node);
if (!$preHaveMem['success']) {
return $preHaveMem;
}
if ($from_etva_node) {
if ($from_etva_node->getId() != $to_etva_node->getId()) {
// if different nodes
$preHaveAllShared = $this->haveAllSharedLogicalvolumes($method, $to_etva_node);
if (!$preHaveAllShared['success']) {
return $preHaveAllShared;
}
}
} else {
$preCanAssign = $this->canAssignToNode($method, $to_etva_node);
if (!$preCanAssign['success']) {
return $preCanAssign;
}
}
$params = $etva_server->_VA();
$response = $to_etva_node->soapSend(self::SERVER_CREATE, $params);
if (!$response['success']) {
$error_decoded = $response['error'];
$result = $response;
$msg_i18n = sfContext::getInstance()->getI18N()->__(EtvaServerPeer::_ERR_ASSIGNED_, array('%name%' => $etva_server->getName(), '%node%' => $to_etva_node->getName(), '%info%' => $error_decoded));
$result['error'] = $msg_i18n;
$message = Etva::getLogMessage(array('name' => $etva_server->getName(), 'node' => $to_etva_node->getName(), 'info' => $response['info']), EtvaServerPeer::_ERR_ASSIGNED_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
return $result;
}
$etva_server->save();
$update_node_server = $this->reloadVm($to_etva_node);
if ($update_node_server['success']) {
$msg_i18n = sfContext::getInstance()->getI18N()->__(EtvaServerPeer::_OK_ASSIGNED_, array('%name%' => $etva_server->getName(), '%node%' => $to_etva_node->getName(), '%info%' => $returned_status));
$result = array('success' => true, 'agent' => $response['agent'], 'response' => $msg_i18n);
//notify event log
$message = Etva::getLogMessage(array('name' => $etva_server->getName(), 'node' => $to_etva_node->getName(), 'info' => $response['info']), EtvaServerPeer::_OK_ASSIGNED_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message)));
return $result;
}
return $update_node_server;
}
public function executeJsonFindSource(sfWebRequest $request)
{
/*$msg_ok_type = EtvaPoolPeer::_OK_FIND_SOURCE_;
$msg_err_type = EtvaPoolPeer::_ERR_FIND_SOURCE_;*/
// get node id from cluster context
$etva_node = EtvaNodePeer::getOrElectNode($request);
if (!$etva_node) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$node_log = Etva::getLogMessage(array('id' => $nid), EtvaNodePeer::_ERR_NOTFOUND_ID_);
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $node_log, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$type = $request->getParameter('type');
$source_host = $request->getParameter('source_host');
// call find storage pool source
$response = $etva_node->soapSend('find_storage_pool_source', array('type' => $type, 'source_host' => $source_host));
if ($response['success']) {
$return = json_encode($response);
// if the request is made throught soap request...
if (sfConfig::get('sf_environment') == 'soap') {
return $return;
}
// if is browser request return text renderer
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
} else {
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($response);
}
$return = $this->setJsonError($response);
return $this->renderText($return);
}
}
public function executeJsonUpdate(sfWebRequest $request)
{
// create cluster entry
$id = $request->getParameter('id');
$cluster = EtvaClusterPeer::retrieveByPK($id);
if (!$cluster) {
$error_msg = sprintf('Object etva_cluster does not exist (%s).', $request->getParameter('id'));
$info = array('success' => false, 'error' => $error_msg);
$error = $this->setJsonError($info);
return $this->renderText($error);
}
/*if(!$cluster) $form = new EtvaClusterForm();
else $form = new EtvaClusterForm($cluster);
$result = $this->processJsonForm($request, $form);
if(!$result['success']){
$error = $this->setJsonError($result);
return $this->renderText($error);
}
//get cluster object
$etva_cluster = $result['object'];*/
$form_data = (array) json_decode($request->getParameter('etva_cluster'));
$clustername = $form_data['name'];
if (!preg_match('/^[a-zA-Z][a-zA-Z0-9\\-\\_]+$/', $clustername)) {
$msg = "Invalid name format";
error_log("CLUSTER[ERROR]" . $msg);
$msg_i18n = $this->getContext()->getI18N()->__($msg);
$error_msg = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n);
//notify system log
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => Etva::getLogMessage(array('name' => $clustername, 'info' => $msg), EtvaClusterPeer::_ERR_CREATE_), 'priority' => EtvaEventLogger::ERR)));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'info' => $msg_i18n, 'error' => array($error_msg));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$cluster->setName($clustername);
$cluster->setIsDefaultCluster(0);
if ($form_data['isDefaultCluster']) {
$updatecluster = array('Isdefaultcluster' => 0);
EtvaClusterQuery::create()->update($updatecluster);
$cluster->setIsDefaultCluster(1);
}
$cluster->setHasNodeHA($form_data['hasNodeHA'] ? 1 : 0);
$cluster->setAdmissionGateType($form_data['admissionGate_type']);
$cluster->setAdmissionGateValue($form_data['admissionGate_value']);
$cluster->save();
$etva_cluster = $cluster;
$updateNodes = array('Issparenode' => 0);
if ($request->getParameter('fencingconf')) {
$fencingconf = $request->getParameter('fencingconf');
$updateNodes['Fencingconf'] = $fencingconf;
}
//clear spare node
EtvaNodeQuery::create()->filterByClusterId($etva_cluster->getId())->update($updateNodes);
if ($sparenode_id = $request->getParameter('sparenode')) {
if ($etva_sparenode = EtvaNodePeer::retrieveByPK($sparenode_id)) {
// and mark the spare node
$etva_sparenode->setIsSpareNode(1);
$etva_sparenode->save();
}
}
$name = $etva_cluster->getName();
$i18n_msg = $msg_i18n = $this->getContext()->getI18N()->__(EtvaClusterPeer::_OK_UPDATE_, array('%name%' => $name));
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $name), EtvaClusterPeer::_OK_UPDATE_))));
$return = array('success' => true, 'agent' => sfConfig::get('config_acronym'), 'response' => $i18n_msg, 'cluster_id' => $etva_cluster->getId());
$return = json_encode($return);
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
}
public function executeJsonRemoveSnapshot(sfWebRequest $request)
{
$sid = $request->getParameter('id');
if (!($etva_server = EtvaServerPeer::retrieveByPK($sid))) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaServerPeer::_ERR_NOTFOUND_ID_, array('%id%' => $sid));
$error = array('agent' => sfConfig::get('config_acronym'), 'success' => false, 'error' => $msg_i18n);
//notify event log
$server_log = Etva::getLogMessage(array('id' => $sid), EtvaServerPeer::_ERR_NOTFOUND_ID_);
$message = Etva::getLogMessage(array('info' => $server_log), EtvaServerPeer::_ERR_MIGRATE_UNKNOWN_);
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$etva_node = $etva_server->getEtvaNode();
$snapshot = $request->getParameter('snapshot');
$server_va = new EtvaServer_VA($etva_server);
$response = $server_va->remove_snapshot($etva_node, $snapshot);
if ($response['success']) {
$return = json_encode($response);
// if the request is made throught soap request...
if (sfConfig::get('sf_environment') == 'soap') {
return $return;
}
// if is browser request return text renderer
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
} else {
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($response);
}
$return = $this->setJsonError($response);
return $this->renderText($return);
}
}
/**
* Expanad the physical volume
*
* Expand size of physical volume,
*
* $request may contain the following keys:
* - nid: virt agent node ID
* - dev: device name Ex: /dev/sdb1
*
* Returns json array('success'=>true,'response'=>$resp) on success
* <br>or<br>
* json array('success'=>false,'error'=>$error) on error
*
*/
public function executeJsonExpand(sfWebRequest $request)
{
$nid = $request->getParameter('nid');
$dev = $request->getParameter('dev');
$etva_node = EtvaNodePeer::getOrElectNode($request);
if (!$etva_node) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify system log
$node_log = Etva::getLogMessage(array('id' => $nid), EtvaNodePeer::_ERR_NOTFOUND_ID_);
$message = Etva::getLogMessage(array('name' => $dev, 'info' => $node_log), EtvaPhysicalvolumePeer::_ERR_UNINIT_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
// get DB info
if (!($etva_pv = $etva_node->retrievePhysicalvolumeByDevice($dev))) {
$msg = Etva::getLogMessage(array('name' => $etva_node->getName(), 'dev' => $dev), EtvaNodePeer::_ERR_NODEV_);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NODEV_, array('%name%' => $etva_node->getName(), '%dev%' => $dev));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify system log
$message = Etva::getLogMessage(array('name' => $dev, 'info' => $msg), EtvaPhysicalvolumePeer::_ERR_UNINIT_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
$error = $this->setJsonError($error);
return $this->renderText($error);
}
/*
* send physical volume to VA
*/
$pv_va = new EtvaPhysicalvolume_VA($etva_pv);
$response = $pv_va->send_expand($etva_node);
if ($response['success']) {
$return = json_encode($response);
// if the request is made throught soap request...
if (sfConfig::get('sf_environment') == 'soap') {
return $return;
}
// if is browser request return text renderer
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
} else {
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($response);
}
$return = $this->setJsonError($response);
return $this->renderText($return);
}
}
public function backup($force, $diagnostic = false)
{
if (!$diagnostic) {
$serial_number = $this->serial_number;
//clear stage cache
$this->delStage(self::BACKUP_STAGE);
$this->delStage(self::MA_BACKUP);
} else {
$response_msg = '';
$va_down = array();
}
/*
* VIRT AGENTS
*/
$node_list = EtvaNodePeer::getWithServers();
$node_num = count($node_list);
if (!$diagnostic) {
if ($node_num != 1) {
/*
* ERROR should be only one element (standard ETVA release only)
*/
$msg = "Sould only be one Virtualization Agent! {$node_num} found!";
$data = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'info' => $msg, 'error' => $msg);
return $data;
}
}
$archive_files = array();
foreach ($node_list as $node) {
/*
* check node state ok to comm with agent
*/
if (!$diagnostic) {
if (!$node->getState()) {
$node_name = $node->getName();
$msg = sfContext::getInstance()->getI18N()->__(EtvaNodePeer::_STATE_DOWN_, array('%name%' => $node_name));
$data = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'info' => $msg, 'error' => $msg);
return $data;
}
} else {
if ($node->getInitialize() == EtvaNodePeer::_INITIALIZE_PENDING_) {
continue;
}
if (!$node->getState()) {
$response_msg .= $node->getName();
$response_msg .= ', ';
$va_down[] = $node->getName();
$command = "touch ";
$command .= $this->archive_base_dir . "/";
$command .= $node->getName() . "_down";
exec($command);
continue;
}
}
if (!$diagnostic) {
$servers_list = $node->getEtvaServers();
$servers_down = array();
/*
* Firs pass, check for servers down...
*/
foreach ($servers_list as $server) {
$server_name = $server->getName();
$server_state = $server->getState();
$server_vm = $server->getVmState();
$server_ma = $server->getAgentTmpl();
/*
* if there's an agent in VM and if vm not running or agent is down add to servers down
*/
if ($server_ma && !$server_state) {
$servers_down[] = Etva::getLogMessage(array('agent' => $server->getName(), 'msg' => 'Down'), Etva::_AGENT_MSG_);
}
}
/*
* First pass return errors found
*/
if (!empty($servers_down) && !$force) {
$data = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'action' => self::MA_BACKUP, 'info' => implode('<br>', $servers_down), 'error' => implode(' ', $servers_down));
return $data;
}
/*
* Second pass...user has been warn
*/
$servers_error = array();
$this->setStage(self::BACKUP_STAGE, self::MA_BACKUP);
foreach ($servers_list as $server) {
$server_name = $server->getName();
$server_state = $server->getState();
$server_vm = $server->getVmState();
$server_ma = $server->getAgentTmpl();
$server_uuid = $server->getUuid();
/*
* if there's an agent in VM send backup command
*/
if ($server_ma && $server_state) {
/*
* take care of MA backup stuff here....
*/
$this->setStage(self::MA_BACKUP, $server_ma);
$ma_filename = sprintf(self::MA_ARCHIVE_FILE, $server_uuid, $server_ma);
// filename path without extension yet. it will be given by get_backupconf result
$full_path = $this->archive_base_dir . '/' . $ma_filename;
$ma_backup = $this->get_backupconf($server_name, $server->getIp(), $server->getAgentPort(), $full_path);
if (!$ma_backup['success']) {
$servers_error[] = $ma_backup['error'];
continue;
}
$archive_files[] = $ma_backup['path'];
}
}
// end servers backup agents
}
/*
* get VA backup
*
*/
$node_uuid = $node->getUuid();
$node_name = $node->getName();
$va_filename = sprintf(self::VA_ARCHIVE_FILE, $node_uuid, 'VA');
// filename path without extension yet. it will be given by get_backupconf result
$full_path = $this->archive_base_dir . '/' . $va_filename;
$va_backup = $this->get_backupconf($node_name, $node->getIp(), $node->getPort(), $full_path, $diagnostic);
if ($va_backup['success']) {
$archive_files[] = $va_backup['path'];
}
}
if (!$diagnostic) {
if (!empty($servers_error)) {
$data = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'action' => self::MA_BACKUP, 'info' => implode('<br>', $servers_error), 'error' => implode(' ', $servers_error));
return $data;
}
}
/*
*
* CENTRAL MANAGEMENT BACKUP (DB)
*
*
*/
$db_filename = $this->tmp_db_filename;
$this->setStage(self::BACKUP_STAGE, self::DB_BACKUP);
// do NOT store session info in backup
$data = new MyPropelData();
$data->dumpData($db_filename, 'all', array('Sessions'), null);
$archive_files[] = $db_filename;
error_log('CM BACKUP');
error_log($db_filename);
if (!$diagnostic) {
$response = $this->uploadApplianceBackup($archive_files);
if (!empty($servers_error)) {
$response['errors'] = implode('<br>', $servers_error);
}
} else {
$response_msg .= ' reported down. Their state was not included.';
$response = array('success' => true, 'agent' => sfConfig::get('config_acronym'), 'info' => $response_msg, 'va_down' => $va_down);
}
return $response;
}
public function updateLastMessage($response)
{
$node_name = $this->etva_node->getName();
if (!$response['success']) {
$message = Etva::getLogMessage(array('name' => $node_name, 'info' => $response['message']), EtvaNodePeer::_ERR_CHECK_MDSTAT_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($node_name, 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$msg_i18n = sfContext::getInstance()->getI18N()->__(EtvaNodePeer::_ERR_CHECK_MDSTAT_, array('%name%' => $node_name, '%info%' => $response['message']));
error_log($message);
// send status to mastersite
$apli = new Appliance();
$apli->updateStatusMessage($message);
// mark node with fail
$this->etva_node->setErrorMessage(self::CHECK_MDSTAT, $msg_i18n);
} else {
$this->clearLastMessage($response);
}
}
public function executeJsonImport(sfWebRequest $request)
{
$nid = $request->getParameter('nid');
$import_data = json_decode($request->getParameter('import'), true);
$server = $import_data;
$vnc_keymap = EtvaSettingPeer::retrieveByPk('vnc_keymap');
$server['vnc_keymap'] = $vnc_keymap->getValue();
$server['uuid'] = EtvaServerPeer::generateUUID();
$server['name'] = $import_data['name'];
$server['vm_type'] = $import_data['vm_type'];
$server['ip'] = '000.000.000.000';
$server['boot'] = 'filesystem';
$import_data['uuid'] = $server['uuid'];
$import_data['vnc_keymap'] = $server['vnc_keymap'];
// import validation check
$result = $this->jsonImportCheck($request);
if (!$result['success']) {
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($result);
}
// if is browser request return text renderer
$error = $this->setJsonError($result);
return $this->renderText($error);
}
if (!($etva_node = EtvaNodePeer::retrieveByPK($nid))) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify event log
$node_log = Etva::getLogMessage(array('id' => $nid), EtvaNodePeer::_ERR_NOTFOUND_ID_);
$message = Etva::getLogMessage(array('info' => $node_log), OvfEnvelope_VA::_ERR_IMPORT_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$disks = $import_data['disks'];
$collVgs = array();
foreach ($disks as $id => $info) {
$vg = $info['vg'];
$lv = $info['lv'];
if ($etva_lv = $etva_node->retrieveLogicalvolumeByLv($lv)) {
$msg_type = $is_DiskFile ? EtvaLogicalvolumePeer::_ERR_DISK_EXIST_ : EtvaLogicalvolumePeer::_ERR_LV_EXIST_;
$msg = Etva::getLogMessage(array('name' => $lv), $msg_type);
$msg_i18n = $this->getContext()->getI18N()->__($msg_type, array('%name%' => $lv));
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify system log
$message = Etva::getLogMessage(array('name' => $lv, 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
if (!($etva_vg = $etva_node->retrieveVolumegroupByVg($vg))) {
$msg = Etva::getLogMessage(array('name' => $vg), EtvaVolumegroupPeer::_ERR_NOTFOUND_);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaVolumegroupPeer::_ERR_NOTFOUND_, array('%name%' => $vg));
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify system log
$message = Etva::getLogMessage(array('name' => $lv, 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
// fix lv path
$is_DiskFile = $vg == sfConfig::get('app_volgroup_disk_flag') ? 1 : 0;
$import_data['disks'][$id]['lv'] = $is_DiskFile ? $etva_node->getStoragedir() . '/' . $lv : $lv;
$collVgs[$vg] = $etva_vg;
}
$networks = $import_data['networks'];
$networks_va = $import_data['networks'];
$collNetworks = array();
$i = 0;
// check if networks are available
foreach ($networks as $network) {
if ($etva_vlan = EtvaVlanPeer::retrieveByPk($network['vlan_id'])) {
$import_data['networks'][$i]['network'] = $etva_vlan->getName();
$import_data['networks'][$i]['macaddr'] = $network['mac'];
}
$etva_mac = EtvaMacPeer::retrieveByMac($network['mac']);
/*
* TODO improve this to add Mac Address to the pool
*/
if (!$etva_mac || !$etva_vlan) {
$msg = Etva::getLogMessage(array(), EtvaNetworkPeer::_ERR_);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNetworkPeer::_ERR_, array());
if (!$etva_mac) {
$msg = Etva::getLogMessage(array('%mac%' => $network['mac']), EtvaMacPeer::_ERR_INVALID_MAC_);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaMacPeer::_ERR_INVALID_MAC_, array('%mac%' => $network['mac']));
}
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify event log
$message = Etva::getLogMessage(array('name' => $server['name'], 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
if ($etva_mac->getInUse()) {
$msg = Etva::getLogMessage(array('%name%' => $etva_mac->getMac()), EtvaMacPeer::_ERR_ASSIGNED_);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaMacPeer::_ERR_ASSIGNED_, array('%name%' => $etva_mac->getMac()));
$error = array('success' => false, 'agent' => $etva_node->getName(), 'info' => $msg_i18n, 'error' => $msg_i18n);
//notify event log
$message = Etva::getLogMessage(array('name' => $server['name'], 'info' => $msg), OvfEnvelope_VA::_ERR_IMPORT_);
$this->dispatcher->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$etva_network = new EtvaNetwork();
$etva_network->fromArray($network, BasePeer::TYPE_FIELDNAME);
$collNetworks[] = $etva_network;
$i++;
}
$env = new OvfEnvelope_VA();
$env->fromArray($import_data);
/* get server copy VA server representation */
$params = $env->_VA();
$method = 'vm_ovf_import_may_fork';
$response = $etva_node->soapSend($method, $params);
if (!$response['success']) {
$error_decoded = $response['error'];
$result = $response;
$msg_i18n = $this->getContext()->getI18N()->__(EtvaServerPeer::_ERR_CREATE_, array('%name%' => $server['name'], '%info%' => $error_decoded));
$result['error'] = $msg_i18n;
//notify event log
$message = Etva::getLogMessage(array('name' => $server['name'], 'info' => $response['info']), EtvaServerPeer::_ERR_CREATE_);
$this->dispatcher->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($result);
}
$return = $this->setJsonError($result);
return $this->renderText($return);
}
$response_decoded = (array) $response['response'];
$returned_object = (array) $response_decoded['_obj_'];
$returned_lvs = (array) $returned_object['LVS'];
$collLvs = array();
foreach ($returned_lvs as $disk) {
$disk_array = (array) $disk;
$vg_info = (array) $disk_array[EtvaLogicalvolume::VOLUMEGROUP_MAP];
$vg = $vg_info[EtvaVolumegroup::VG_MAP];
$fake_lv_response = array('success' => true, 'response' => array('_obj_' => $disk_array));
// create logical volume
$etva_lv = new EtvaLogicalvolume();
$etva_lv->setEtvaVolumegroup($collVgs[$vg]);
$lv_va = new EtvaLogicalvolume_VA($etva_lv);
$lv_response = $lv_va->processResponse($etva_node, $fake_lv_response, 'lvcreate');
if (!$lv_response['success']) {
$return = $this->setJsonError($lv_response);
return $this->renderText($return);
}
$collLvs[] = $etva_lv;
}
$etva_server = new EtvaServer();
$etva_server->fromArray($server, BasePeer::TYPE_FIELDNAME);
$user_groups = $this->getUser()->getGroups();
$server_sfgroup = array_shift($user_groups);
//if user has group then put one of them otherwise put DEFAULT GROUP ID
if ($server_sfgroup) {
$etva_server->setsfGuardGroup($server_sfgroup);
} else {
$etva_server->setsfGuardGroup(sfGuardGroupPeer::getDefaultGroup());
}
foreach ($collNetworks as $coll) {
$etva_server->addEtvaNetwork($coll);
}
$i = 0;
foreach ($collLvs as $coll) {
$server_disk = new EtvaServerLogical();
$server_disk->setEtvaLogicalvolume($coll);
$server_disk->setBootDisk($i);
$etva_server->addEtvaServerLogical($server_disk);
$i++;
}
//update some data from agent response
$vm = (array) $returned_object['VM'];
$etva_server->initData($vm);
//$etva_server->setEtvaNode($etva_node);
$etva_server->setEtvaCluster($etva_node->getEtvaCluster());
try {
$etva_server->save();
} catch (Exception $e) {
$msg = $e->getMessage();
$result = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg, 'info' => $msg);
$return = $this->setJsonError($result);
return $this->renderText($return);
}
// assign To etva_node
$etva_server->assignTo($etva_node);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaServerPeer::_OK_CREATE_, array('%name%' => $server['name']));
$message = Etva::getLogMessage(array('name' => $server['name']), EtvaServerPeer::_OK_CREATE_);
$this->dispatcher->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message)));
$result = array('success' => true, 'agent' => $response['agent'], 'insert_id' => $etva_server->getId(), 'response' => $msg_i18n);
$return = json_encode($result);
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
// if is browser request return text renderer
return $this->renderText($return);
}
public function executeJsonRemove(sfWebRequest $request)
{
$sid = $request->getParameter('sid');
$mac = $request->getParameter('macaddr');
if (!($etva_server = EtvaServerPeer::retrieveByPK($sid))) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaServerPeer::_ERR_NOTFOUND_ID_, array('%id%' => $sid));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
//notify system log
$server_log = Etva::getLogMessage(array('id' => $sid), EtvaServerPeer::_ERR_NOTFOUND_ID_);
$message = Etva::getLogMessage(array('name' => $mac, 'info' => $server_log), EtvaNetworkPeer::_ERR_REMOVE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
// if is a CLI soap request return json encoded data
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($error);
}
// if is browser request return text renderer
$error = $this->setJsonError($error);
return $this->renderText($error);
}
$etva_node = $etva_server->getEtvaNode();
$method = 'detach_interface';
$params = array('uuid' => $etva_server->getUuid(), 'macaddr' => $mac);
$response = $etva_node->soapSend($method, $params);
if ($response['success']) {
$response_decoded = (array) $response['response'];
$returned_status = $response_decoded['_okmsg_'];
$etva_server->deleteNetworkByMac($mac);
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNetworkPeer::_OK_REMOVE_, array('%name%' => $mac, '%server%' => $etva_server->getName()));
$result = $response;
$result['response'] = $msg_i18n;
//notify system log
$message = Etva::getLogMessage(array('name' => $mac, 'server' => $etva_server->getName()), EtvaNetworkPeer::_OK_REMOVE_);
$this->dispatcher->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message)));
$return = json_encode($result);
// if the request is made throught soap request...
if (sfConfig::get('sf_environment') == 'soap') {
return $return;
}
// if is browser request return text renderer
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($return);
} else {
$error_decoded = $response['error'];
//$error = 'Interface '.$mac.': '.$error_decoded;
$msg_i18n = $this->getContext()->getI18N()->__(EtvaNetworkPeer::_ERR_REMOVE_, array('%name%' => $mac, '%info%' => $error_decoded));
$response['error'] = $msg_i18n;
//notify system log
$message = Etva::getLogMessage(array('name' => $mac, 'info' => $response['info']), EtvaNetworkPeer::_ERR_REMOVE_);
$this->dispatcher->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$result = $response;
if (sfConfig::get('sf_environment') == 'soap') {
return json_encode($result);
}
$return = $this->setJsonError($result);
return $this->renderText($return);
}
}
public function processResponse($etva_node, $response, $method, $params)
{
$etva_pool = $this->etva_pool;
$pool_name = $etva_pool->getName();
switch ($method) {
case self::POOL_CREATE:
$msg_ok_type = EtvaPoolPeer::_OK_CREATE_;
$msg_err_type = EtvaPoolPeer::_ERR_CREATE_;
break;
case self::POOL_DESTROY:
$msg_ok_type = EtvaPoolPeer::_OK_REMOVE_;
$msg_err_type = EtvaPoolPeer::_ERR_REMOVE_;
break;
case self::POOL_RELOAD:
$msg_ok_type = EtvaPoolPeer::_OK_RELOAD_;
$msg_err_type = EtvaPoolPeer::_ERR_RELOAD_;
break;
}
if (!$response['success']) {
$result = $response;
$message = Etva::getLogMessage(array('name' => $pool_name, 'info' => $response['info']), $msg_err_type);
$msg_i18n = sfContext::getInstance()->getI18N()->__($msg_err_type, array('%name%' => $pool_name, '%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;
}
if ($method == self::POOL_CREATE) {
// save object
$etva_pool->save();
// create relation to node
$etva_nodepool = new EtvaNodePool();
$etva_nodepool->setNodeId($etva_node->getId());
$etva_nodepool->setPoolId($etva_pool->getId());
$etva_nodepool->save();
}
$pool_id = $etva_pool->getId();
$etva_cluster = $etva_node->getEtvaCluster();
$error_messages = array();
if ($etva_pool->getShared()) {
// send call to all nodes
$bulk_responses = $etva_cluster->soapSend($method, $params, $etva_node);
//error_log(print_r($bulk_responses,true));
foreach ($bulk_responses as $node_id => $node_response) {
$node = EtvaNodePeer::retrieveByPK($node_id);
if ($node_response['success']) {
if ($method == self::POOL_CREATE || $method == self::POOL_RELOAD) {
if (!EtvaNodePoolPeer::retrieveByPK($node_id, $pool_id)) {
// create relation to node
$etva_nodepool = new EtvaNodePool();
$etva_nodepool->setNodeId($node_id);
$etva_nodepool->setPoolId($pool_id);
$etva_nodepool->save();
$node->clearErrorMessage(self::POOL_CREATE);
if ($method == self::POOL_RELOAD) {
// clear error message for reload
$node->clearErrorMessage($method);
}
}
}
} else {
$message = Etva::getLogMessage(array('name' => $pool_name, 'info' => $node_response['info']), $msg_err_type);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($node_response['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$msg_i18n = sfContext::getInstance()->getI18N()->__($msg_err_type, array('%name%' => $pool_name, '%info%' => $node_response['info']));
array_push($error_messages, array('success' => false, 'agent' => $node_response['agent'], 'response' => $msg_i18n));
// mark node with fail
$node->setErrorMessage($method, $msg_i18n);
}
}
}
if ($method == self::POOL_DESTROY) {
// remove object
$etva_pool->delete();
}
$response_decoded = (array) $response['response'];
$returned_object = (array) $response_decoded['_obj_'];
$message = Etva::getLogMessage(array('name' => $pool_name), $msg_ok_type);
$msg_i18n = sfContext::getInstance()->getI18N()->__($msg_ok_type, array('%name%' => $pool_name));
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($response['agent'], 'event.log', array('message' => $message)));
$result = array('success' => true, 'agent' => $etva_node->getName(), 'response' => $msg_i18n, 'errors' => $error_messages);
return $result;
}
/**
* Perform update on table setting
*
* @param string $param parameter name to perform operation
* @param string $value value for the $param
*
*/
public function executeJsonUpdateSetting(sfWebRequest $request)
{
$isAjax = $request->isXmlHttpRequest();
if (!$isAjax) {
return $this->redirect('@homepage');
}
$settings = $request->getParameter('settings');
$settings_decoded = json_decode($settings, true);
$force = $request->getParameter('force');
$networks = $request->getParameter('networks');
$network_decoded = json_decode($networks, true);
if ($networks) {
$etva_data = Etva::getEtvaModelFile();
$etvamodel = $etva_data['model'];
/*
* get nodes....and call node agent script
*/
$remote_errors = array();
$change_networks = 0;
$cm_networks = new SystemNetworkUtil();
$interfaces_devices = sfConfig::get('app_device_interfaces');
$devices = $interfaces_devices[$etvamodel];
$cm_networks->loadCMNetworks($devices);
$sys_networks = $cm_networks->getNetworks();
if ($etvamodel == 'standard') {
$local = $network_decoded['lan'];
$remote = $network_decoded['cm_management'];
$cm_ip = $remote['ip'];
$local_net = new SystemNetwork();
$local_net->fromArray($local);
$remote_net = new SystemNetwork();
$remote_net->fromArray($remote);
$sys_lan_if = $devices['lan'];
$sys_manag_if = $devices['cm_management'];
$sys_lan_net = $sys_networks[$sys_lan_if];
$sys_manag_net = $sys_networks[$sys_manag_if];
if (!$local_net->equals($sys_lan_net) || !$remote_net->equals($sys_manag_net)) {
$change_networks = 1;
}
} else {
$local = $network_decoded['cm_management'];
$remote = array();
$cm_ip = $local['ip'];
$local_net = new SystemNetwork();
$local_net->fromArray($local);
$sys_manag_if = $devices['cm_management'];
$sys_manag_net = $sys_networks[$sys_manag_if];
if (!$local_net->equals($sys_manag_net)) {
$change_networks = 1;
}
}
if ($change_networks) {
$criteria = new Criteria();
$etva_nodes = EtvaNodePeer::doSelect($criteria);
if (!$force) {
// check for nodes state if not force
foreach ($etva_nodes as $etva_node) {
$node_state = $etva_node->getState();
if (!$node_state) {
$remote_errors[] = Etva::getLogMessage(array('agent' => $etva_node->getName(), 'msg' => 'Down'), Etva::_AGENT_MSG_);
}
/*
* check if servers has an MA and are down...send error
*/
$etva_servers = $etva_node->getEtvaServers();
foreach ($etva_servers as $etva_server) {
$server_ma = $etva_server->getAgentTmpl();
$server_state = $etva_server->getState();
if (!$server_state && $server_ma) {
$remote_errors[] = Etva::getLogMessage(array('agent' => $etva_server->getName(), 'msg' => 'Down'), Etva::_AGENT_MSG_);
}
}
}
//end foreach
}
if ($remote_errors && !$force) {
$msg = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'action' => 'check_nodes', 'info' => implode('<br>', $remote_errors), 'error' => implode(' ', $remote_errors));
$error = $this->setJsonError($msg);
return $this->renderText($error);
}
if ($etvamodel != 'standard') {
// only if not standard version
/*
*
* check ISO DIR in use
*
*/
$isosdir = sfConfig::get("config_isos_dir");
$criteria = new Criteria();
$criteria->add(EtvaServerPeer::LOCATION, "%{$isosdir}%", Criteria::LIKE);
$criteria->add(EtvaServerPeer::VM_STATE, 'running');
$servers_running_iso = EtvaServerPeer::doSelect($criteria);
foreach ($servers_running_iso as $server) {
$remote_errors[] = $this->getContext()->getI18N()->__(EtvaServerPeer::_CDROM_INUSE_, array('%name%' => $server->getName()));
}
if ($remote_errors) {
$message = Etva::getLogMessage(array('info' => ETVA::_CDROM_INUSE_), ETVA::_ERR_ISODIR_INUSE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$i18n_br_sep = implode('<br>', $remote_errors);
$i18n_sp_sep = implode(' ', $remote_errors);
//$iso_br_msg = Etva::getLogMessage(array('info'=>'<br>'.$br_sep), ETVA::_ERR_ISODIR_INUSE_);
$i18n_iso_br_msg = $this->getContext()->getI18N()->__(ETVA::_ERR_ISODIR_INUSE_, array('%info%' => '<br>' . $i18n_br_sep));
//$iso_sp_msg = Etva::getLogMessage(array('info'=>$sp_sep), ETVA::_ERR_ISODIR_INUSE_);
$i18n_iso_sp_msg = $this->getContext()->getI18N()->__(ETVA::_ERR_ISODIR_INUSE_, array('%info%' => $i18n_sp_sep));
$msg = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'info' => $i18n_iso_br_msg, 'error' => $i18n_iso_sp_msg);
$error = $this->setJsonError($msg);
return $this->renderText($error);
}
/*
* if all ok so far.....send nodes umount ISO DIR
*/
foreach ($etva_nodes as $etva_node) {
$node_va = new EtvaNode_VA($etva_node);
$response = array('success' => true);
if ($force && $etva_node->getState()) {
$response = $node_va->send_umount_isosdir();
}
$success = $response['success'];
if (!$success) {
$node_msg = Etva::getLogMessage(array('name' => $response['agent'], 'info' => $response['error']), EtvaNodePeer::_ERR_ISODIR_UMOUNT_);
$remote_errors[] = $node_msg;
$message = Etva::getLogMessage(array('info' => $node_msg), EtvaSettingPeer::_ERR_SETTING_REMOTE_CONNECTIVITY_SAVE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
}
}
if (!empty($remote_errors)) {
$msg = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'info' => implode('<br>', $remote_errors), 'error' => implode(' ', $remote_errors));
$error = $this->setJsonError($msg);
return $this->renderText($error);
}
}
/*
* update using local script
*/
$local_updated = $this->localUpdate($local);
if (!$local_updated) {
$intf = $local['if'];
$msg_i18n = $this->getContext()->getI18N()->__(SystemNetwork::_ERR_NOTFOUND_INTF_, array('%name%' => $intf, '%info%' => ''));
$info = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n);
$error = $this->setJsonError($info);
return $this->renderText($error);
}
if (empty($remote_errors)) {
foreach ($etva_nodes as $etva_node) {
// send update to nodes if force
$etva_node->setSoapTimeout(5);
$remote_updated = $this->remoteUpdate($etva_node, $remote, $cm_ip);
if ($remote_updated !== true) {
if ($remote_updated === false) {
$intf = $remote['intf'];
$msg_i18n = $this->getContext()->getI18N()->__(SystemNetwork::_ERR_NOTFOUND_INTF_, array('%name%' => $intf, '%info%' => ''));
$remote_errors[] = $msg_i18n;
//$error = array('success'=>false,'agent'=>sfConfig::get('config_acronym'),'error'=>$msg_i18n);
} else {
$agent_msg = Etva::getLogMessage(array('agent' => $remote_updated['agent'], 'msg' => $remote_updated['error']), Etva::_AGENT_MSG_);
$message = Etva::getLogMessage(array('info' => $agent_msg), EtvaSettingPeer::_ERR_SETTING_REMOTE_CONNECTIVITY_SAVE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$remote_errors[] = $agent_msg;
}
}
/*
* update MA if any...
*
*/
$etva_servers = $etva_node->getEtvaServers();
foreach ($etva_servers as $etva_server) {
$server_ma = $etva_server->getAgentTmpl();
$server_state = $etva_server->getState();
if ($server_state && $server_ma) {
$aux_ip = $etva_server->getIp();
$etva_server->setSoapTimeout(5);
$remote_updated = $this->remoteUpdate($etva_server, $remote, $cm_ip);
if ($remote_updated === false) {
$intf = $remote['intf'];
$msg_i18n = $this->getContext()->getI18N()->__(SystemNetwork::_ERR_NOTFOUND_INTF_, array('%name%' => $intf, '%info%' => ''));
$remote_errors[] = $msg_i18n;
//$error = array('success'=>false,'agent'=>sfConfig::get('config_acronym'),'error'=>$msg_i18n);
} else {
$agent_msg = Etva::getLogMessage(array('agent' => $remote_updated['agent'], 'msg' => $remote_updated['error']), Etva::_AGENT_MSG_);
$message = Etva::getLogMessage(array('info' => $agent_msg), EtvaSettingPeer::_ERR_SETTING_REMOTE_CONNECTIVITY_SAVE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
$remote_errors[] = $agent_msg;
}
}
}
}
}
if (!empty($remote_errors)) {
$msg = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'info' => implode('<br>', $remote_errors), 'error' => implode(' ', $remote_errors));
$error = $this->setJsonError($msg);
return $this->renderText($error);
}
}
// end if changed networks
}
foreach ($settings_decoded as $data) {
$param = $data['param'];
$value = $data['value'];
if (!($etva_setting = EtvaSettingPeer::retrieveByPk($param))) {
$msg_i18n = $this->getContext()->getI18N()->__(EtvaSettingPeer::_ERR_NOTFOUND_PARAM_, array('%id%' => $param));
$info = array('success' => false, 'error' => $msg_i18n);
$error = $this->setJsonError($info);
return $this->renderText($error);
}
$etva_setting->setValue($value);
switch ($param) {
case 'vnc_keymap':
if ($etva_setting->saveVNCkeymap()) {
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $etva_setting->getValue()), EtvaSettingPeer::_OK_VNCKEYMAP_CHANGE_))));
} else {
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $value), EtvaSettingPeer::_ERR_VNCKEYMAP_CHANGE_), 'priority' => EtvaEventLogger::ERR)));
}
break;
default:
try {
$etva_setting->save();
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $etva_setting->getParam(), 'value' => $etva_setting->getValue()), EtvaSettingPeer::_OK_SETTING_CHANGE_))));
} catch (Exception $e) {
//notify system log
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => Etva::getLogMessage(array('name' => $value), EtvaSettingPeer::_ERR_SETTING_CHANGE_), 'priority' => EtvaEventLogger::ERR)));
}
break;
}
}
// end foreach
$msg_i18n = $this->getContext()->getI18N()->__(EtvaSettingPeer::_OK_SETTING_CONNECTIVITY_SAVE_);
$message = EtvaSettingPeer::_OK_SETTING_CONNECTIVITY_SAVE_;
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message)));
$info = array('success' => true, 'agent' => sfConfig::get('config_acronym'), 'response' => $msg_i18n);
return $this->renderText(json_encode($info));
}
