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
$nid = $arguments['id'];
$this->log("[INFO] node check id={$nid}");
if (!($etva_node = EtvaNodePeer::retrieveByPK($nid))) {
$msg_i18n = $context->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $nid));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
} else {
$etva_node_va = new EtvaNode_VA($etva_node);
$response = $etva_node_va->checkState();
if (!$response['success']) {
$this->log("[ERROR] " . $response['error']);
} else {
$this->log("[INFO] " . $response['response']);
}
return $response;
}
}
protected function execute($arguments = array(), $options = array())
{
// Context
$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
// server id
$server = $arguments['server'];
$this->log("[INFO] Shutdown server with '{$server}'");
$etva_server = EtvaServerPeer::retrieveByPK($server);
if (!$etva_server) {
$etva_server = EtvaServerPeer::retrieveByUuid($server);
}
if (!$etva_server) {
$etva_server = EtvaServerPeer::retrieveByName($server);
}
if (!$etva_server) {
$msg_i18n = $context->getI18N()->__(EtvaServerPeer::_ERR_NOTFOUND_, array('name' => $server));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
} else {
if ($nid = $options['node']) {
$etva_node = EtvaNodePeer::retrieveByPK($nid);
} else {
$etva_node = $etva_server->getEtvaNode();
}
if (!$etva_node) {
//notify event log
$msg_i18n = Etva::makeNotifyLogMessage(sfConfig::get('config_acronym'), EtvaNodePeer::_ERR_NOTFOUND_ID_, array('id' => $nid), EtvaServerPeer::_ERR_STOP_, array('name' => $server));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
$destroy = $options['destroy'] ? 1 : 0;
$force = $options['force'] ? 1 : 0;
$extra = array('destroy' => $destroy, 'force' => $force);
$server_va = new EtvaServer_VA($etva_server);
$response = $server_va->send_stop($etva_node, $extra);
if ($response['success']) {
$this->log("[INFO] " . $response['response']);
} else {
$this->log("[ERROR] " . $response['error']);
}
return $response;
}
}
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;
}
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 static function getOrElectNodeFromArray($arguments)
{
// get parameters
$nid = isset($arguments['node']) ? $arguments['node'] : null;
$cid = isset($arguments['cluster']) ? $arguments['cluster'] : null;
$level = isset($arguments['level']) ? $arguments['level'] : null;
$vg = isset($arguments['volumegroup']) ? $arguments['volumegroup'] : null;
$dev = isset($arguments['device']) ? $arguments['device'] : null;
$lv = isset($arguments['logicalvolume']) ? $arguments['logicalvolume'] : null;
// check level - back compatibility
if (!$level) {
$level = 'node';
}
if ($level == 'cluster') {
$etva_cluster = EtvaClusterPeer::retrieveByPK($cid);
return EtvaNode::getFirstActiveNode($etva_cluster);
} elseif ($level == 'node') {
$etva_node = EtvaNodePeer::retrieveByPK($nid);
if ($lv) {
$c = new Criteria();
$c->add(EtvaLogicalvolumePeer::STORAGE_TYPE, EtvaLogicalvolume::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL);
$etva_lv = EtvaLogicalvolumePeer::retrieveByLv($lv, $c);
return $etva_lv ? EtvaNodePeer::ElectNode($etva_node) : $etva_node;
} elseif ($dev) {
$c = new Criteria();
$c->add(EtvaPhysicalvolumePeer::STORAGE_TYPE, EtvaPhysicalvolume::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL);
$etva_pv = EtvaPhysicalvolumePeer::retrieveByDevice($dev, $c);
return $etva_pv ? EtvaNodePeer::ElectNode($etva_node) : $etva_node;
} elseif ($vg) {
$c = new Criteria();
$c->add(EtvaVolumeGroupPeer::STORAGE_TYPE, EtvaVolumeGroup::STORAGE_TYPE_LOCAL_MAP, Criteria::ALT_NOT_EQUAL);
$etva_vg = EtvaVolumegroupPeer::retrieveByVg($vg, $c);
return $etva_vg ? EtvaNodePeer::ElectNode($etva_node) : $etva_node;
} else {
return $etva_node;
}
}
}
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);
}
protected function execute($arguments = array(), $options = array())
{
// Context
$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
// server id
$server = $arguments['server'];
$this->log("[INFO] Start server with '{$server}'");
$etva_server = EtvaServerPeer::retrieveByPK($server);
if (!$etva_server) {
$etva_server = EtvaServerPeer::retrieveByUuid($server);
}
if (!$etva_server) {
$etva_server = EtvaServerPeer::retrieveByName($server);
}
if (!$etva_server) {
$msg_i18n = $context->getI18N()->__(EtvaServerPeer::_ERR_NOTFOUND_, array('name' => $server));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
} else {
if ($nid = $options['node']) {
if (!($etva_node = EtvaNodePeer::retrieveByPK($nid))) {
//notify event log
$msg_i18n = Etva::makeNotifyLogMessage(sfConfig::get('config_acronym'), EtvaNodePeer::_ERR_NOTFOUND_ID_, array('id' => $nid), EtvaServerPeer::_ERR_START_, array('name' => $server));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
} else {
// get list of nodes that server can assign
$nodes_toassign = $etva_server->listNodesAssignTo();
if (count($nodes_toassign)) {
$etva_node = $nodes_toassign[0];
// get first
} else {
//notify event log
$msg_i18n = Etva::makeNotifyLogMessage(sfConfig::get('config_acronym'), EtvaServerPeer::_ERR_NO_NODE_TO_ASSIGN_, array(), EtvaServerPeer::_ERR_START_, array('name' => $server));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
}
}
$server_va = new EtvaServer_VA($etva_server);
if ($options['assign'] || $etva_server->getUnassigned()) {
// Assign server to node
$response = $server_va->send_assign($etva_node);
if (!$response['success']) {
$this->log("[ERROR] " . $response['error']);
return $response;
}
}
// start server
$response = $server_va->send_start($etva_node);
if ($response['success']) {
// update GA Info
$response_ga = $server_va->getGAInfo($etva_node);
$this->log("[INFO] " . $response['response']);
} else {
$this->log("[ERROR] " . $response['error']);
}
return $response;
}
}
public function check_all_see_it(EtvaNode $etva_node, $bulk_responses)
{
$errors = array();
foreach ($bulk_responses as $node_id => $node_response) {
if ($node_response['success']) {
$node = EtvaNodePeer::retrieveByPK($node_id);
$vgs = $node_response['response'];
$found = false;
foreach ($vgs as $vg => $vgInfo) {
$vg_info = (array) $vgInfo;
$vg_type = $vg_info[EtvaVolumegroup::STORAGE_TYPE_MAP];
$vg_name = $vg_info[EtvaVolumegroup::VG_MAP];
if ($vg_type == $this->etva_vg->getStorageType()) {
if ($vg_type == EtvaVolumegroup::STORAGE_TYPE_LOCAL_MAP) {
if ($vg_name == $this->etva_vg->getVg()) {
$found = true;
}
} else {
if (isset($vg_info[EtvaVolumegroup::UUID_MAP])) {
$vg_uuid = $vg_info[EtvaVolumegroup::UUID_MAP];
if ($vg_uuid == $this->etva_vg->getUuid()) {
$found = true;
}
} else {
if ($vg_name == $this->etva_vg->getVg()) {
$found = true;
}
}
}
}
if ($found) {
break;
}
}
if (!$found) {
$errors[$node_id] = array('node_id' => $node_id, 'uuid' => $this->etva_vg->getUuid(), 'vg' => $this->etva_vg->getVg(), 'found' => true);
}
/*$node_init = $this->initialize($node,(array) $node_response['response']);
if(!$node_init['success']){
$errors[$node_id] = $node_init;
} else {
//notify system log
$message = Etva::getLogMessage(array(), EtvaVolumegroupPeer::_OK_SOAPREFRESH_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($node_response['agent'], 'event.log',array('message' => $message)));
}*/
} else {
/*$message = Etva::getLogMessage(array('info'=>$node_response['info']), EtvaVolumegroupPeer::_ERR_SOAPREFRESH_);
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($node_response['agent'], 'event.log',array('message' => $message,'priority'=>EtvaEventLogger::ERR)));*/
}
}
if (!empty($errors)) {
return array('success' => false, 'errors' => $errors);
} else {
return array('success' => 'true');
}
}
protected function execute($arguments = array(), $options = array())
{
$context = sfContext::createInstance(sfProjectConfiguration::getApplicationConfiguration('app', $options['env'], true));
parent::execute($arguments, $options);
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$connection = $databaseManager->getDatabase($options['connection'])->getConnection();
// add your code here
$this->log('Checking shared storage cluster consistency...' . "\n");
$ok = 1;
$affected = 0;
$errors = array();
$clusters = EtvaClusterPeer::doSelect(new Criteria());
foreach ($clusters as $cluster) {
$bulk_response_lvs = $cluster->soapSend('getlvs_arr', array('force' => 1));
$bulk_response_dtable = $cluster->soapSend('device_table');
$lv_va = new EtvaLogicalvolume_VA();
foreach ($bulk_response_lvs as $node_id => $node_response) {
if ($node_response['success']) {
//response received ok
$lvs = (array) $node_response['response'];
$node = EtvaNodePeer::retrieveByPK($node_id);
//$consist = $lv_va->check_shared_consistency($node,$lvs);
$response_dtable = (array) $bulk_response_dtable[$node_id];
$dtable = array();
if ($response_dtable['success']) {
$dtable = (array) $response_dtable['response'];
//$consist_dtable = $lv_va->check_shared_devicetable_consistency($node,$dtable,$bulk_response_dtable);
}
$check_res = $lv_va->check_consistency($node, $lvs, $dtable, $bulk_response_dtable);
if (!$check_res['success']) {
$err = $check_res['errors'];
$msg = sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => ''));
$err_msg = sprintf(" node with id=%s is not consistent: %s \n", $node_id, $msg);
$errors[] = array('message' => $err_msg, 'debug' => $err);
$affected++;
$node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
} else {
$node->clearErrorMessage(EtvaLogicalvolume_VA::LVINIT);
}
/*if( !$consist || !$consist_dtable ){
$errors = $lv_va->get_missing_lv_devices();
$msg = $errors ? $errors['message'] :
sfContext::getInstance()->getI18N()->__(EtvaLogicalvolumePeer::_ERR_INCONSISTENT_,array('%info%'=>''));
$err_msg = sprintf( " node with id=%s is not consistent: %s \n", $node_id, $msg );
$errors[] = array( 'message'=> $err_msg, 'debug'=>array( 'consist_lvs'=>$consist, 'consist_dtable'=>$consist_dtable ) );
$affected++;
$node->setErrorMessage(EtvaLogicalvolume_VA::LVINIT);
} else {
$node->clearErrorMessage(EtvaLogicalvolume_VA::LVINIT);
}*/
} else {
$errors[] = $node_response;
$affected++;
}
}
$bulk_response_pvs = $cluster->soapSend('hash_phydisks', array('force' => 1));
$pv_va = new EtvaPhysicalvolume_VA();
foreach ($bulk_response_pvs as $node_id => $node_response) {
if ($node_response['success']) {
//response received ok
$pvs = (array) $node_response['response'];
$node = EtvaNodePeer::retrieveByPK($node_id);
$check_res = $pv_va->check_consistency($node, $pvs);
if (!$check_res['success']) {
$err = $check_res['errors'];
$msg = sfContext::getInstance()->getI18N()->__(EtvaPhysicalvolumePeer::_ERR_INCONSISTENT_, array('%info%' => ''));
$err_msg = sprintf(" node with id=%s is not consistent: %s \n", $node_id, $msg);
$errors[] = array('message' => $err_msg, 'debug' => $err);
$affected++;
$node->setErrorMessage(EtvaPhysicalvolume_VA::PVINIT);
} else {
$node->clearErrorMessage(EtvaPhysicalvolume_VA::PVINIT);
}
} else {
$errors[] = $node_response;
$affected++;
}
}
$bulk_responses_vgs = $cluster->soapSend('getvgpvs', array('force' => 1));
$vg_va = new EtvaVolumegroup_VA();
foreach ($bulk_response_vgs as $node_id => $node_response) {
if ($node_response['success']) {
//response received ok
$vgs = (array) $node_response['response'];
$node = EtvaNodePeer::retrieveByPK($node_id);
$check_res = $vg_va->check_consistency($node, $vgs);
if (!$check_res['success']) {
$err = $check_res['errors'];
$msg = sfContext::getInstance()->getI18N()->__(EtvaVolumegroupPeer::_ERR_INCONSISTENT_, array('%info%' => ''));
$err_msg = sprintf(" node with id=%s is not consistent: %s \n", $node_id, $msg);
$errors[] = array('message' => $err_msg, 'debug' => $err);
$affected++;
$node->setErrorMessage(EtvaVolumegroup_VA::VGINIT);
} else {
$node->clearErrorMessage(EtvaVolumegroup_VA::VGINIT);
}
} else {
$errors[] = $node_response;
$affected++;
}
}
}
if (!empty($errors)) {
$this->log($message);
} else {
// log the message!
$this->log("The check shared storage cluster consistency task ran!", 6);
}
}
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 check_shared_devicetable_consistency($etva_node, $lvs_1stdtable, $bulk_response_dtable)
{
$node_id = $etva_node->getId();
$etva_cluster = $etva_node->getEtvaCluster();
// get shared LV
$db_ = $etva_cluster->getSharedLvs();
if (!$db_) {
$db_ = array();
}
$shared_lvs_1stdtable = array();
//filter LVs by shared
foreach ($db_ as $data) {
$lvdevice = $data->getLvdevice();
$clvdev = $lvdevice;
$clvdev = str_replace("/dev/", "", $clvdev);
$clvdev = str_replace("-", "--", $clvdev);
$clvdev = str_replace("/", "-", $clvdev);
$re_clvdev = "/" . $clvdev . ":/";
$lv_dtable_aux = preg_grep($re_clvdev, $lvs_1stdtable);
// ignore snapshots
$lv_dtable = preg_grep("/(?:(?! snapshot ).)/", $lv_dtable_aux);
$shared_lvs_1stdtable = array_merge($shared_lvs_1stdtable, $lv_dtable);
}
$consistent = 0;
$dt_errors = array();
foreach ($bulk_response_dtable as $e_id => $e_response) {
if ($e_response['success']) {
//response received ok
$node = EtvaNodePeer::retrieveByPK($e_id);
$dtable = (array) $e_response['response'];
$count_eq = 0;
foreach ($dtable as $e_line) {
if (in_array($e_line, $shared_lvs_1stdtable)) {
$count_eq++;
}
}
if ($count_eq != count($shared_lvs_1stdtable)) {
foreach ($shared_lvs_1stdtable as $d) {
if (!in_array($d, $dtable)) {
$this->missing_dtable[$e_id]['devices'][] = $d;
$this->missing_dtable[$e_id]['name'] = $node->getName();
}
}
$missing_devices = $this->missing_dtable[$e_id]['devices'];
$err_msg = sprintf(" node_id=%s missing_devices=%s \n", $e_id, print_r($missing_devices, true));
$dt_errors[] = array('message' => $err_msg);
}
}
}
if (empty($dt_errors)) {
$consistent = 1;
}
return $consistent;
}
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);
}
/**
* returns all servers of an node in json for Extjs grid with pager
*
*
* request object is like this;
* <code>
* $request['nid'] = $nid; //node ID
* $request['start'] = $startt; // start at record
* $request['limit'] = $limit; // number of records
* </code>
*
* @param sfWebRequest $request A request object
* @return string json string representation of servers info
*
*/
public function executeJsonGrid(sfWebRequest $request)
{
$isAjax = $request->isXmlHttpRequest();
if (!$isAjax) {
return $this->redirect('@homepage');
}
$limit = $this->getRequestParameter('limit', 10);
$page = floor($this->getRequestParameter('start', 0) / $limit) + 1;
// pager
$query = EtvaServerQuery::create();
if ($this->getRequestParameter("assigned")) {
$nodeID = $this->getRequestParameter("nid");
$query = $query->useEtvaServerAssignQuery('ServerAssign', 'LEFT JOIN')->filterByNodeId($nodeID)->endUse();
}
$this->addSortQuery($query);
$etva_node = EtvaNodePeer::retrieveByPK($this->getRequestParameter("nid"));
if (!$etva_node) {
return array('success' => false);
}
$this->pager = $query->paginate($page, $limit);
$elements = array();
$i = 0;
# Get data from Pager
foreach ($this->pager as $item) {
$elements[$i] = $item->toDisplay();
$etva_vnc_ports = $item->getEtvaVncPorts();
if (count($etva_vnc_ports) > 0) {
$etva_vnc_port = $etva_vnc_ports[0];
$elements[$i]['vnc_port'] = $etva_vnc_port->getId();
}
$all_shared = $item->isAllSharedLogicalvolumes();
$elements[$i]['all_shared_disks'] = $all_shared;
$has_snapshots = $item->hasSnapshots();
$elements[$i]['has_snapshots_disks'] = $has_snapshots;
$elements[$i]['has_snapshots_support'] = $item->hasSnapshotsSupport() ? true : false;
$elements[$i]['has_devices'] = $item->hasDevices();
if ($nodeID) {
$elements[$i]['node_id'] = $nodeID;
}
$i++;
}
$final = array('total' => $this->pager->getNbResults(), 'node_state' => $etva_node->getState(), 'node_initialize' => $etva_node->getInitialize(), 'can_create_vms' => $etva_node->canCreateVms(), 'node_has_vgs' => $etva_node->hasVgs(), 'data' => $elements);
$result = json_encode($final);
$this->getResponse()->setHttpHeader('Content-type', 'application/json');
return $this->renderText($result);
}
protected function execute($arguments = array(), $options = array())
{
// Context
$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
// server id
$server = $arguments['server'];
$this->log("[INFO] Check status of server '{$server}'");
$etva_server = EtvaServerPeer::retrieveByPK($server);
if (!$etva_server) {
$etva_server = EtvaServerPeer::retrieveByUuid($server);
}
if (!$etva_server) {
$etva_server = EtvaServerPeer::retrieveByName($server);
}
if (!$etva_server) {
$msg_i18n = $context->getI18N()->__(EtvaServerPeer::_ERR_NOTFOUND_, array('name' => $server));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
$this->log("[ERROR] " . $error['error']);
return $error;
} else {
if ($nid = $options['node']) {
$etva_node = EtvaNodePeer::retrieveByPK($nid);
} else {
$etva_node = $etva_server->getEtvaNode();
}
/*if(!$etva_node){
//notify event log
$msg_i18n = Etva::makeNotifyLogMessage(sfConfig::get('config_acronym'),
EtvaNodePeer::_ERR_NOTFOUND_ID_, array('id'=>$nid));
$error = array('success'=>false,'agent'=>sfConfig::get('config_acronym'),'error'=>$msg_i18n,'info'=>$msg_i18n);
$this->log("[ERROR] ".$error['error']);
return $error;
}
$server_va = new EtvaServer_VA($etva_server);
$response = $server_va->getGAInfo($etva_node); // update GA Info
*/
// TODO force check
$response = array('success' => true, 'response' => 'check ok', 'agent' => sfConfig::get('config_acronym'));
if ($etva_node) {
$response['agent'] = $etva_node->getName();
}
if ($options['check']) {
if (!$options['request_id']) {
$options['request_id'] = UUID::generate(UUID::UUID_RANDOM, UUID::FMT_STRING);
}
$response['_request_id'] = $options['request_id'];
$response['_request_status'] = EtvaAsynchronousJob::PENDING;
if ($etva_server->getVmState() == $options['check']) {
$response['_request_status'] = EtvaAsynchronousJob::FINISHED;
$msg_ok_type = '';
if ($options['check'] == EtvaServer::STATE_RUNNING) {
$msg_ok_type = EtvaServerPeer::_OK_START_;
} elseif ($options['check'] == EtvaServer::STATE_STOP) {
$msg_ok_type = EtvaServerPeer::_OK_STOP_;
}
if ($msg_ok_type) {
$response['response'] = Etva::makeNotifyLogMessage($response['agent'], $msg_ok_type, array('name' => $etva_server->getName()), null, array(), EtvaEventLogger::INFO);
}
}
//$this->log("[DEBUG] status=".$response['_request_status']." state=".$etva_server->getVmState()." == ".$options['check']);
}
if ($response['success']) {
$this->log("[INFO] " . $response['response']);
//$this->log("[DEBUG ".print_r($response,true));
} else {
$this->log("[ERROR] " . $response['error']);
}
return $response;
}
}
protected function execute($arguments = array(), $options = array())
{
// Context
$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
$node = $options['node'];
$etva_node = EtvaNodePeer::retrieveByPK($node);
if (!$etva_node) {
$msg_i18n = $context->getI18N()->__(EtvaNodePeer::_ERR_NOTFOUND_ID_, array('%id%' => $node));
$error = array('success' => false, 'agent' => sfConfig::get('config_acronym'), 'error' => $msg_i18n, 'info' => $msg_i18n);
return $error;
}
if ($arguments['boot'] == 'location') {
$valid = $this->validateLocationUrl($options['location']);
if ($valid == false) {
$msg_i18n = $context->getI18N()->__('Could not validate the location URL!');
$error = array('agent' => sfConfig::get('config_acronym'), 'success' => false, 'error' => $msg_i18n, 'info' => $msg_i18n);
return $error;
}
}
$server = array_merge($arguments, $options);
// decode networks
if ($server['networks']) {
$server['networks'] = $this->process_array_of_arguments($server['networks']);
}
//$this->log("[DEBUG] server networks ".print_r($server['networks'],true));
// decode disks
if ($server['disks']) {
$server_disks = $this->process_array_of_arguments($server['disks']);
$server['disks'] = $this->prepare_disks($server_disks);
}
//$this->log("[DEBUG] server disks ".print_r($server['disks'],true));
$etva_server = new EtvaServer();
$server_va = new EtvaServer_VA($etva_server);
$response = $server_va->send_create($etva_node, $server);
if ($response['success']) {
$this->log("[INFO] " . $response['response']);
} else {
$this->log("[ERROR] " . $response['error']);
}
return $response;
}
