public function initData($arr)
{
if (array_key_exists(self::NAME_MAP, $arr)) {
$this->setName($arr[self::NAME_MAP]);
}
if (array_key_exists(self::MEMORY_MAP, $arr)) {
$memory = Etva::Byte_to_MBconvert($arr[self::MEMORY_MAP]);
$this->setMem($memory);
}
if (array_key_exists(self::VCPU_MAP, $arr)) {
$this->setCpus($arr[self::VCPU_MAP]);
}
if (array_key_exists(self::VNC_PORT_MAP, $arr)) {
$this->setVncPort($arr[self::VNC_PORT_MAP]);
}
if (array_key_exists(self::VNC_KEYMAP_MAP, $arr)) {
$this->setVncKeymap($arr[self::VNC_KEYMAP_MAP]);
}
if (array_key_exists(self::VM_STATE_MAP, $arr)) {
$this->setVmState($arr[self::VM_STATE_MAP]);
}
if (array_key_exists(self::DISKS_MAP, $arr)) {
$this->setDisks($arr[self::DISKS_MAP]);
}
if (array_key_exists(self::NETWORKS_MAP, $arr)) {
$this->setNetworks($arr[self::NETWORKS_MAP]);
}
if (array_key_exists(self::FEATURES_MAP, $arr)) {
$this->setFeatures(json_encode($arr[self::FEATURES_MAP]));
}
}
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;
}
}
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;
}
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 getMemory($units = 'B')
{
$mem_array = $this->virtualsystem->getMemory();
$all_mem = array_sum($mem_array);
switch ($units) {
case 'B':
$all_mem = Etva::MB_to_Byteconvert($all_mem);
break;
default:
break;
}
return $all_mem;
}
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;
}
}
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;
}
/**
* 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 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;
}
}
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 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);
}
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 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);
}
}
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);
$con = $databaseManager->getDatabase($options['connection'])->getConnection();
// add your code here
$this->log('[INFO] Checking Servers heartbeat...' . "\n");
$servers_timeout = EtvaServerQuery::create()->filterByVmState(EtvaServer::RUNNING)->filterByGaState(EtvaServerPeer::_GA_RUNNING_)->filterByHasha(1)->where('hbtimeout>0 AND UNIX_TIMESTAMP(heartbeat) < (UNIX_TIMESTAMP(now()) - hbtimeout)')->useEtvaServerAssignQuery('ServerAssign', 'RIGHT JOIN')->useEtvaNodeQuery()->filterByState(EtvaNode::NODE_ACTIVE)->endUse()->endUse()->find();
if (count($servers_timeout) > 0) {
foreach ($servers_timeout as $etva_server) {
$message = sprintf(' The server %s with id %s get heartbeat timed out (last heartbeat at %s and heartbeat timeout %s secods)', $etva_server->getName(), $etva_server->getId(), $etva_server->getHeartbeat(), $etva_server->getHbtimeout());
$this->log($message);
// add log message
Etva::makeNotifyLogMessage($this->name, $message);
$etva_node = $etva_server->getEtvaNode();
$server_va = new EtvaServer_VA($etva_server);
$response_ga = $etva_server->getGAInfo($etva_node);
if (!$response_ga['success']) {
$msg = sprintf(' Something wrong with node %s agent, can\'t get GA state of the server %s with id %s run.', $etva_node->getName(), $etva_server->getName(), $etva_server->getId());
$this->log($msg);
// add log message
Etva::makeNotifyLogMessage($this->name, $msg);
$etva_server->setGaState(EtvaServerPeer::_GA_STOPPED_);
// mark GA as stopped
$etva_server->save();
} else {
if ($reponse_ga['ga_state'] == EtvaServerPeer::_GA_RUNNING_) {
$message_ga = sprintf(' But the explicit check GA state of the server %s with id %s run with success.', $etva_server->getName(), $etva_server->getId());
$this->log($message_ga);
// add log message
Etva::makeNotifyLogMessage($this->name, $message_ga, array(), null, array(), EtvaEventLogger::INFO);
} else {
// go restart
$starttime = sfConfig::get('app_server_heartbeat_starttime');
$starttime_date = date("c", time() - $starttime);
if ($etva_server->getHblaststart() && $etva_server->getHblaststart() > $starttime_date) {
$msg = sprintf(' the server %s with id %s is in starttime.', $etva_server->getName(), $etva_server->getId());
$this->log($msg);
// add log message
Etva::makeNotifyLogMessage($this->name, $msg, array(), null, array(), EtvaEventLogger::INFO);
} else {
$last_nrestarts = $etva_server->getHbnrestarts();
if ($last_nrestarts >= sfConfig::get('app_server_heartbeat_number_of_restart')) {
$msg = sprintf(' the server %s with id %s exceed number of restart.', $etva_server->getName(), $etva_server->getId());
$this->log($msg);
// add log message
Etva::makeNotifyLogMessage($this->name, $msg);
} else {
$msg = sprintf(' the server %s with id %s is heartbeat out of date and will be restart.', $etva_server->getName(), $etva_server->getId());
$this->log($msg);
// add log message
Etva::makeNotifyLogMessage($this->name, $msg, array(), null, array(), EtvaEventLogger::INFO);
// force to stop
$response_stop = $server_va->send_stop($etva_node, array('force' => 1, 'destroy' => 1));
sleep(5);
// wait a few seconds
$response_start = $server_va->send_start($etva_node);
if (!$response_start['success']) {
// start fail...
sleep(10);
// wait a few seconds
$response_start = $server_va->send_start($etva_node);
// start again
}
$etva_server->resetHeartbeat(EtvaServerPeer::_GA_STOPPED_);
// reset heartbeat and mark GA as stopped
$etva_server->setHbnrestarts($last_nrestarts + 1);
// inc number of restart
$etva_server->save();
}
}
}
}
}
} else {
$this->log("[INFO] No servers with heartbeat timed out.");
}
// log the message!
$this->log("[INFO] The check servers heartbeat task ran!");
}
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 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);
}
}
protected function processStartStop(EtvaNode $etva_node, $response, $method)
{
$etva_server = $this->etva_server;
switch ($method) {
case self::SERVER_START:
$msg_ok_type = EtvaServerPeer::_OK_START_;
$msg_err_type = EtvaServerPeer::_ERR_START_;
break;
case self::SERVER_STOP:
$msg_ok_type = EtvaServerPeer::_OK_STOP_;
$msg_err_type = EtvaServerPeer::_ERR_STOP_;
break;
}
if (!$response['success']) {
$result = $response;
$msg_i18n = Etva::makeNotifyLogMessage($response['agent'], $response['info'], array(), $msg_err_type, array('name' => $etva_server->getName()));
$result['error'] = $msg_i18n;
return $result;
}
$response_decoded = (array) $response['response'];
$returned_status = $response_decoded['_okmsg_'];
$returned_object = (array) $response_decoded['_obj_'];
// get some info from response...
//update some server data from agent response
$etva_server->initData($returned_object);
$etva_server->setFirstBoot(0);
if ($first_boot) {
$etva_server->setBoot('filesystem');
} else {
$boot_field = $etva_server->getBoot();
switch ($boot_field) {
case 'filesystem':
case 'pxe':
if (!$etva_server->getCdrom()) {
$etva_server->setLocation(null);
}
break;
}
}
switch ($method) {
case self::SERVER_START:
$etva_server->setHblaststart('NOW');
// update hb last start
break;
}
$etva_server->save();
// update free memory
$etva_node->updateMemFree();
$etva_node->save();
//notify event log
$msg_i18n = Etva::makeNotifyLogMessage($response['agent'], $msg_ok_type, array('name' => $etva_server->getName()), null, array(), EtvaEventLogger::INFO);
$result = array('success' => true, 'agent' => $response['agent'], 'response' => $msg_i18n);
return $result;
}
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 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 canResizeTo($sizeMB)
{
$vg = $this->getEtvaVolumegroup();
$size_bytes = Etva::MB_to_Byteconvert($sizeMB);
$total_available_size = $vg->getFreesize() + $this->size;
if ($size_bytes > 0 && $size_bytes <= $total_available_size) {
return true;
} else {
return false;
}
}
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] 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;
}
}
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 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);
}
}
public function canAssignServer(EtvaServer $server)
{
$server_mem = Etva::MB_to_Byteconvert($server->getMem());
if ($this->getCputotal() >= $server->getVcpu() && $this->getMaxMem() > $server_mem && !$server->getDevices_VA() && !$server->getHasSnapshots()) {
if ($server->getVmState() !== EtvaServer::RUNNING || $this->getMemfree() > $server_mem) {
error_log("canAssignServer OK node=" . $this->getName() . " server=" . $server->getName() . " vmstate=" . $server->getVmState() . " maxmem=" . $this->getMaxMem() . " memfree=" . $this->getMemfree() . " server_mem=" . $server_mem);
return true;
}
}
error_log("canAssignServer NOK node=" . $this->getName() . " server=" . $server->getName() . " vmstate=" . $server->getVmState() . " maxmem=" . $this->getMaxMem() . " memfree=" . $this->getMemfree() . " server_mem=" . $server_mem);
return false;
}
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);
}
}
<?php
//load partial files code... based on DB service module name.
//in this case it should be in service name=>main and will load js code from _ETFS_main.php
Etva::loadServicesPartials($etva_server);
?>
<script>
Ext.ns('ETFS');
/*
* .View
*
* Build all panels. Entry point for module
*
*/
ETFS.View = function(config) {
Ext.apply(this,config);
console.log(this);
//load services ID from BD
var conn = new Ext.data.Connection({
listeners:{
// wait message.....
beforerequest:function(){
Ext.MessageBox.show({
title: <?php
echo json_encode(__('Please wait...'));
?>
,
private function loadModelConf()
{
$this->etva_model = Etva::getEtvaModelFile();
}
