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 executeNetworks(sfWebRequest $request)
{
$this->network_form = new EtvaNetworkForm();
$this->network_tableMap = EtvaNetworkPeer::getTableMap();
$this->vlan_tableMap = EtvaVlanPeer::getTableMap();
}
public function executeJsonGridNoPager($request)
{
$isAjax = $request->isXmlHttpRequest();
if (!$isAjax) {
return $this->redirect('@homepage');
}
$sid = $this->getRequestParameter('sid');
if ($sid) {
$server = EtvaServerPeer::retrieveByPK($sid);
$cid = $server->getClusterId();
} else {
// get cluster id
$cid = $this->getRequestParameter('cid');
if (!$cid) {
$etva_cluster = EtvaClusterPeer::retrieveDefaultCluster();
$cid = $etva_cluster->getId();
}
}
//Get networks from cluster
$c_vlan = new Criteria();
$c_vlan->add(EtvaVlanPeer::CLUSTER_ID, $cid);
$etva_vlans = EtvaVlanPeer::doSelect($c_vlan);
//get networks with server
$c = new Criteria();
$vlan_flag = false;
$server_flag = false;
$query = $this->getRequestParameter('query') ? json_decode($this->getRequestParameter('query'), true) : array();
foreach ($query as $key => $val) {
$column = EtvaNetworkPeer::translateFieldName(sfInflector::camelize($key), BasePeer::TYPE_PHPNAME, BasePeer::TYPE_COLNAME);
if ($key == 'vlan_id') {
$vlan_flag = true;
}
if ($key == 'server_id') {
$server_flag = true;
}
$c->add($column, $val);
}
//error_log($c->toString());
//get vlans from cluster
if (!$vlan_flag && !$server_flag) {
// && !$server_flag && $cid){
//error_log('!(!$vlan_flag && !$server_flag)');
foreach ($etva_vlans as $etva_vlan) {
if ($this->getRequestParameter('query')) {
$c->addOr(EtvaNetworkPeer::VLAN_ID, $etva_vlan->getId());
} else {
$c->addAnd(EtvaNetworkPeer::VLAN_ID, $etva_vlan->getId());
}
}
}
// add sort criteria to sort elements
$this->addSortCriteria($c);
// add server criteria
$this->addServerCriteria($c);
//error_log($c->toString());
$etva_network_list = EtvaNetworkPeer::doSelectJoinEtvaServer($c);
$elements = array();
$i = 0;
foreach ($etva_network_list as $item) {
$etva_server = $item->getEtvaServer();
$etva_vlan = $item->getEtvaVlan();
if ($etva_server && $etva_vlan) {
$etva_server_name = $etva_server->getName();
$etva_server_type = $etva_server->getVmType();
$etva_vm_state = $etva_server->getVmState();
$etva_vlan_name = $etva_vlan->getName();
$elements[$i] = $item->toArray();
$elements[$i]['ServerName'] = $etva_server_name;
$elements[$i]['VmType'] = $etva_server_type;
$elements[$i]['Vlan'] = $etva_vlan_name;
$elements[$i]['Vm_state'] = $etva_vm_state;
$etva_node = $etva_server->getEtvaNode();
if ($etva_node) {
$etva_node_name = $etva_node->getName();
$elements[$i]['NodeName'] = $etva_node_name;
$elements[$i]['NodeId'] = $etva_node->getId();
}
$i++;
}
}
$final = array('total' => count($etva_network_list), 'data' => $elements);
$result = json_encode($final);
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($result);
}
function toArray()
{
$result = array('IntfModel' => $this->type);
if ($this->address) {
$result['Mac'] = $this->address;
}
if ($this->network) {
if ($etva_vlan = EtvaVlanPeer::retrieveByName($this->network)) {
$result['Vlan'] = $etva_vlan->getName();
$result['VlanId'] = $etva_vlan->getId();
}
}
return $result;
}
public function check_nics_availability($etva_node, $networks, $method)
{
$etva_server = $this->etva_server;
$collNetworks = array();
// check if networks are available
foreach ($networks as $network) {
$etva_vlan = EtvaVlanPeer::retrieveByPk($network['vlan_id']);
$etva_mac = EtvaMacPeer::retrieveByMac($network['mac']);
if (!$etva_mac || !$etva_vlan) {
$msg = Etva::getLogMessage(array(), EtvaNetworkPeer::_ERR_);
$msg_i18n = sfContext::getInstance()->getI18N()->__(EtvaNetworkPeer::_ERR_, array());
$error = array('success' => false, 'agent' => $etva_node->getName(), 'error' => $msg_i18n);
//notify event log
$message = Etva::getLogMessage(array('name' => $etva_server->getName(), 'info' => $msg), EtvaServerPeer::_ERR_CREATE_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
return $error;
}
if ($method == self::SERVER_CREATE && $etva_mac->getInUse()) {
$msg = Etva::getLogMessage(array('name' => $etva_mac->getMac()), EtvaMacPeer::_ERR_ASSIGNED_);
$msg_i18n = sfContext::getInstance()->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' => $etva_server->getName(), 'info' => $msg), EtvaServerPeer::_ERR_CREATE_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($error['agent'], 'event.log', array('message' => $message, 'priority' => EtvaEventLogger::ERR)));
return $error;
}
$etva_network = new EtvaNetwork();
$etva_network->fromArray($network, BasePeer::TYPE_FIELDNAME);
$collNetworks[] = $etva_network;
}
$this->collNetworks = $collNetworks;
return array('success' => true);
}
/**
* 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
}
