379 lines
9.6 KiB
PHP
379 lines
9.6 KiB
PHP
<?php defined('SYSPATH') or die('No direct access allowed.');
|
|
|
|
/**
|
|
*
|
|
* @package PTA
|
|
* @subpackage Domain
|
|
* @category Models
|
|
* @author Deon George
|
|
* @copyright (c) 2010 phpTSMadmin Development Team
|
|
* @license http://phptsmadmin.sf.net/license.html
|
|
*/
|
|
class Model_DOMAIN extends ORM_TSM {
|
|
protected $_table_name = 'DOMAINS';
|
|
protected $_primary_key = 'DOMAIN_NAME'; // We need a primary key to detect that the object is loaded.
|
|
protected $_sorting = array(
|
|
'DOMAIN_NAME'=>'ASC',
|
|
);
|
|
|
|
protected $_has_many = array(
|
|
'MGMTCLASS'=>array('foreign_key'=>'DOMAIN_NAME','far_key'=>'DOMAIN_NAME'),
|
|
'NODE'=>array('foreign_key'=>'DOMAIN_NAME','far_key'=>'DOMAIN_NAME'),
|
|
'SCHEDULE_CLIENT'=>array('foreign_key'=>'DOMAIN_NAME','far_key'=>'DOMAIN_NAME')
|
|
);
|
|
|
|
protected $_tsm = array(
|
|
'db2'=>array(
|
|
'_has_many'=>array(
|
|
'MGMTCLASS'=>array('foreign_key'=>'DOMAIN_NAME','far_key'=>'DOMAIN_NAME'),
|
|
'NODE'=>array('foreign_key'=>'DOMAINNAME','far_key'=>'DOMAIN_NAME'),
|
|
'SCHEDULE_CLIENT'=>array('foreign_key'=>'DOMAIN_NAME','far_key'=>'DOMAIN_NAME')
|
|
),
|
|
),
|
|
);
|
|
|
|
/**
|
|
* Get all the NODES in this DOMAIN
|
|
*/
|
|
private function _nodes() {
|
|
$k = sprintf('%s-%s',__METHOD__,$this->DOMAIN_NAME);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
// In the interest of performance, we load all the records and get PHP to process it.
|
|
// Our ORM caching we reduce the hit on TSM.
|
|
foreach (ORM::factory('NODE')->find_all() as $o)
|
|
if ($o->DOMAIN_NAME == $this->DOMAIN_NAME)
|
|
array_push($result,$o);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
private function _node_int($method,$data) {
|
|
$k = sprintf('%s-%s-%s-%s',__METHOD__,$this->DOMAIN_NAME,$method,$data);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = 0;
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
$result += $no->{$method}($data);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
private function _node_bypoolbybtype($pool,$method,$type) {
|
|
$k = sprintf('%s-%s-%s-%s-%s',__METHOD__,$this->DOMAIN_NAME,$pool,$method,$type);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = 0;
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
$result += $no->{$method}($pool,$type);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return the BACKUP TYPES used by NODES in this DOMAIN
|
|
* ie: Bkup/Arch/SpMg
|
|
*/
|
|
public function btypes() {
|
|
$k = sprintf('%s-%s',__METHOD__,$this->DOMAIN_NAME);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
$result = array_merge($result,$no->btypes());
|
|
|
|
$result = array_unique($result);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function file_bybtype($type) {
|
|
return $this->_node_int('file_bybtype',$type);
|
|
}
|
|
|
|
/**
|
|
* Return the FILES that NODES in this DOMAIN has in a STORAGE POOL
|
|
* @param $pool is STORAGE POOL NAME
|
|
*/
|
|
public function file_bypool($pool) {
|
|
return $this->_node_int('file_bypool',$pool);
|
|
}
|
|
|
|
public function file_bypoolbybtype($pool,$type) {
|
|
return $this->_node_bypoolbybtype($pool,'file_bypoolbybtype',$type);
|
|
}
|
|
|
|
public function file_byptype($type) {
|
|
return $this->_node_int('file_byptype',$type);
|
|
}
|
|
|
|
public function logmb_bybtype($type) {
|
|
return $this->_node_int('logmb_bybtype',$type);
|
|
}
|
|
|
|
/**
|
|
* Return the LOGICAL_MB that NODES in this DOMAIN has in a STORAGE POOL
|
|
* @param $pool is STORAGE POOL NAME
|
|
*/
|
|
public function logmb_bypool($pool) {
|
|
return $this->_node_int('logmb_bypool',$pool);
|
|
}
|
|
|
|
public function logmb_bypoolbybtype($pool,$type) {
|
|
return $this->_node_bypoolbybtype($pool,'logmb_bypoolbybtype',$type);
|
|
}
|
|
|
|
public function logmb_byptype($type) {
|
|
return $this->_node_int('logmb_byptype',$type);
|
|
}
|
|
|
|
public function nodes() {
|
|
return $this->_nodes();
|
|
}
|
|
|
|
public function nodes_bybtype($type) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
if ($no->file_bybtype($type))
|
|
array_push($result,$no);
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return the NODES in this DOMAIN that have data in this STORAGE POOL
|
|
* @param $pool is STORAGE POOL NAME
|
|
*/
|
|
public function nodes_bypool(ORM $spo) {
|
|
$result = array();
|
|
|
|
foreach ($spo->nodes() as $no)
|
|
if (in_array($no,$this->_nodes()))
|
|
array_push($result,$no);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function nodes_bypoolbybtype($pool,$type) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
if ($no->file_bypoolbybtype($pool,$type))
|
|
array_push($result,$no);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function nodes_byptype($type) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
if ($no->file_byptype($type) AND ! in_array($no,$result))
|
|
array_push($result,$no);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return the STORAGE POOLS used by NODES in this DOMAIN
|
|
*/
|
|
public function stgpools() {
|
|
$k = sprintf('%s-%s',__METHOD__,$this->DOMAIN_NAME);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
foreach ($no->stgpools() as $spo)
|
|
if (! in_array($spo,$result))
|
|
array_push($result,$spo);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return the STORAGE POOLS that NODES in this DOMAIN uses by BACKUP TYPE
|
|
* @param $type is Bkup/Arch/SpMg
|
|
*/
|
|
public function stgpools_bybtype($type) {
|
|
$k = sprintf('%s-%s-%s',__METHOD__,$this->DOMAIN_NAME,$type);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$x = $result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
foreach ($no->stgpools_bybtype($type) as $spo)
|
|
if (! in_array($spo->STGPOOL_NAME,$result))
|
|
array_push($result,$spo);
|
|
|
|
Sort::MASort($result,'STGPOOL_NAME');
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the STORAGE POOLS that NODES in this DOMAIN uses by BACKUP TYPE
|
|
* @param $type is ACTIVEDATA/PRIMARY/COPY
|
|
*/
|
|
public function stgpools_byptype($type) {
|
|
$k = sprintf('%s-%s-%s',__METHOD__,$this->DOMAIN_NAME,$type);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
foreach ($this->stgpools() as $spo)
|
|
if ($spo->POOLTYPE == $type)
|
|
array_push($result,$spo);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return the STORAGE POOL TYPES used by NODES in this DOMAIN
|
|
* ie: ACTIVE/PRIMARY/COPY
|
|
* @todo This should be sorted by PRIMARY/ACTIVE/COPY
|
|
*/
|
|
public function stgpooltypes() {
|
|
$k = sprintf('%s-%s',__METHOD__,$this->DOMAIN_NAME);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
$result = array_merge($result,$no->stgpooltypes());
|
|
|
|
$result = array_unique($result);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function vols_bybtype($type) {
|
|
return $this->vols_byctype($this->datatypemap($type));
|
|
}
|
|
|
|
/**
|
|
* Return the VOLUMES that NODES in this DOMAIN uses by BACKUP TYPE
|
|
* @param $type is BACKUP/ARCHIVE/SPACE MANAGED
|
|
*/
|
|
public function vols_byctype($type) {
|
|
$k = sprintf('%s-%s-%s',__METHOD__,$this->DOMAIN_NAME,$type);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
foreach ($no->vols_byctype($type) as $vo)
|
|
if (! in_array($vo->VOLUME_NAME,$result))
|
|
array_push($result,$vo);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return the VOLUMES that NODES in this DOMAIN use
|
|
* @param $pool is STORAGE POOL NAME
|
|
*/
|
|
public function vols_bypool($pool) {
|
|
$k = sprintf('%s-%s-%s',__METHOD__,$this->DOMAIN_NAME,$pool);
|
|
$c = Kohana::$config->load('config')->cache;
|
|
|
|
if (is_null($result = Cache::instance($c)->get($k))) {
|
|
$result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
foreach ($no->vols_bypool($pool) as $vo)
|
|
if (! in_array($vo->VOLUME_NAME,$result))
|
|
array_push($result,$vo);
|
|
|
|
// @todo Cache time should be configurble
|
|
Cache::instance($c)->set($k,$result,300);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function vols_bypoolbybtype($pool,$type) {
|
|
return $this->vols_bypoolbyctype($pool,$this->datatypemap($type));
|
|
}
|
|
|
|
/**
|
|
* Return the VOLUMES that this NODE uses by pool and BACKUP TYPE
|
|
* @param $pool is STORAGE POOL NAME
|
|
* @param $type is BACKUP/ARCHIVE/SPACE MANAGED
|
|
*/
|
|
public function vols_bypoolbyctype($pool,$type) {
|
|
$x = $result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
foreach ($no->vols_bypoolbyctype($pool,$type) as $vo)
|
|
if (! in_array($vo->VOLUME_NAME,$result))
|
|
array_push($result,$vo);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function vols_byptype($type) {
|
|
$x = $result = array();
|
|
|
|
foreach ($this->_nodes() as $no)
|
|
foreach ($no->vols_byptype($type) as $vuo)
|
|
if (! in_array($vuo->VOLUME_NAME,$x)) {
|
|
array_push($result,$vuo);
|
|
array_push($x,$vuo->VOLUME_NAME);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
?>
|