protected function execute($arguments = array(), $options = array())
{
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$con = $databaseManager->getDatabase($options['connection'])->getConnection();
// add networks from config file to the givel cluster (optional)
$flag = 0;
//write or not to stdout
if ($options['cluster_id']) {
$cluster_id = $options['cluster_id'];
$flag = 1;
} else {
$default_cluster = EtvaClusterPeer::retrieveDefaultCluster();
$cluster_id = $default_cluster->getId();
}
error_log("LOADCONFTASK[INFO] Loading config file");
error_log($cluster_id);
$model = Etva::getEtvaModelFile();
$networks = isset($model['networks']) ? $model['networks'] : $model[ucfirst('networks')];
if ($this->initialize_networks($networks, $cluster_id)) {
if ($flag == 0) {
echo "Done!\n";
}
return 1;
} else {
if ($flag == 0) {
echo "Failed!\n";
}
return 0;
}
}
public static function checkDbVersion()
{
$etva_data = Etva::getEtvaModelFile();
$curr = $etva_data['dbversion'];
$min = floatval(sfConfig::get('app_dbrequired'));
if ($curr < $min) {
return "Incompatible database version. Please upgrade.";
} else {
return "OK";
}
}
public function Appliance($sn = null)
{
$etva_data = Etva::getEtvaModelFile();
isset($etva_data[self::CONF_SITE_NAME]) ? $this->site_url = $etva_data[self::CONF_SITE_NAME] : ($this->site_url = '');
// set temporary DB dump to fixtures/backup/DB_FILE
$this->tmp_db_filename = sfConfig::get('sf_data_dir') . '/fixtures/backup/' . self::DB_FILE;
// set archive dir to uploads/backup
$this->archive_base_dir = sfConfig::get('sf_data_dir') . '/backup';
if ($sn) {
$this->serial_number = $sn;
}
/*
* get serial number from DB if not set
*/
if (!$this->serial_number) {
$pk = 'serial_number';
$sn_setting = EtvaSettingPeer::retrieveByPk($pk);
if (!$sn_setting) {
$sn_setting = new EtvaSetting();
}
$this->serial_number = $sn_setting->getValue();
}
}
public function executeIndex(sfWebRequest $request)
{
// if(update::checkDbVersion() == 0){
//
// }else{
//
// }
$this->node_list = EtvaNodePeer::doSelect(new Criteria());
$this->node_form = new EtvaNodeForm();
$etva_data = Etva::getEtvaModelFile();
$this->etvamodel = $etva_data['model'];
if ($this->getUser()->isFirstRequest()) {
$etva_data = Etva::getEtvaModelFile();
$etvamodel = $etva_data['model'];
// remove session macs for cleanup the wizard
$this->getUser()->getAttributeHolder()->remove('etvamodel');
// store the new mac back into the session
$this->getUser()->setAttribute('etvamodel', $etvamodel);
$this->getUser()->isFirstRequest(false);
}
//$action = $this->getController()->getAction('node','bulkUpdateState');
//$result = $action->executeBulkUpdateState($this->request);
}
public function initialize(EtvaNode $etva_node, $devs, $force_regist = false)
{
$etva_cluster = $etva_node->getEtvaCluster();
$volumegroup_names = array();
$errors = array();
/*
* check shared vgs consistency (applies only for enterprise)
*/
$etva_data = Etva::getEtvaModelFile();
/*$etvamodel = $etva_data['model'];
$consist = 1;
if($etvamodel != 'standard') $consist = $this->check_shared_consistency($etva_node,$devs);*/
$check_res = $this->check_consistency($etva_node, $devs);
if (!$check_res['success']) {
$errors = $check_res['errors'];
$inconsistent_message = Etva::getLogMessage(array('info' => ''), EtvaPhysicalvolumePeer::_ERR_INCONSISTENT_);
$etva_node->setErrorMessage(self::PVINIT);
$message = Etva::getLogMessage(array('info' => $inconsistent_message), EtvaPhysicalvolumePeer::_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);
}
/*if(!$consist){
$errors = $this->missing_pvs[$etva_node->getId()];
$inconsistent_message = Etva::getLogMessage(array('info'=>''), EtvaPhysicalvolumePeer::_ERR_INCONSISTENT_);
$etva_node->setErrorMessage(self::PVINIT);
$message = Etva::getLogMessage(array('info'=>$inconsistent_message), EtvaPhysicalvolumePeer::_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);
}*/
$physical_names = array();
foreach ($devs as $dev => $devInfo) {
$dev_info = (array) $devInfo;
$dev_type = $dev_info[EtvaPhysicalvolume::STORAGE_TYPE_MAP];
$dev_device = $dev_info[EtvaPhysicalvolume::DEVICE_MAP];
//error_log(sprintf("node name=%s id=%d device=%s uuid=%s type=%s",$etva_node->getName(),$etva_node->getId(),$dev_device,$dev_info[EtvaPhysicalvolume::UUID_MAP],$dev_type));
if ($dev_type == EtvaPhysicalvolume::STORAGE_TYPE_LOCAL_MAP) {
$etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByNodeTypeDevice($etva_node->getId(), $dev_type, $dev_device);
} else {
if (isset($dev_info[EtvaPhysicalvolume::UUID_MAP])) {
$dev_uuid = $dev_info[EtvaPhysicalvolume::UUID_MAP];
$etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByUUID($dev_uuid);
} else {
$dev_info[EtvaPhysicalvolume::UUID_MAP] = '';
// clean uuid
$etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByNodeTypeDevice($etva_node->getId(), $dev_type, $dev_device);
}
if (!$etva_physicalvol) {
$etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByNodeTypeDevice($etva_node->getId(), $dev_type, $dev_device);
}
if (!$etva_physicalvol) {
$etva_physicalvol = EtvaPhysicalvolumePeer::retrieveByClusterTypeUUIDDevice($etva_node->getClusterId(), $dev_type, $dev_info[EtvaPhysicalvolume::UUID_MAP], $dev_device);
}
}
if ($force_regist && !$etva_physicalvol) {
// no pv in db... and force registration ... so create new one
$etva_node_physicalvol = new EtvaNodePhysicalvolume();
$etva_physicalvol = new EtvaPhysicalvolume();
} else {
if ($etva_physicalvol) {
//if pv already in DB we need to make sure if already exists association with node. if not create new one
$etva_node_physicalvol = EtvaNodePhysicalvolumePeer::retrieveByPK($etva_node->getId(), $etva_physicalvol->getId());
if (!$etva_node_physicalvol) {
$etva_node_physicalvol = new EtvaNodePhysicalvolume();
}
}
}
if ($etva_physicalvol) {
$etva_physicalvol->initData($dev_info);
$etva_physicalvol->setEtvaCluster($etva_cluster);
$etva_node_physicalvol->setEtvaPhysicalvolume($etva_physicalvol);
$etva_node_physicalvol->setEtvaNode($etva_node);
$etva_node_physicalvol->setDevice($dev_device);
$etva_node_physicalvol->save();
$physical_names[] = $etva_physicalvol->getName();
}
// TODO treat ignoring cases
}
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_PVS);
}
$etva_node->clearErrorMessage(self::PVINIT);
$message = Etva::getLogMessage(array('info' => implode(', ', $physical_names)), EtvaPhysicalvolumePeer::_OK_SOAPUPDATE_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($etva_node->getName(), 'event.log', array('message' => $message)));
return array('success' => true, 'response' => $physical_names);
}
}
private function loadModelConf()
{
$this->etva_model = Etva::getEtvaModelFile();
}
public function initialize($data)
{
$uuid = $data['uuid'];
$etva_data = Etva::getEtvaModelFile();
if (!$etva_data) {
$error_msg = 'Could not process etva-model.conf';
$error = array('success' => false, 'error' => $error_msg);
//notify system log
$message = Etva::getLogMessage(array('name' => $data['name'], 'info' => $error_msg), EtvaNodePeer::_ERR_SOAPINIT_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
return $error;
}
$etvamodel = $etva_data['model'];
$c = new Criteria();
$c->add(EtvaNodePeer::UUID, $uuid);
$etva_node = EtvaNodePeer::doSelectOne($c);
if ($etva_node) {
if ($etva_node->getState() < EtvaNode::NODE_INACTIVE) {
// dont touch
//$data['state'] = $etva_node->getState();
$data['state'] = $this->calcState($etva_node, EtvaNode::NODE_ACTIVE);
}
if (!isset($data['isSpareNode'])) {
$data['isSpareNode'] = $etva_node->getIssparenode() ? 1 : 0;
}
if (!isset($data['fencingconf'])) {
$data['fencingconf'] = $etva_node->getFencingconf();
}
$data['cluster_id'] = $etva_node->getClusterId();
$node_initialize = $etva_node->getInitialize();
$data['initialize'] = $node_initialize;
if (empty($node_initialize)) {
$data['initialize'] = self::INITIALIZE_PENDING;
}
if ($etvamodel == 'standard') {
$data['initialize'] = self::INITIALIZE_OK;
} else {
if ($node_initialize != self::INITIALIZE_OK) {
return array('success' => true);
}
}
$data['id'] = $etva_node->getId();
/*
* calculate free mem
*/
$etva_node->setMemtotal($data['memtotal']);
$etva_node->updateMemFree();
$data['memfree'] = $etva_node->getMemfree();
$uuid = $etva_node->getUuid();
$form = new EtvaNodeForm($etva_node);
} else {
/*
* add default cluster ID to node
*/
if (!($default_cluster = EtvaClusterPeer::retrieveDefaultCluster())) {
$error_msg = sprintf('Default Object etva_cluster does not exist ');
$error = array('success' => false, 'error' => $error_msg);
//notify system log
$cluster_message = Etva::getLogMessage(array('info' => $error_msg), EtvaClusterPeer::_ERR_DEFAULT_CLUSTER_);
$message = Etva::getLogMessage(array('name' => $data['name'], 'info' => $cluster_message), EtvaNodePeer::_ERR_SOAPINIT_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
return $error;
}
$data['cluster_id'] = $default_cluster->getId();
$form = new EtvaNodeForm();
$uuid = EtvaNodePeer::generateUUID();
$data['initialize'] = self::INITIALIZE_PENDING;
if ($etvamodel == 'standard') {
$data['initialize'] = self::INITIALIZE_OK;
}
/*
* calculate free mem
*/
$etva_node = new EtvaNode();
$etva_node->setMemtotal($data['memtotal']);
$etva_node->updateMemFree();
$etva_node->setClusterId($default_cluster->getId());
$data['memfree'] = $etva_node->getMemfree();
$data['uuid'] = $uuid;
}
$this->clearLastMessage();
$result = $this->processNodeForm($data, $form);
if (!$result['success']) {
return $result;
}
// reset guest agent info
$this->reset_gas_info($etva_node);
/*
*
* check if has restore to perform....
*/
$apli = new Appliance();
$action = $apli->getStage(Appliance::RESTORE_STAGE);
if ($action) {
$backup_url = $apli->get_backupconf_url(Appliance::VA_ARCHIVE_FILE, $uuid, 'VA');
if ($backup_url) {
$result['reset'] = 1;
$result['backup_url'] = $backup_url;
/*
* send pvs, vgs, lvs
*/
$node_devs = $etva_node->getEtvaNodePhysicalvolumesJoinEtvaPhysicalvolume();
$devs_va = array();
foreach ($node_devs as $data) {
$dev = $data->getEtvaPhysicalvolume();
$devs_va[] = $dev->_VA();
}
$result['pvs'] = $devs_va;
$node_vgs = $etva_node->getEtvaNodeVolumegroupsJoinEtvaVolumegroup();
$vgs_va = array();
foreach ($node_vgs as $data) {
$vg = $data->getEtvaVolumegroup();
$vgs_va[] = $vg->_VA();
}
$result['vgs'] = $vgs_va;
$node_lvs = $etva_node->getEtvaNodeLogicalvolumesJoinEtvaLogicalvolume();
$lvs_va = array();
foreach ($node_lvs as $data) {
$lv = $data->getEtvaLogicalvolume();
$lvs_va[] = $lv->_VA();
}
$result['lvs'] = $lvs_va;
}
$apli->setStage(Appliance::RESTORE_STAGE, Appliance::VA_INIT);
}
return $result;
}
/**
* Used to process soap requests => updateVirtAgentVgs
*
* Updates volume group info sent by virt Agent
* The request should be made throught soapapi
*
* Replies with succcess
*
* $request may contain the following keys:
* - uid: uid (virtAgent sending request uid)
* - vgs (object containing volumes info)
* @return array array(success=>true)
*/
public function executeSoapUpdate(sfWebRequest $request)
{
if (sfConfig::get('sf_environment') == 'soap') {
$vgs = $request->getParameter('vgs');
// check node ID correspondig to the uid given
$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'));
$error = array('success' => false, 'error' => $error_msg);
//notify event log
$node_message = Etva::getLogMessage(array('name' => $request->getParameter('uuid')), EtvaNodePeer::_ERR_NOTFOUND_UUID_);
$message = Etva::getLogMessage(array('info' => $node_message), EtvaVolumegroupPeer::_ERR_SOAPUPDATE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
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;
}
/*
* check node cluster ID
*/
if (!($etva_cluster = $etva_node->getEtvaCluster())) {
$error_msg = sprintf('Object etva_cluster does not exist for node %s', $etva_node->getName());
$error = array('success' => false, 'error' => $error_msg);
//notify event log
$cluster_message = Etva::getLogMessage(array('info' => $error_msg), EtvaClusterPeer::_ERR_CLUSTER_);
$message = Etva::getLogMessage(array('info' => $cluster_message), EtvaVolumegroupPeer::_ERR_SOAPUPDATE_);
$this->dispatcher->notify(new sfEvent(sfConfig::get('config_acronym'), 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
return $error;
}
$etva_data = Etva::getEtvaModelFile();
$etvamodel = $etva_data['model'];
$force_regist = false;
// for model standard, if vgs initialize then force registration
if ($etvamodel == 'standard' && !$etva_node->hasVgs()) {
$force_regist = true;
}
error_log("EtvaVolumegroup soapUpdate force_regist=" . $force_regist . " etvamodel=" . $etvamodel . " hasVgs=" . $etva_node->hasVgs());
//error_log(print_r($vgs,true));
/*
* send volume group to VA
*/
$vg_va = new EtvaVolumegroup_VA();
$response = $vg_va->initialize($etva_node, $vgs, $force_regist);
return $response;
}
}
/**
* 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
}
/**
* 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));
}
