def fetch_statistics(self):
"""
Loads statistics from this vDisk - returns unprocessed data
"""
# Load data from volumedriver
if self.volume_id and self.vpool:
try:
vdiskstats = self.storagedriver_client.statistics_volume(str(self.volume_id))
vdiskinfo = self.storagedriver_client.info_volume(str(self.volume_id))
except:
vdiskstats = StorageDriverClient.empty_statistics()
vdiskinfo = StorageDriverClient.empty_info()
else:
vdiskstats = StorageDriverClient.empty_statistics()
vdiskinfo = StorageDriverClient.empty_info()
# Load volumedriver data in dictionary
vdiskstatsdict = {}
try:
pc = vdiskstats.performance_counters
vdiskstatsdict['backend_data_read'] = pc.backend_read_request_size.sum()
vdiskstatsdict['backend_data_written'] = pc.backend_write_request_size.sum()
vdiskstatsdict['backend_read_operations'] = pc.backend_read_request_size.events()
vdiskstatsdict['backend_write_operations'] = pc.backend_write_request_size.events()
vdiskstatsdict['data_read'] = pc.read_request_size.sum()
vdiskstatsdict['data_written'] = pc.write_request_size.sum()
vdiskstatsdict['read_operations'] = pc.read_request_size.events()
vdiskstatsdict['write_operations'] = pc.write_request_size.events()
for key in ['cluster_cache_hits', 'cluster_cache_misses', 'metadata_store_hits',
'metadata_store_misses', 'sco_cache_hits', 'sco_cache_misses']:
vdiskstatsdict[key] = getattr(vdiskstats, key)
# Do some more manual calculations
block_size = vdiskinfo.lba_size * vdiskinfo.cluster_multiplier
if block_size == 0:
block_size = 4096
vdiskstatsdict['4k_read_operations'] = vdiskstatsdict['data_read'] / block_size
vdiskstatsdict['4k_write_operations'] = vdiskstatsdict['data_written'] / block_size
# Precalculate sums
for key, items in StorageDriverClient.stat_sums.iteritems():
vdiskstatsdict[key] = 0
for item in items:
vdiskstatsdict[key] += vdiskstatsdict[item]
except:
pass
return vdiskstatsdict
def _statistics(self, dynamic):
"""
Fetches the Statistics for the vDisk.
"""
client = StorageDriverClient()
volatile = VolatileFactory.get_client()
prev_key = '{0}_{1}'.format(self._key, 'statistics_previous')
# Load data from volumedriver
if self.volume_id and self.vpool:
try:
vdiskstats = self.storagedriver_client.statistics_volume(
str(self.volume_id))
except:
vdiskstats = client.empty_statistics()
else:
vdiskstats = client.empty_statistics()
# Load volumedriver data in dictionary
vdiskstatsdict = {}
for key, value in vdiskstats.__class__.__dict__.items():
if type(value) is property and key in client.stat_counters:
vdiskstatsdict[key] = getattr(vdiskstats, key)
# Precalculate sums
for key, items in client.stat_sums.iteritems():
vdiskstatsdict[key] = 0
for item in items:
vdiskstatsdict[key] += vdiskstatsdict[item]
vdiskstatsdict['timestamp'] = time.time()
# Calculate delta's based on previously loaded dictionary
previousdict = volatile.get(prev_key, default={})
for key in vdiskstatsdict.keys():
if key in client.stat_keys:
delta = vdiskstatsdict['timestamp'] - previousdict.get(
'timestamp', vdiskstatsdict['timestamp'])
if delta < 0:
vdiskstatsdict['{0}_ps'.format(key)] = 0
elif delta == 0:
vdiskstatsdict['{0}_ps'.format(key)] = previousdict.get(
'{0}_ps'.format(key), 0)
else:
vdiskstatsdict['{0}_ps'.format(key)] = max(
0, (vdiskstatsdict[key] - previousdict[key]) / delta)
volatile.set(prev_key, vdiskstatsdict, dynamic.timeout * 10)
# Returning the dictionary
return vdiskstatsdict
def _statistics(self, dynamic):
"""
Fetches the Statistics for the vDisk.
"""
volatile = VolatileFactory.get_client()
prev_key = '{0}_{1}'.format(self._key, 'statistics_previous')
# Load data from volumedriver
if self.volume_id and self.vpool:
try:
vdiskstats = self.storagedriver_client.statistics_volume(str(self.volume_id))
except:
vdiskstats = StorageDriverClient.empty_statistics()
else:
vdiskstats = StorageDriverClient.empty_statistics()
# Load volumedriver data in dictionary
vdiskstatsdict = {}
for key, value in vdiskstats.__class__.__dict__.items():
if type(value) is property and key in StorageDriverClient.stat_counters:
vdiskstatsdict[key] = getattr(vdiskstats, key)
# Precalculate sums
for key, items in StorageDriverClient.stat_sums.iteritems():
vdiskstatsdict[key] = 0
for item in items:
vdiskstatsdict[key] += vdiskstatsdict[item]
vdiskstatsdict['timestamp'] = time.time()
# Calculate delta's based on previously loaded dictionary
previousdict = volatile.get(prev_key, default={})
for key in vdiskstatsdict.keys():
if key in StorageDriverClient.stat_keys:
delta = vdiskstatsdict['timestamp'] - previousdict.get('timestamp',
vdiskstatsdict['timestamp'])
if delta < 0:
vdiskstatsdict['{0}_ps'.format(key)] = 0
elif delta == 0:
vdiskstatsdict['{0}_ps'.format(key)] = previousdict.get('{0}_ps'.format(key), 0)
else:
vdiskstatsdict['{0}_ps'.format(key)] = max(0, (vdiskstatsdict[key] - previousdict[key]) / delta)
volatile.set(prev_key, vdiskstatsdict, dynamic.timeout * 10)
# Returning the dictionary
return vdiskstatsdict
