1907 lines
49 KiB
PHP
1907 lines
49 KiB
PHP
<?php
|
|
// $Header: /cvsroot/phptsmadmin/phpTSMadmin/lib/tsm_classes.php,v 1.1 2009/04/19 04:04:29 wurley Exp $
|
|
|
|
abstract class base {
|
|
function getName() {
|
|
return $this->name;
|
|
}
|
|
}
|
|
|
|
abstract class copyGroup extends base {
|
|
function __construct($name) {
|
|
$this->id = $name;
|
|
}
|
|
|
|
abstract public function setDetails($details);
|
|
|
|
public function setDefaultMgmtClass() {
|
|
$this->default = true;
|
|
}
|
|
|
|
public function isDefaultMgmtClass() {
|
|
return $this->default;
|
|
}
|
|
|
|
public function getStoragePool() {
|
|
$stgpools = objectCache('stgps');
|
|
|
|
if ($stgpools->ifExist($this->stgpool))
|
|
return $stgpools->getStoragePool($this->stgpool);
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class copyGroupArchive extends copyGroup {
|
|
public function setDetails($details) {
|
|
$this->domain = $details['DOMAIN_NAME'];
|
|
#$this->xx = $details['SET_NAME'];
|
|
$this->name = $details['CLASS_NAME'];
|
|
#$this->xx = $details['COPYGROUP_NAME'];
|
|
$this->retain['DAYS'] = $details['RETVER'];
|
|
#$this->xx = $details['SERIALIZATION'];
|
|
$this->stgpool = $details['DESTINATION'];
|
|
#$this->xx = $details['CHG_TIME'];
|
|
#$this->xx = $details['CHG_ADMIN'];
|
|
#$this->xx = $details['PROFILE'];
|
|
#$this->xx = $details['RETINIT'];
|
|
#$this->xx = $details['RETMIN'];
|
|
|
|
$this->default = false;
|
|
$this->type = 'Arch';
|
|
}
|
|
}
|
|
|
|
class copyGroupBackup extends copyGroup {
|
|
public function setDetails($details) {
|
|
$this->domain = $details['DOMAIN_NAME'];
|
|
#$this->xx = $details['SET_NAME'];
|
|
$this->name = $details['CLASS_NAME'];
|
|
#$this->xx = $details['COPYGROUP_NAME'];
|
|
$this->version['EXISTS'] = $details['VEREXISTS'];
|
|
$this->version['DELETED'] = $details['VERDELETED'];
|
|
$this->retain['EXTRA'] = $details['RETEXTRA'];
|
|
$this->retain['ONLY'] = $details['RETONLY'];
|
|
#$this->xx = $details['MODE'];
|
|
#$this->xx = $details['SERIALIZATION'];
|
|
$this->frequency = $details['FREQUENCY'];
|
|
$this->stgpool = $details['DESTINATION'];
|
|
#$this->xx = $details['TOC_DESTINATION'];
|
|
#$this->xx = $details['CHG_TIME'];
|
|
#$this->xx = $details['CHG_ADMIN'];
|
|
#$this->xx = $details['PROFILE'];
|
|
|
|
$this->default = false;
|
|
$this->type = 'Bkup';
|
|
}
|
|
}
|
|
|
|
class deviceClass extends base {
|
|
function deviceClass($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
$this->access = $details['ACCESS_STRATEGY'];
|
|
#$this->xx = $details['STGPOOL_COUNT'];
|
|
$this->type = $details['DEVTYPE'];
|
|
#$this->xx = $details['FORMAT'];
|
|
$this->capacity = $details['CAPACITY'];
|
|
#$this->xx = $details['MOUNTLIMIT'];
|
|
#$this->xx = $details['MOUNTWAIT'];
|
|
#$this->xx = $details['MOUNTRETENTION'];
|
|
#$this->xx = $details['PREFIX'];
|
|
$this->library = $details['LIBRARY_NAME'];
|
|
$this->dir = $details['DIRECTORY'];
|
|
#$this->xx = $details['SERVERNAME'];
|
|
#$this->xx = $details['RETRYPERIOD'];
|
|
#$this->xx = $details['RETRYINTERVAL'];
|
|
#$this->xx = $details['SHARED'];
|
|
#$this->xx = $details['HLADDRESS'];
|
|
#$this->xx = $details['MINCAPACITY'];
|
|
#$this->xx = $details['WORM'];
|
|
#$this->xx = $details['SCALECAPACITY'];
|
|
#$this->xx = $details['LAST_UPDATE_BY'];
|
|
#$this->xx = $details['LAST_UPDATE'];
|
|
|
|
# DISK types have a blank type - we'll set it.
|
|
if ($this->access == 'Random' && ! trim($this->type) && $this->name='DISK')
|
|
$this->type = 'DISK';
|
|
}
|
|
|
|
function LibraryDevClass() {
|
|
if (trim($this->library))
|
|
return $this->library;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isLibraryDevClass() {
|
|
if (trim($this->library))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class drive extends base {
|
|
function drive($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
$this->library = $details['LIBRARY_NAME'];
|
|
$this->type = $details['DEVICE_TYPE'];
|
|
#$this->xx = $details['ONLINE'];
|
|
#$this->xx = $details['READ_FORMATS'];
|
|
#$this->xx = $details['WRITE_FORMATS'];
|
|
#$this->xx = $details['ELEMENT'];
|
|
#$this->xx = $details['ACS_DRIVE_ID'];
|
|
$this->status = $details['DRIVE_STATE'];
|
|
#$this->xx = $details['ALLOCATED_TO'];
|
|
#$this->xx = $details['LAST_UPDATE_BY'];
|
|
#$this->xx = $details['LAST_UPDATE'];
|
|
#$this->xx = $details['CLEAN_FREQ'];
|
|
#$this->xx = $details['DRIVE_SERIAL'];
|
|
$this->volume = $details['VOLUME_NAME'];
|
|
}
|
|
|
|
function inLibraryName($library) {
|
|
if ($this->library == $library)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class filesystem extends base {
|
|
function filesystem($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
#$this->xx = $details['NODE_NAME'];
|
|
$this->id = $details['FILESPACE_ID'];
|
|
$this->type = $details['FILESPACE_TYPE'];
|
|
$this->capacity = $details['CAPACITY'];
|
|
$this->util = $details['PCT_UTIL'];
|
|
$this->backup['start'] = $details['BACKUP_START'];
|
|
$this->backup['end'] = $details['BACKUP_END'];
|
|
#$this->xx = $details['DELETE_OCCURRED'];
|
|
#$this->xx = $details['UNICODE_FILESPACE'];
|
|
#$this->xx = $details['FILESPACE_HEXNAME'];
|
|
}
|
|
|
|
function setOccupancy($details) {
|
|
$this->occupancy[$details->type][$details->getStoragePool()] = $details->files;
|
|
}
|
|
|
|
function setVolumeUsage($details) {
|
|
switch ($details['COPY_TYPE']) {
|
|
case 'BACKUP' : $type = 'Bkup';
|
|
break;
|
|
case 'ARCHIVE' : $type = 'Arch';
|
|
break;
|
|
case 'SPACE MANAGED' : $type = 'HSM';
|
|
break;
|
|
|
|
default:
|
|
debug_dump(sprintf('Unknown Copy Type: %s',$details['COPY_TYPE']),1);
|
|
}
|
|
#$this->xx = $details['NODE_NAME'];
|
|
#$this->xx = $details['COPY_TYPE'];
|
|
#$this->xx = $details['FILESPACE_NAME'];
|
|
#$this->xx = $details['STGPOOL_NAME'];
|
|
#$this->xx = $details['VOLUME_NAME'];
|
|
$this->volume[$type][$details['STGPOOL_NAME']][$details['VOLUME_NAME']] = getVolume($details['VOLUME_NAME']);
|
|
#$this->xx = $details['FILESPACE_ID'];
|
|
}
|
|
|
|
function getStoragePools() {
|
|
$result = array();
|
|
|
|
if (isset($this->occupancy))
|
|
foreach ($this->occupancy as $type => $stgpools)
|
|
foreach ($stgpools as $stgpool => $details)
|
|
if (! in_array($stgpool,$result))
|
|
$result[] = $stgpool;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of VOLUMES used by this FILE SYSTEM
|
|
* @input string (STORAGE POOL NAME|NULL [for all storage pools])
|
|
* @return array (VOLUME NAMES)
|
|
*/
|
|
function getVolumeUsage($stgp = null) {
|
|
$result = array();
|
|
|
|
if (isset($this->volume))
|
|
foreach ($this->volume as $type => $stgpools)
|
|
foreach ($stgpools as $stgpool => $volumes) {
|
|
if ($stgp && $stgp != $stgpool)
|
|
continue;
|
|
foreach ($volumes as $volume => $details)
|
|
if (! in_array($volume,$result))
|
|
$result[] = $volume;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getOccupancy($type='Bkup') {
|
|
if (isset($this->occupancy[$type]))
|
|
return $this->occupancy[$type];
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getVolumes($type='Bkup') {
|
|
if (isset($this->volume[$type]))
|
|
return $this->volume[$type];
|
|
else
|
|
return array();
|
|
}
|
|
|
|
function getVolumesStgp($type,$stgp) {
|
|
$return = array();
|
|
|
|
foreach ($this->getVolumes($type) as $stgpool => $stgpdetails) {
|
|
foreach ($stgpdetails as $volid => $volume) {
|
|
if ($volume->getStoragePool() == $stgp)
|
|
$return[] = $volume;
|
|
}
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
}
|
|
|
|
class helpText {
|
|
function helpText($command) {
|
|
$this->command = $command;
|
|
$this->description = '';
|
|
$this->class = '';
|
|
$this->example = '';
|
|
$this->parameter = '';
|
|
$this->related = '';
|
|
}
|
|
|
|
function addTitle($text) {
|
|
$this->title = $text;
|
|
}
|
|
|
|
function addDescription($text) {
|
|
if (trim($text) && (! preg_match('/^\s*\*\s+/',$text)))
|
|
$this->description .= $text.' ';
|
|
else
|
|
if (trim($text))
|
|
$this->description .= sprintf('<br />%s',$text);
|
|
else
|
|
$this->description .= '<br /><br />';
|
|
}
|
|
|
|
function addClass($text) {
|
|
if (trim($text))
|
|
$this->class .= $text.' ';
|
|
else
|
|
$this->class .= '<br /><br />';
|
|
}
|
|
|
|
function addParameter($text) {
|
|
static $lastcommand;
|
|
|
|
if (preg_match('/^\s+/',$text) && trim($lastcommand))
|
|
$this->parameter[$lastcommand]['text'] .= $text.'<br />';
|
|
|
|
else {
|
|
if (trim($text)) {
|
|
$lastcommand = preg_replace('/(.*)\s+\(Required\)/',"$1",$text);
|
|
if ($lastcommand != $text)
|
|
$this->parameter[$lastcommand]['required'] = true;
|
|
$this->parameter[$lastcommand]['text'] = '';
|
|
|
|
} else {
|
|
$this->parameter[$lastcommand]['text'] .= '<br />';
|
|
}
|
|
}
|
|
}
|
|
|
|
function addSyntax($text) {
|
|
$this->syntax .= $text.'<br />';
|
|
}
|
|
|
|
function addExample($text) {
|
|
$this->example[] = $text;
|
|
}
|
|
|
|
function addRelated($text) {
|
|
static $lastrelated;
|
|
|
|
# If there are than 2 upper case chars together, assume a command.
|
|
$text = preg_replace('/^\s*/','',$text);
|
|
if (preg_match('/^\s*([A-Z]{2,}\s?)+/',$text,$matches)) {
|
|
|
|
# $matches[0] has the command.
|
|
$command = preg_replace('/\s*$/','',$matches[0]);
|
|
$text = preg_replace("/${command}\s*/",'',$text);
|
|
$lastrelated = $command;
|
|
}
|
|
|
|
if (! isset($this->related[$lastrelated]))
|
|
$this->related[$lastrelated] = '';
|
|
|
|
$this->related[$lastrelated] .= $text;
|
|
}
|
|
|
|
function getTitle() {
|
|
return $this->title;
|
|
}
|
|
|
|
function getDescription() {
|
|
global $app;
|
|
$help = objectCache('help',1);
|
|
|
|
# Find any commands and make them hotlinks
|
|
foreach ($help->getCommands() as $command)
|
|
$this->description = preg_replace("/$command/",
|
|
sprintf('<a href="cmd.php?cmd=help&index=%s&command=%s">%s</a>',$app['server']->index,htmlspecialchars($command),$command),$this->description);
|
|
return $this->description;
|
|
}
|
|
|
|
function getClass() {
|
|
return $this->class;
|
|
}
|
|
|
|
function getSyntax() {
|
|
foreach ($this->getParameterList() as $parm)
|
|
$this->syntax = preg_replace("/-$parm-/",
|
|
sprintf('-<a href="#%s">%s</a>-',$parm,$parm),$this->syntax);
|
|
|
|
return "<pre>".$this->syntax."</pre>";
|
|
}
|
|
|
|
function getParameterList() {
|
|
return array_keys($this->parameter);
|
|
}
|
|
|
|
function getParameters() {
|
|
$return = '<table class="result" border=0>';
|
|
foreach ($this->parameter as $parm => $text)
|
|
$return .= sprintf('<tr class="list_item"><td class="heading"><a name="%s">%s</a></td><td class="value"><table class="result"><tr><td>%s</td></tr></table></td></tr>',
|
|
$parm,
|
|
isset($text['required']) ? "<b>$parm</b>" : $parm,$text['text']);
|
|
$return .= '</table>';
|
|
return $return;
|
|
}
|
|
|
|
function getRelated() {
|
|
global $app;
|
|
$help = objectCache('help',1);
|
|
$commands = $help->getCommands();
|
|
|
|
$return = '<table class="result" border=0>'."\n";
|
|
# Find any commands and make them hotlinks
|
|
foreach ($this->related as $command => $desc) {
|
|
if (in_array($command,$commands))
|
|
$return .= sprintf('<tr class="list_item"><td class="heading"><span style="white-space: nowrap;"><a href="cmd.php?cmd=help&index=%s&command=%s">%s</a></span></td><td class="value"><table class="result"><tr><td>%s</td></tr></table></td></tr>',
|
|
$app['server']->index,htmlspecialchars($command),$command,$desc)."\n";
|
|
else
|
|
$return .= sprintf('<tr class="list_item"><td class="heading"><span style="white-space: nowrap;">%s</span></td><td class="value"><table class="result"><tr><td>%s</td></tr></table></td></tr>',
|
|
$command,$desc)."\n";
|
|
}
|
|
$return .= '</table>'."\n";
|
|
|
|
return $return;
|
|
}
|
|
}
|
|
|
|
class library extends base {
|
|
function library($name,$server) {
|
|
$this->name = $name;
|
|
$this->index = $server;
|
|
}
|
|
|
|
function setLibrary($details) {
|
|
$this->type = $details['LIBRARY_TYPE'];
|
|
#$this->xx = $details['ACS_ID'];
|
|
#$this->xx = $details['PRIVATE_CATEGORY'];
|
|
#$this->xx = $details['SCRATCH_CATEGORY'];
|
|
#$this->xx = $details['EXTERNAL_MGR'];
|
|
$this->shared = $details['SHARED'];
|
|
#$this->xx = $details['LANFREE'];
|
|
#$this->xx = $details['OBEYMOUNTRETENTION'];
|
|
#$this->xx = $details['PRIMARY_LIB_MGR'];
|
|
$this->autolabel = $details['AUTOLABEL'];
|
|
#$this->xx = $details['LAST_UPDATE_BY'];
|
|
#$this->xx = $details['LAST_UPDATE'];
|
|
#$this->xx = $details['LIBRARY_SERIAL'];
|
|
#$this->xx = $details['WORMSCRATCH_CAT'];
|
|
#$this->xx = $details['RESETDRIVES'];
|
|
}
|
|
|
|
function setAttr($attr,$value) {
|
|
$this->attr[$attr] = $value;
|
|
}
|
|
|
|
function getAttr($attr) {
|
|
if (isset($this->attr[$attr]))
|
|
return $this->attr[$attr];
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function addSlots($details) {
|
|
$this->slots = $details;
|
|
}
|
|
|
|
function addVolumes($details) {
|
|
$this->volumes = $details;
|
|
}
|
|
|
|
function addDrives($details) {
|
|
$this->drives = $details;
|
|
}
|
|
|
|
function getDrives() {
|
|
if (isset($this->drives))
|
|
return $this->drives;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function slotVolumes($checkedIn=true) {
|
|
$result = array();
|
|
|
|
if (isset($this->slots)) {
|
|
foreach ($this->slots as $element => $details)
|
|
if ($checkedIn && $details['status'] == 'Allocated')
|
|
$result[$element] = $details;
|
|
elseif (! $checkedIn && $details['status'] != 'Allocated')
|
|
$result[$element] = $details;
|
|
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getLibraryEmpty() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->isLibraryEmpty())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getLibraryPending() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->isLibraryPending())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getLibraryScratch() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->isLibraryScratch())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
class mgmtclass extends base {
|
|
function __construct($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
$this->domain = $details['DOMAIN_NAME'];
|
|
#$this->xx = $details['SET_NAME'];
|
|
$this->name = $details['CLASS_NAME'];
|
|
$this->default = $details['DEFAULTMC'] == 'Yes' ? true : false;
|
|
#$this->xx = $details['DESCRIPTION'];
|
|
#$this->xx = $details['SPACEMGTECHNIQUE'];
|
|
#$this->xx = $details['AUTOMIGNONUSE'];
|
|
#$this->xx = $details['MIGREQUIRESBKUP'];
|
|
#$this->xx = $details['MIGDESTINATION'];
|
|
#$this->xx = $details['CHG_TIME'];
|
|
#$this->xx = $details['CHG_ADMIN'];
|
|
#$this->xx = $details['PROFILE'];
|
|
}
|
|
}
|
|
|
|
class node extends base {
|
|
function node($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
$this->os = $details['PLATFORM_NAME'];
|
|
$this->domain = $details['DOMAIN_NAME'];
|
|
$this->time['pwset'] = $details['PWSET_TIME'];
|
|
$this->passwd['invalid'] = $details['INVALID_PW_COUNT'];
|
|
$this->contact = $details['CONTACT'];
|
|
$this->compression = $details['COMPRESSION'] == 'NO' ? false : true;
|
|
$this->delete['arch'] = $details['ARCHDELETE'] == 'NO' ? false : true;
|
|
$this->delete['back'] = $details['BACKDELETE'] == 'NO' ? false : true;
|
|
$this->locked = $details['LOCKED'] == 'NO' ? false : true;
|
|
$this->time['lastacc'] = $details['LASTACC_TIME'];
|
|
$this->time['registered'] = $details['REG_TIME'];
|
|
#$this->xx = $details['REG_ADMIN'];
|
|
#$this->xx = $details['LASTSESS_COMMMETH'];
|
|
#$this->xx = $details['LASTSESS_RECVD'];
|
|
#$this->xx = $details['LASTSESS_SENT'];
|
|
#$this->xx = $details['LASTSESS_DURATION'];
|
|
#$this->xx = $details['LASTSESS_IDLEWAIT'];
|
|
#$this->xx = $details['LASTSESS_COMMWAIT'];
|
|
#$this->xx = $details['LASTSESS_MEDIAWAIT'];
|
|
$this->level['tsm_ver'] = $details['CLIENT_VERSION'];
|
|
$this->level['tsm_rel'] = $details['CLIENT_RELEASE'];
|
|
$this->level['tsm_lvl'] = $details['CLIENT_LEVEL'];
|
|
$this->level['tsm_slv'] = $details['CLIENT_SUBLEVEL'];
|
|
$this->level['os'] = $details['CLIENT_OS_LEVEL'];
|
|
$this->cloptset = $details['OPTION_SET'];
|
|
#$this->xx = $details['AGGREGATION'];
|
|
$this->url = $details['URL'];
|
|
#$this->xx = $details['NODETYPE'];
|
|
$this->passwd['expiry'] = $details['PASSEXP'];
|
|
$this->mp['keep'] = $details['KEEP_MP'] == 'NO' ? false : true;
|
|
$this->mp['max'] = $details['MAX_MP_ALLOWED'];
|
|
#$this->xx = $details['AUTO_FS_RENAME'];
|
|
#$this->xx = $details['VALIDATEPROTOCOL'];
|
|
$this->hostname = $details['TCP_NAME'];
|
|
$this->ipaddr = $details['TCP_ADDRESS'];
|
|
#$this->xx = $details['GUID'];
|
|
$this->txngroupmax = $details['TXNGROUPMAX'];
|
|
#$this->xx = $details['DATAWRITEPATH'];
|
|
#$this->xx = $details['DATAREADPATH'];
|
|
#$this->xx = $details['SESSION_INITIATION'];
|
|
#$this->xx = $details['CLIENT_HLA'];
|
|
#$this->xx = $details['CLIENT_LLA'];
|
|
$this->group = $details['COLLOCGROUP_NAME'];
|
|
#$this->xx = $details['PROXY_TARGET'];
|
|
#$this->xx = $details['PROXY_AGENT'];
|
|
}
|
|
|
|
function addFileSpace($details) {
|
|
$this->fs[$details['FILESPACE_ID']] = new filesystem($details['FILESPACE_NAME']);
|
|
$this->fs[$details['FILESPACE_ID']]->setDetails($details);
|
|
}
|
|
|
|
function addOccupancy($details) {
|
|
$this->fs[$details->filespace_id]->setOccupancy($details);
|
|
}
|
|
|
|
function addVolumeUsage($details) {
|
|
$this->fs[$details['FILESPACE_ID']]->setVolumeUsage($details);
|
|
}
|
|
|
|
function getFileSystems() {
|
|
if (isset($this->fs))
|
|
return $this->fs;
|
|
else
|
|
return array();
|
|
}
|
|
|
|
/**
|
|
* Return a list of ALL STORAGE POOLS that this node has data in.
|
|
* @return: array (STORAGE POOL NAMES)
|
|
*/
|
|
function getStoragePools() {
|
|
$result = array();
|
|
|
|
if (isset($this->fs))
|
|
foreach ($this->fs as $fs => $object) {
|
|
$stgpools = $object->getStoragePools();
|
|
$result = array_unique(array_merge($result,$stgpools));
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of ALL VOLUMES that this node has data on.
|
|
* @return: array (VOLUME NAMES)
|
|
*/
|
|
function getVolumeUsage() {
|
|
$result = array();
|
|
|
|
if (isset($this->fs))
|
|
foreach ($this->fs as $fs => $object) {
|
|
$vols = $object->getVolumeUsage();
|
|
$result = array_unique(array_merge($result,$vols));
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of ALL PRIMARY VOLUMES that this node has data on.
|
|
* return: array (VOLUME OBJECTS)
|
|
*/
|
|
function getPrimaryVolumes($type='Bkup') {
|
|
$result = array();
|
|
|
|
if (isset($this->fs))
|
|
foreach ($this->fs as $fs => $object)
|
|
foreach ($object->getVolumes($type) as $stgp => $volumes)
|
|
foreach ($volumes as $volume)
|
|
if ($volume->isPrimaryVol())
|
|
$result[$volume->name] = $volume;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of ALL COPYPOOL VOLUMES that this node has data on.
|
|
* return: array (VOLUME OBJECTS)
|
|
*/
|
|
function getCopyVolumes($type='Bkup') {
|
|
$result = array();
|
|
|
|
if (isset($this->fs))
|
|
foreach ($this->fs as $fs => $object)
|
|
foreach ($object->getVolumes($type) as $stgp => $volumes)
|
|
foreach ($volumes as $volume)
|
|
if ($volume->isCopyVol())
|
|
$result[$volume->name] = $volume;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of ALL STORAGE POOLS by FILESYSTEM
|
|
* @return: array (FILE SYSTEM OBJECTS)
|
|
*/
|
|
function getFSOccupancy($type='Bkup') {
|
|
$result = array();
|
|
|
|
foreach ($this->fs as $fs => $object)
|
|
if (count($object->getOccupancy($type)))
|
|
$result[$fs] = $object;
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getVolumes($type='Bkup') {
|
|
$result = array();
|
|
|
|
foreach ($this->fs as $fs => $object)
|
|
if (count($object->getVolumes($type)))
|
|
$result[$fs] = $object;
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getOccupancy() {
|
|
$result = array();
|
|
|
|
if (isset($this->fs))
|
|
foreach ($this->fs as $fs => $object) {
|
|
if (isset($object->occupancy))
|
|
foreach ($object->occupancy as $type => $stgpools) {
|
|
foreach ($stgpools as $stgp => $details) {
|
|
@$result[$type][$stgp]['num'] += $details['num'];
|
|
@$result[$type][$stgp]['physical'] += $details['physical'];
|
|
@$result[$type][$stgp]['logical'] += $details['logical'];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getTapeVolumes($stgp,$type) {
|
|
$result = array();
|
|
|
|
if (! isset($this->fs))
|
|
return null;
|
|
|
|
foreach ($this->fs as $fsid => $fsobject) {
|
|
if (! isset($fsobject->volume))
|
|
continue;
|
|
|
|
foreach ($fsobject->getVolumesStgp($type,$stgp) as $vol => $voldetails)
|
|
$result[] = $voldetails;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
class occupant extends base {
|
|
function setDetails($details) {
|
|
$this->name = $details['NODE_NAME'];
|
|
$this->type = $details['TYPE'];
|
|
$this->filespace = $details['FILESPACE_NAME'];
|
|
$this->stgpool = $details['STGPOOL_NAME'];
|
|
$this->files['num'] = $details['NUM_FILES'];
|
|
$this->files['physical'] = $details['PHYSICAL_MB'];
|
|
$this->files['logical'] = $details['LOGICAL_MB'];
|
|
$this->filespace_id = $details['FILESPACE_ID'];
|
|
}
|
|
|
|
function getNode() {
|
|
return ($this->name);
|
|
}
|
|
|
|
function getStoragePool() {
|
|
return ($this->stgpool);
|
|
}
|
|
|
|
function getType() {
|
|
return ($this->type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class defines a volume.
|
|
*/
|
|
class storagePool extends base {
|
|
function storagePool($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
$this->type = $details['POOLTYPE'];
|
|
$this->devclass = $details['DEVCLASS'];
|
|
#$this->xx = $details['EST_CAPACITY_MB'];
|
|
#$this->xx = $details['TRIGGER_PCT_UTIL'];
|
|
$this->utilisation = $details['PCT_UTILIZED'];
|
|
$this->migratable = $details['PCT_MIGR'];
|
|
#$this->xx = $details['PCT_LOGICAL'];
|
|
$this->migr['hi'] = $details['HIGHMIG'];
|
|
$this->migr['low'] = $details['LOWMIG'];
|
|
#$this->xx = $details['MIGPROCESS'];
|
|
$this->nextstgp = $details['NEXTSTGPOOL'];
|
|
$this->maxsize = $details['MAXSIZE'];
|
|
$this->access = $details['ACCESS'];
|
|
#$this->xx = $details['DESCRIPTION'];
|
|
#$this->xx = $details['OVFLOCATION'];
|
|
$this->cache = $details['CACHE'];
|
|
$this->collocate = $details['COLLOCATE'];
|
|
$this->reclaim = $details['RECLAIM'];
|
|
$this->maxscratch = $details['MAXSCRATCH'];
|
|
#$this->xx = $details['NUMSCRATCHUSED'];
|
|
$this->reuse = $details['REUSEDELAY'] ? $details['REUSEDELAY'] : 0;
|
|
$this->migr['running'] = $details['MIGR_RUNNING'] == 'YES' ? true : false;
|
|
$this->migr['mb'] = $details['MIGR_MB'];
|
|
$this->migr['sec'] = $details['MIGR_SECONDS'];
|
|
$this->reclaimrunning = $details['RECL_RUNNING'] == 'YES' ? true : false;
|
|
#$this->xx = $details['CHG_TIME'];
|
|
#$this->xx = $details['CHG_ADMIN'];
|
|
$this->reclaimstgp = $details['RECLAIMSTGPOOL'];
|
|
#$this->xx = $details['MIGDELAY'];
|
|
#$this->xx = $details['MIGCONTINUE'];
|
|
#$this->xx = $details['DATAFORMAT'];
|
|
#$this->xx = $details['COPYSTGPOOLS'];
|
|
#$this->xx = $details['COPYCONTINUE'];
|
|
#$this->xx = $details['CRCDATA'];
|
|
#$this->xx = $details['RECLAIMPROCESS'];
|
|
}
|
|
|
|
function isPrimaryPool() {
|
|
if ($this->type == 'PRIMARY')
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isCopyPool() {
|
|
if ($this->type == 'COPY')
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function getReclaim() {
|
|
return $this->reclaim;
|
|
}
|
|
|
|
function getReUse() {
|
|
return $this->reuse;
|
|
}
|
|
}
|
|
|
|
class summary extends base {
|
|
function summary($name) {
|
|
$this->name = $name;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
#$this->xx = $details['LAST_UPDATE'];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class defines a volume.
|
|
*/
|
|
class volume extends base {
|
|
function volume($name,$server) {
|
|
$this->name = $name;
|
|
$this->index = $server;
|
|
}
|
|
|
|
function setDetails($details) {
|
|
$this->stgpool = isset($details['STGPOOL_NAME']) ? $details['STGPOOL_NAME'] : null;
|
|
$this->devclass = isset($details['DEVCLASS_NAME']) ? $details['DEVCLASS_NAME'] : null;
|
|
$this->estcap = isset($details['EST_CAPACITY_MB']) ? $details['EST_CAPACITY_MB'] : null;
|
|
$this->utilisation = isset($details['PCT_UTILIZED']) ? $details['PCT_UTILIZED'] : null;
|
|
$this->status['volume'] = isset($details['STATUS']) ? $details['STATUS'] : null;
|
|
$this->access = isset($details['ACCESS']) ? $details['ACCESS'] : null;
|
|
$this->reclaim = isset($details['PCT_RECLAIM']) ? $details['PCT_RECLAIM'] : null;
|
|
$this->scratch = isset($details['SCRATCH']) ? ($details['SCRATCH'] == 'YES' ? true : false) : null;
|
|
$this->mounted = isset($details['TIMES_MOUNTED']) ? $details['TIMES_MOUNTED'] : null;
|
|
$this->writepass = isset($details['WRITE_PASS']) ? $details['WRITE_PASS'] : null;
|
|
$this->last['read'] = isset($details['LAST_READ_DATE']) ? $details['LAST_READ_DATE'] : null;
|
|
$this->last['write'] = isset($details['LAST_WRITE_DATE']) ? $details['LAST_WRITE_DATE'] : null;
|
|
$this->pending['start'] = isset($details['PENDING_DATE']) ? $details['PENDING_DATE'] : null;
|
|
$this->error['read'] = isset($details['READ_ERRORS']) ? $details['READ_ERRORS'] : null;
|
|
$this->error['write'] = isset($details['WRITE_ERRORS']) ? $details['WRITE_ERRORS'] : null;
|
|
$this->error['status'] = isset($details['ERROR_STATE']) ? $details['ERROR_STATE'] : null;
|
|
$this->location = isset($details['LOCATION']) ? $details['LOCATION'] : null;
|
|
#$this->xx = $details['SCALEDCAP_APPLIED'];
|
|
#$this->xx = $details['NUM_SIDES'];
|
|
#$this->xx = $details['MVSLF_CAPABLE'];
|
|
#$this->xx = $details['CHG_TIME'];
|
|
#$this->xx = $details['CHG_ADMIN'];
|
|
#$this->xx = $details['BEGIN_RCLM_DATE'];
|
|
#$this->xx = $details['END_RCLM_DATE'];
|
|
}
|
|
|
|
function setLibrary($details) {
|
|
$this->setLibraryName($details['LIBRARY_NAME']);
|
|
$this->status['library'] = $details['STATUS'];
|
|
$this->lib['owner'] = $details['OWNER'];
|
|
$this->lib['use'] = $details['LAST_USE'];
|
|
$this->lib['element'] = $details['HOME_ELEMENT'];
|
|
#$this->xx = $details['CLEANINGS_LEFT'];
|
|
#$this->xx = $details['DEVTYPE'];
|
|
#$this->xx = $details['MEDIATYPE'];
|
|
}
|
|
|
|
function setDBBackup($details) {
|
|
$this->dbv['date'] = $details['DATE_TIME'];
|
|
$this->dbv['type'] = $details['TYPE'];
|
|
$this->dbv['series'] = $details['BACKUP_SERIES'];
|
|
$this->dbv['operation'] = $details['BACKUP_OPERATION'];
|
|
$this->dbv['sequence'] = $details['VOLUME_SEQ'];
|
|
$this->devclass = $details['DEVCLASS'];
|
|
$this->location = $details['LOCATION'];
|
|
#$this->xx = $details['UNIQUE'];
|
|
#$this->xx = $details['COMMAND'];
|
|
}
|
|
|
|
/**
|
|
* Is volume in library
|
|
*/
|
|
function inLibrary() {
|
|
if (isset($this->lib['name']) && ! is_null($this->lib['name']))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function inLibraryName($library) {
|
|
if ($this->inLibrary() && $this->lib['name'] == $library)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isPrimaryVol() {
|
|
if (isset($this->stgpool))
|
|
return isPrimaryPool($this->stgpool);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isCopyVol() {
|
|
if (isset($this->stgpool))
|
|
return isCopyPool($this->stgpool);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isReadWrite() {
|
|
if (isset($this->access))
|
|
return $this->access == 'READWRITE' ? true : false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function isOutOfLibrary() {
|
|
if (! $this->inLibrary() && LibraryDevClass($this->devclass))
|
|
return true;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function isOffSite() {
|
|
if (isset($this->access))
|
|
return $this->access == 'OFFSITE' ? true : false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function isPending() {
|
|
if (isset($this->status['volume']))
|
|
if ($this->status['volume'] == 'PENDING') {
|
|
$start = strtotime(tsmDate($this->pending['start'],'nomsec'));
|
|
$end = $start + getReUse($this->stgpool)*86400;
|
|
$this->pending['end'] = strftime('%Y-%m-%d %H:%M:%S',$end);
|
|
return true;
|
|
} else
|
|
return false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function isEmpty() {
|
|
if (isset($this->status['volume']))
|
|
return $this->status['volume'] == 'EMPTY' ? true : false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function tobeReclaimed() {
|
|
if (isset($this->reclaim))
|
|
return $this->reclaim > getReclaim($this->stgpool) ? true : false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function hasWriteErrors() {
|
|
if (isset($this->error['write']))
|
|
return $this->error['write'] ? true : false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function hasReadErrors() {
|
|
if (isset($this->error['read']))
|
|
return $this->error['read'] ? true : false;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function lastWrite() {
|
|
if (isset($this->last['write']) && trim($this->last['write']))
|
|
return strtotime(tsmDate($this->last['write'],'notime'));
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function lastRead() {
|
|
if (isset($this->last['read']) && trim($this->last['read']))
|
|
return strtotime(tsmDate($this->last['read'],'notime'));
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function setLibraryName($name) {
|
|
$this->lib['name'] = $name;
|
|
}
|
|
|
|
function setSlot($slot) {
|
|
$this->lib['slot'] = $slot;
|
|
}
|
|
|
|
function getSlot() {
|
|
if (isset($this->lib['slot']))
|
|
return $this->lib['slot'];
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getLocation() {
|
|
if (isset($this->location))
|
|
return $this->location;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getStoragePool() {
|
|
if (isset($this->stgpool))
|
|
return $this->stgpool;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function isLibraryEmpty() {
|
|
if ($this->inLibrary() && isset($this->status['volume']) && $this->status['volume'] == 'EMPTY')
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isLibraryPending() {
|
|
if ($this->inLibrary() && isset($this->status['volume']) && $this->status['volume'] == 'PENDING')
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isLibraryScratch() {
|
|
if ($this->inLibrary() && $this->status['library'] == 'Scratch')
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function isScratch() {
|
|
if ($this->scratch)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function inElement($library,$element) {
|
|
if ($this->inLibraryName($library) && $this->lib['element'] == $element)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class xtsm extends tsm {
|
|
# Record when information retrieved from TSM
|
|
public $cache = null;
|
|
|
|
# Our TSM Server
|
|
protected $server = null;
|
|
|
|
function expired() {
|
|
if ($this->cache+$_SESSION[APPCONFIG]->getValue('cache','time')< time() || (isset($this->expired) && $this->expired))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class deviceClasses extends xtsm {
|
|
var $devclasses = array();
|
|
|
|
function deviceClasses($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our devclass info.
|
|
function load() {
|
|
$this->devclasses = array();
|
|
|
|
# Get our defined device classes.
|
|
$result = $this->server->query('select * from DEVCLASSES',null,'DEVCLASS_NAME');
|
|
if ($result) {
|
|
foreach ($result as $devc => $details) {
|
|
$this->devclasses[$devc] = new deviceClass($devc);
|
|
$this->devclasses[$devc]->setDetails($details);
|
|
}
|
|
}
|
|
}
|
|
|
|
function isLibraryDevClass($devclass) {
|
|
if (isset($this->devclasses[$devclass]))
|
|
return $this->devclasses[$devclass]->isLibraryDevClass();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function LibraryDevClass($devclass) {
|
|
if (isset($this->devclasses[$devclass]))
|
|
return $this->devclasses[$devclass]->LibraryDevClass();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getDevClasses() {
|
|
return $this->devclasses;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class defines all drives.
|
|
*/
|
|
class drives extends xtsm {
|
|
var $drives = array();
|
|
|
|
function drives($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our drive info.
|
|
function load() {
|
|
$this->drives = array();
|
|
|
|
# Get our defined drives.
|
|
$result = $this->server->query('select * from DRIVES',null,'DRIVE_NAME');
|
|
if ($result) {
|
|
foreach ($result as $drive => $details) {
|
|
$this->drives[$drive] = new drive($drive);
|
|
$this->drives[$drive]->setDetails($details);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getDrives($library) {
|
|
$result = array();
|
|
|
|
foreach ($this->drives as $drive => $object) {
|
|
if ($object->inLibraryName($library))
|
|
$result[$drive] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
# Get TSM Help
|
|
class help extends xtsm {
|
|
function help($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our help info.
|
|
function load() {
|
|
$this->commands = $this->server->query('help',null);
|
|
}
|
|
|
|
function getCommands() {
|
|
return $this->commands;
|
|
}
|
|
|
|
function getCommand($command) {
|
|
$helpText = new helpText($command);
|
|
$commandHelp = $this->server->query("help $command",null);
|
|
$helpText->raw = $commandHelp;
|
|
|
|
# Skip the two lines, its just the command again.
|
|
array_shift($commandHelp);
|
|
array_shift($commandHelp);
|
|
|
|
# The 2nd line is the command description.
|
|
$helpText->addTitle(array_shift($commandHelp));
|
|
array_shift($commandHelp);
|
|
$mode = 'description';
|
|
|
|
# Work through the output.
|
|
foreach ($commandHelp as $line) {
|
|
if (preg_match('/^Privilege Class$/',$line))
|
|
$mode = 'class';
|
|
elseif (preg_match('/^Syntax$/',$line))
|
|
$mode = 'syntax';
|
|
elseif (preg_match('/^Parameters$/',$line))
|
|
$mode = 'parameter';
|
|
elseif (preg_match('/^Examples$/',$line))
|
|
$mode = 'example';
|
|
elseif (preg_match('/^Related Commands$/',$line))
|
|
$mode = 'related';
|
|
|
|
if (! isset($skip[$mode]))
|
|
$skip[$mode] = 1;
|
|
else
|
|
$skip[$mode]++;
|
|
|
|
# Cut out the 2nd or more blank lines.
|
|
if (trim($line))
|
|
$isBlank[$mode] = false;
|
|
|
|
if ((! trim($line)) && isset($isBlank[$mode]) && $isBlank[$mode])
|
|
continue;
|
|
elseif (! trim($line))
|
|
$isBlank[$mode] = true;
|
|
|
|
switch ($mode) {
|
|
case 'description' : $helpText->addDescription($line);
|
|
break;
|
|
case 'class' : if ($skip[$mode] > 2)
|
|
$helpText->addClass($line);
|
|
break;
|
|
case 'syntax' : if ($skip[$mode] > 2)
|
|
$helpText->addSyntax($line);
|
|
break;
|
|
case 'parameter' : if ($skip[$mode] > 2)
|
|
$helpText->addParameter($line);
|
|
break;
|
|
case 'example' : $helpText->addExample($line);
|
|
break;
|
|
case 'related' : if ($skip[$mode] > 4)
|
|
$helpText->addRelated($line);
|
|
break;
|
|
default : debug_dump("Unknown Text [$line]",1);
|
|
}
|
|
}
|
|
|
|
return $helpText;
|
|
// debug_dump(array('command'=>$command,'commandHelp'=>$commandHelp,'helpText'=>$helpText),1);
|
|
}
|
|
}
|
|
|
|
class libraries extends xtsm {
|
|
# Our libraries.
|
|
var $libraries = array();
|
|
|
|
function libraries($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our library info.
|
|
function load() {
|
|
debug_log(sprintf('%s::load(): Entered (%s).',get_class($this),$this->cache),1);
|
|
|
|
$this->libraries = array();
|
|
|
|
$result = $this->server->query('select * from LIBRARIES',null,'LIBRARY_NAME');
|
|
if ($result) {
|
|
foreach ($result as $library => $details) {
|
|
if (! isset($this->libraries[$library]))
|
|
$this->libraries[$library] = new library($library,$this->server->index);
|
|
|
|
$this->libraries[$library]->setLibrary($details);
|
|
}
|
|
}
|
|
|
|
# Add our volumes & drives
|
|
objectCache('volumes');
|
|
objectCache('drives');
|
|
foreach ($this->libraries as $library) {
|
|
# Does this library support show slots?
|
|
if (in_array($library->type,array('SCSI'))) {
|
|
$result = $this->server->query(sprintf('show slots %s',$library->name),null,'Library');
|
|
|
|
if (! count($result)) {
|
|
error(sprintf('querying library %s didnt return any information - is the library operational?',$library->name),'error',false);
|
|
$this->expired = true;
|
|
}
|
|
|
|
if (isset($result[$library->name])) {
|
|
$this->libraries[$library->name]->addSlots($result[$library->name]['SlotUsage']);
|
|
$this->libraries[$library->name]->setAttr('ProductId',$result[$library->name]['Product Id']);
|
|
#$this->libraries[$library->name]->setAttr('xx',$result[$library->name]['Support module']);
|
|
#$this->libraries[$library->name]->setAttr('xx',$result[$library->name]['Mount count']);
|
|
$this->libraries[$library->name]->setAttr('Drives',$result[$library->name]['Drives']);
|
|
$this->libraries[$library->name]->setAttr('Slots',$result[$library->name]['Slots']);
|
|
$this->libraries[$library->name]->setAttr('Changers',$result[$library->name]['Changers']);
|
|
$this->libraries[$library->name]->setAttr('IO',$result[$library->name]['Import/Exports']);
|
|
#$this->libraries[$library->name]->setAttr('xx',$result[$library->name]['Device']);
|
|
}
|
|
|
|
$this->libraries[$library->name]->addVolumes($_SESSION['cache'][$this->server->index]['volumes']->libraryVolumes($library->name));
|
|
$this->libraries[$library->name]->addDrives($_SESSION['cache'][$this->server->index]['drives']->getDrives($library->name));
|
|
}
|
|
}
|
|
}
|
|
|
|
function libVolumes($checkedin=true) {
|
|
$result = array();
|
|
|
|
$volumes = objectCache('volumes');
|
|
|
|
foreach ($this->libraries as $library) {
|
|
foreach ($library->slotVolumes($checkedin) as $element => $details) {
|
|
$result[$library->name][$element] = $volumes->getVolume($details['barcodelabel']);
|
|
$result[$library->name][$element]->setSlot($details['slot']);
|
|
$result[$library->name][$element]->setDetails($details);
|
|
$result[$library->name][$element]->setLibraryName($library->name);
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getLibraries() {
|
|
return $this->libraries;
|
|
}
|
|
}
|
|
|
|
class mgmtClasses extends xtsm {
|
|
var $copygroups = array();
|
|
var $mgmtclasses = array();
|
|
|
|
function __construct() {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our devclass info.
|
|
function load() {
|
|
$this->copygroups = array();
|
|
$this->mgmtclasses = array();
|
|
|
|
# Get our defined mgmt classes
|
|
$result = $this->server->query(sprintf("select * from MGMTCLASSES where SET_NAME='%s'",'ACTIVE'),null);
|
|
if ($result) {
|
|
foreach ($result as $id => $details) {
|
|
$this->mgmtclasses[$id] = new mgmtClass($id);
|
|
$this->mgmtclasses[$id]->setDetails($details);
|
|
}
|
|
}
|
|
|
|
# Get our defined copy groups
|
|
# Copygroup name is always STANDARD
|
|
$result = $this->server->query(sprintf("select * from BU_COPYGROUPS where SET_NAME='%s' and COPYGROUP_NAME='%s'",'ACTIVE','STANDARD'),null);
|
|
if ($result) {
|
|
foreach ($result as $id => $details) {
|
|
$this->copygroups[$id] = new copyGroupBackup($id);
|
|
$this->copygroups[$id]->setDetails($details);
|
|
|
|
# Set the default mgmtclass
|
|
if ($this->isDefaultMgmtClass($this->copygroups[$id]->name))
|
|
$this->copygroups[$id]->setDefaultMgmtClass();
|
|
}
|
|
}
|
|
|
|
$result = $this->server->query(sprintf("select * from AR_COPYGROUPS where SET_NAME='%s' and COPYGROUP_NAME='%s'",'ACTIVE','STANDARD'),null);
|
|
if ($result) {
|
|
foreach ($result as $id => $details) {
|
|
$this->copygroups[$id] = new copyGroupArchive($id);
|
|
$this->copygroups[$id]->setDetails($details);
|
|
|
|
# Set the default mgmtclass
|
|
if ($this->isDefaultMgmtClass($this->copygroups[$id]->name))
|
|
$this->copygroups[$id]->setDefaultMgmtClass();
|
|
}
|
|
}
|
|
}
|
|
|
|
private function getMgmtClass($name) {
|
|
foreach ($this->mgmtclasses as $mgmtclass)
|
|
if ($mgmtclass->name == $name)
|
|
return $mgmtclass;
|
|
}
|
|
|
|
private function isDefaultMgmtClass($name) {
|
|
$mgmtclass = $this->getMgmtClass($name);
|
|
|
|
if ($mgmtclass)
|
|
return $mgmtclass->default;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
private function getCopyGroup($domain,$mgmtclass,$type='Bkup') {
|
|
foreach ($this->copygroups as $copygroup)
|
|
if ($copygroup->domain == $domain && $copygroup->name == $mgmtclass && $copygroup->type == $type)
|
|
return $copygroup;
|
|
|
|
return null;
|
|
}
|
|
|
|
public function getMgmtClasses($domain,$type='Bkup') {
|
|
$result = array();
|
|
|
|
foreach ($this->mgmtclasses as $mgmtclass) {
|
|
if ($mgmtclass->domain == $domain)
|
|
$result[$mgmtclass->name] = $this->getCopyGroup($mgmtclass->domain,$mgmtclass->name,$type);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
class nodes extends xtsm {
|
|
var $nodes = array();
|
|
|
|
function nodes($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our node info.
|
|
function load() {
|
|
$this->nodes= array();
|
|
$occupancy = objectcache('occupancy');
|
|
|
|
# Get our defined nodes.
|
|
$result = $this->server->query('select * from NODES',null,'NODE_NAME');
|
|
if ($result) {
|
|
foreach ($result as $node => $details) {
|
|
$this->nodes[$node] = new node($node);
|
|
$this->nodes[$node]->setDetails($details);
|
|
}
|
|
}
|
|
|
|
# Get the file systems.
|
|
$result = $this->server->query('select * from FILESPACES',null);
|
|
if ($result)
|
|
foreach ($result as $details)
|
|
$this->nodes[$details['NODE_NAME']]->addFileSpace($details);
|
|
|
|
# Get the file systems occupancy.
|
|
foreach ($this->getNodes() as $node) {
|
|
foreach ($occupancy->getOccupancy($node->name) as $details)
|
|
$this->nodes[$node->name]->addOccupancy($details);
|
|
}
|
|
|
|
# Get the volume usage.
|
|
$result = $this->server->query('select * from VOLUMEUSAGE',null);
|
|
if ($result)
|
|
foreach ($result as $details)
|
|
$this->nodes[$details['NODE_NAME']]->addVolumeUsage($details);
|
|
}
|
|
|
|
function getNodes() {
|
|
return $this->nodes;
|
|
}
|
|
|
|
function getNode($node) {
|
|
if (isset($this->nodes[$node]))
|
|
return $this->nodes[$node];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class obtains storage pool occupancy
|
|
*/
|
|
class occupancy extends xtsm {
|
|
var $occupancy = array();
|
|
|
|
function occupancy($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our drive info.
|
|
function load() {
|
|
$this->occupancy = array();
|
|
$count = 0;
|
|
|
|
# Get our defined drives.
|
|
$result = $this->server->query('select * from OCCUPANCY',null);
|
|
if ($result) {
|
|
foreach ($result as $details) {
|
|
$this->occupancy[$count] = new occupant();
|
|
$this->occupancy[$count]->setDetails($details);
|
|
$count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
function getOccupancy($node) {
|
|
$result = array();
|
|
|
|
foreach ($this->occupancy as $details) {
|
|
if ($details->getNode() == $node)
|
|
$result[] = $details;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getStoragePoolTotals($stgp) {
|
|
$result = array();
|
|
|
|
foreach ($this->occupancy as $details) {
|
|
if ($details->getStoragePool() == $stgp) {
|
|
@$result[$details->getNode()][$details->getType()]['files'] = $details->files['num'];
|
|
@$result[$details->getNode()][$details->getType()]['physical'] = $details->files['physical'];
|
|
@$result[$details->getNode()][$details->getType()]['logical'] = $details->files['logical'];
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class defines all storage pools.
|
|
*/
|
|
class storagePools extends xtsm {
|
|
var $stgpools = array();
|
|
|
|
function storagePools($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our storagepool info.
|
|
function load() {
|
|
$this->stgpools = array();
|
|
|
|
# Get our defined storagepools.
|
|
$result = $this->server->query('select * from STGPOOLS',null,'STGPOOL_NAME');
|
|
if ($result) {
|
|
foreach ($result as $stgp => $details) {
|
|
$this->stgpools[$stgp] = new storagePool($stgp);
|
|
$this->stgpools[$stgp]->setDetails($details);
|
|
}
|
|
}
|
|
}
|
|
|
|
function isPrimaryPool($pool) {
|
|
if (isset($this->stgpools[$pool]))
|
|
return $this->stgpools[$pool]->isPrimaryPool();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function isCopyPool($pool) {
|
|
if (isset($this->stgpools[$pool]))
|
|
return $this->stgpools[$pool]->isCopyPool();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getReclaim($pool) {
|
|
if (isset($this->stgpools[$pool]))
|
|
return $this->stgpools[$pool]->getReclaim();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getReUse($pool) {
|
|
if (isset($this->stgpools[$pool]))
|
|
return $this->stgpools[$pool]->getReUse();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
function getStoragePools() {
|
|
return $this->stgpools;
|
|
}
|
|
|
|
function ifExist($pool) {
|
|
if (isset($this->stgpools[$pool]))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function getStoragePool($pool) {
|
|
if (isset($this->stgpools[$pool]))
|
|
return $this->stgpools[$pool];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class summaryInfo extends xtsm {
|
|
# Our summary info.
|
|
var $summaryInfo = array();
|
|
|
|
public function __construct($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our summary info.
|
|
public function load() {
|
|
$this->summaryInfo = $this->server->query('select START_TIME,END_TIME,ACTIVITY,ENTITY,SCHEDULE_NAME,SUCCESSFUL,MEDIAW,VOLUME_NAME,DRIVE_NAME,BYTES,LAST_USE,AFFECTED,NUMBER,EXAMINED,AFFECTED,FAILED,BYTES,IDLE from SUMMARY order by START_TIME,END_TIME',null);
|
|
}
|
|
|
|
# Show media actions in the summary table.
|
|
function mediaActions($list=false) {
|
|
$result = array();
|
|
|
|
foreach ($this->summaryInfo as $index => $details) {
|
|
if (trim($details['MEDIAW']) || $details['BYTES'] || $details['AFFECTED'])
|
|
$result[$details['ACTIVITY']][$index] = $details;
|
|
}
|
|
|
|
if ($list)
|
|
return array_keys($result);
|
|
else
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Get the range of dates available for the summary table
|
|
*/
|
|
public function getSummaryRange() {
|
|
$sum['start'] = null;
|
|
$sum['end'] = null;
|
|
|
|
foreach ($this->summaryInfo as $index => $details) {
|
|
if (($details['START_TIME'] < $sum['start']) || is_null($sum['start']))
|
|
$sum['start'] = $details['START_TIME'];
|
|
|
|
if (($details['END_TIME'] > $sum['end']) || is_null($sum['end']))
|
|
$sum['end'] = $details['END_TIME'];
|
|
}
|
|
|
|
$sum['starti'] = strtotime(tsmDate($sum['start'],'notime'));
|
|
$sum['endi'] = strtotime(tsmDate($sum['end'],'notime'));
|
|
|
|
for ($i=$sum['starti']; $i <= $sum['endi']; $i+=86400) {
|
|
$sum['date'][] = date('Y-m-d',$i);
|
|
}
|
|
|
|
return $sum['date'];
|
|
}
|
|
|
|
function getSummary($start,$end) {
|
|
$result = array();
|
|
|
|
foreach ($this->summaryInfo as $index => $details) {
|
|
$sum['start'] = tsmDate($details['START_TIME'],'notime');
|
|
$sum['end'] = tsmDate($details['END_TIME'],'notime');
|
|
if (($sum['start'] >= $start && ! trim($sum['end'])) ||
|
|
($sum['start'] >= $start && $sum['end'] <= $end) ||
|
|
(! trim($sum['start']) && $sum['end'] <= $end))
|
|
|
|
$result[$index] = $details;
|
|
}
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class defines all volumes.
|
|
*/
|
|
class volumes extends xtsm {
|
|
# Our volumes.
|
|
var $volumes = array();
|
|
|
|
function volumes($server) {
|
|
global $app;
|
|
|
|
$this->server = $app['server'];
|
|
$this->load();
|
|
}
|
|
|
|
# Load our media info.
|
|
function load() {
|
|
$this->volumes = array();
|
|
|
|
# Get our defined volumes.
|
|
$result = $this->server->query('select * from VOLUMES',null,'VOLUME_NAME');
|
|
if ($result) {
|
|
foreach ($result as $volume => $details) {
|
|
$this->volumes[$volume] = new volume($volume,$this->server->index);
|
|
$this->volumes[$volume]->setDetails($details);
|
|
}
|
|
}
|
|
|
|
# Get our library volumes.
|
|
$result = $this->server->query('select * from LIBVOLUMES',null,'VOLUME_NAME');
|
|
if ($result) {
|
|
foreach ($result as $volume => $details) {
|
|
if (! isset($this->volumes[$volume]))
|
|
$this->volumes[$volume] = new volume($volume,$this->server->index);
|
|
|
|
$this->volumes[$volume]->setLibrary($details);
|
|
}
|
|
}
|
|
|
|
# Get our DB volumes.
|
|
$result = $this->server->query("select * from VOLHISTORY where TYPE in ('BACKUPFULL','BACKUPINCR','DBSNAPSHOT') order by BACKUP_SERIES,BACKUP_OPERATION,VOLUME_SEQ",null,'VOLUME_NAME');
|
|
if ($result) {
|
|
foreach ($result as $volume => $details) {
|
|
$this->volumes[$volume] = new volume($volume,$this->server->index);
|
|
$this->volumes[$volume]->setDBBackup($details);
|
|
$this->volumes[$volume]->setDetails($details);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a list of COPY POOL volumes that are in the library
|
|
*/
|
|
function libCopyVolumes($inlib) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object)
|
|
if ($object->isCopyVol() && isLibraryDevclass($object->devclass) && ($object->inLibrary() == $inlib))
|
|
$result[$volume] = $object;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of NON READ/WRITE volumes that need to be fixed.
|
|
*/
|
|
function nonReadWriteVolumes() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if (! $object->isReadWrite() && ! is_null($object->isReadWrite()) && ! $object->isOffSite() &&
|
|
! $object->isOutOfLibrary())
|
|
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of volumes that should be RECLAIMed.
|
|
*/
|
|
function reclaimVolumes() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->tobeReclaimed())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of volumes that have had errors.
|
|
*/
|
|
function errorVolumes() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->hasReadErrors() || $object->hasWriteErrors())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of volumes that have not been read/written to for a long time.
|
|
*/
|
|
function staleVolumes($days=0) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ((! is_null($object->lastRead()) && ($object->lastRead() + $days*86400) < time()) ||
|
|
(! is_null($object->lastWrite()) && ($object->lastWrite() + $days*86400) < time())) {
|
|
$result[$volume] = $object;
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of volumes that are PENDING.
|
|
*/
|
|
function pendingVolumes() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->isPending())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Return a list of volumes that are EMPTY.
|
|
*/
|
|
function emptyVolumes() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->isEmpty())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function libraryVolumes($library) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->inLibraryName($library))
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getVolume($volume) {
|
|
if (isset($this->volumes[$volume]))
|
|
return $this->volumes[$volume];
|
|
else
|
|
return new volume('Unknown Label',$this->server->index);
|
|
}
|
|
|
|
function primaryNotInLib() {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->isOutOfLibrary() && $object->isPrimaryVol())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getStoragePoolVolumes($stgp) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if (isset($object->stgpool) && $object->stgpool == $stgp)
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getStoragePoolScratchVolumes($stgp) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if (isset($object->stgpool) && $object->stgpool == $stgp && $object->isScratch())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getStoragePoolDefinedVolumes($stgp) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if (isset($object->stgpool) && $object->stgpool == $stgp && ! $object->isScratch())
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getStoragePoolVolumesStatus($stgp,$status) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if (isset($object->stgpool) && $object->stgpool == $stgp && $object->status['volume'] == $status)
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function getStoragePoolVolumesAccess($stgp,$access) {
|
|
$result = array();
|
|
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if (isset($object->stgpool) && $object->stgpool == $stgp && $object->access == $access)
|
|
$result[$volume] = $object;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function inElement($library,$element) {
|
|
foreach ($this->volumes as $volume => $object) {
|
|
if ($object->inElement($library,$element))
|
|
return $object->name;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
?>
|