def _stopRecordingFull(self, handle, location, lastTstamp, delayedStop): sink = self.get_element('fdsink') if sink.get_state() == gst.STATE_NULL: sink.set_state(gst.STATE_READY) if handle: handle.flush() sink.emit('remove', handle.fileno()) self._recordingStopped(handle, location) handle = None if not delayedStop: self.uiState.set('filename', None) self.uiState.set('recording', False) try: size = formatting.formatStorage(os.stat(location).st_size) except EnvironmentError, e: self.debug("Failed to stat %s: %s", location, log.getExceptionMessage(e)) # catch File not found, permission denied, disk problems size = "unknown" # Limit number of entries on filelist, remove the oldest entry fl = self.uiState.get('filelist', otherwise=[]) if FILELIST_SIZE == len(fl): self.uiState.remove('filelist', fl[0]) self.uiState.append('filelist', (lastTstamp, location, size)) if not delayedStop and self._symlinkToLastRecording: self._updateSymlink(location, self._symlinkToLastRecording)
def get_pipeline_string(self, properties): directory = properties['directory'] self.directory = directory self.fixRenamedProperties(properties, [('rotateType', 'rotate-type')]) rotateType = properties.get('rotate-type', 'none') # now act on the properties if rotateType == 'size': self.setSizeRotate(properties['size']) self.uiState.set('rotate-type', 'every %sB' % \ formatting.formatStorage(properties['size'])) elif rotateType == 'time': self.setTimeRotate(properties['time']) self.uiState.set('rotate-type', 'every %s' % \ formatting.formatTime(properties['time'])) else: self.uiState.set('rotate-type', 'disabled') # FIXME: should add a way of saying "do first cycle at this time" return self.pipe_template
def stopRecording(self): sink = self.get_element('fdsink') if sink.get_state() == gst.STATE_NULL: sink.set_state(gst.STATE_READY) if self.file: self.file.flush() sink.emit('remove', self.file.fileno()) self._recordingStopped(self.file, self.location) self.file = None self.uiState.set('filename', None) self.uiState.set('recording', False) try: size = format.formatStorage(os.stat(self.location).st_size) except EnvironmentError, e: # catch File not found, permission denied, disk problems size = "unknown" # Limit number of entries on filelist, remove the oldest entry fl = self.uiState.get('filelist', otherwise=[]) if FILELIST_SIZE == len(fl): self.uiState.remove('filelist', fl[0]) self.uiState.append('filelist', (self.last_tstamp, self.location, size)) if self._symlinkToLastRecording: self._updateSymlink(self.location, self._symlinkToLastRecording)
def update_mem(self, size): if not size: size = _('Unknown') fraction = 0 else: fraction = size / self.total_mem size = '%sB' % formatStorage(size) self.mem.set_text(size) self.mem.set_fraction(fraction)
def update_mem(self, size): if not size: size = _('Unknown') fraction = 0 else: fraction = size / self.total_mem size = '%sB' % formatting.formatStorage(size) self.mem.set_text(size) self.mem.set_fraction(fraction)
def updateState(self, set): c = self bytes_sent = c.getBytesSent() bytes_received = c.getBytesReceived() uptime = c.getUptime() set("stream-mime", c.get_mime()) set("stream-url", c.getUrl()) set("stream-uptime", formatting.formatTime(uptime)) bitspeed = bytes_received * 8 / uptime currentbitrate = self.getCurrentBitrate() set("stream-bitrate", formatting.formatStorage(bitspeed) + "bit/s") set("stream-current-bitrate", formatting.formatStorage(currentbitrate) + "bit/s") set("stream-totalbytes", formatting.formatStorage(bytes_received) + "Byte") set("stream-bitrate-raw", bitspeed) set("stream-totalbytes-raw", bytes_received) set("clients-current", str(c.getClients())) set("clients-max", str(c.getMaxClients())) set("clients-peak", str(c.getPeakClients())) set("clients-peak-time", c.getPeakEpoch()) set("clients-average", str(int(c.getAverageClients()))) bitspeed = bytes_sent * 8 / uptime set("consumption-bitrate", formatting.formatStorage(bitspeed) + "bit/s") set("consumption-bitrate-current", formatting.formatStorage(currentbitrate * c.getClients()) + "bit/s") set("consumption-totalbytes", formatting.formatStorage(bytes_sent) + "Byte") set("consumption-bitrate-raw", bitspeed) set("consumption-totalbytes-raw", bytes_sent)
def updateState(self, set): c = self bytes_sent = c.getBytesSent() bytes_received = c.getBytesReceived() uptime = c.getUptime() set('stream-mime', c.get_mime()) set('stream-url', c.getUrl()) set('stream-uptime', formatTime(uptime)) bitspeed = bytes_received * 8 / uptime currentbitrate = self.getCurrentBitrate() set('stream-bitrate', formatStorage(bitspeed) + 'bit/s') set('stream-current-bitrate', formatStorage(currentbitrate) + 'bit/s') set('stream-totalbytes', formatStorage(bytes_received) + 'Byte') set('stream-bitrate-raw', bitspeed) set('stream-totalbytes-raw', bytes_received) set('clients-current', str(c.getClients())) set('clients-max', str(c.getMaxClients())) set('clients-peak', str(c.getPeakClients())) set('clients-peak-time', c.getPeakEpoch()) set('clients-average', str(int(c.getAverageClients()))) bitspeed = bytes_sent * 8 / uptime set('consumption-bitrate', formatStorage(bitspeed) + 'bit/s') set('consumption-bitrate-current', formatStorage(currentbitrate * c.getClients()) + 'bit/s') set('consumption-totalbytes', formatStorage(bytes_sent) + 'Byte') set('consumption-bitrate-raw', bitspeed) set('consumption-totalbytes-raw', bytes_sent)
def allocateCacheSpace(self, size): """ Try to reserve cache space. If there is not enough space and the cache cleanup is enabled, it will delete files from the cache starting with the ones with oldest access time until the cache usage drops below the fraction specified by the property cleanup-low-threshold. Returns a 'tag' that should be used to 'free' the cache space using releaseCacheSpace. This tag is needed to better estimate the cache usage, if the cache usage has been updated since cache space has been allocated, freeing up the space should not change the cache usage estimation. @param size: size to reserve, in bytes @type size: int @returns: an allocation tag or None if the allocation failed. @rtype: tuple """ usage = self.updateCacheUsage() if (usage + size) < self._cacheMaxUsage: self._cacheUsage += size self.updateCacheUsageStatistics() return (self._cacheUsageLastUpdate, size) self.debug('cache usage will be %sbytes, need more cache', format.formatStorage(usage + size)) if not self._cleanupEnabled: self.debug('not allowed to clean up cache, so cannot cache') # No space available and cleanup disabled: allocation failed. return None # Update cleanup statistics self.stats.onCleanup() # List the cached files with file state os.chdir(self._cacheDir) files = [] for f in os.listdir('.'): # There's a possibility of getting an error on os.stat here. See # similar comment in updateCacheUsage() try: files.append((f, os.stat(f))) except OSError, e: if e.errno == errno.ENOENT: pass else: raise
def do(self, args): # get a list of pid, vsize and sort on vsize in reverse order l = [] processes = getProcesses(prefix=self.prefix) if not processes: return util.ok('No job processes running.') for process in processes.values(): l.append((process.pid, process.vsize)) l.sort(key=lambda t: t[1]) l.reverse() # check the one with the mostest pid, vsize = l[0] warning = parseSize(self.options.warning) critical = parseSize(self.options.critical) if vsize >= critical: # count number of critical jobs which = [t for t in l if t[1] >= critical] return util.critical( '%d %s(s) above critical level - highest is %d at %s' % (len(which), self.process_type, pid, formatting.formatStorage(vsize))) if vsize >= warning: # count number of warning jobs which = [t for t in l if t[1] >= warning] return util.warning( '%d %s(s) above warning level - highest is %d at %s' % (len(which), self.process_type, pid, formatting.formatStorage(vsize))) return util.ok( 'No %s processes above warning level ' '(highest is %d at %s)' % (self.process_type, pid, formatting.formatStorage(vsize)))
def do(self, args): # get a list of pid, vsize and sort on vsize in reverse order l = [] processes = getProcesses(prefix=self.prefix) if not processes: return util.ok('No job processes running.') for process in processes.values(): l.append((process.pid, process.vsize)) l.sort(key=lambda t: t[1]) l.reverse() # check the one with the mostest pid, vsize = l[0] warning = parseSize(self.options.warning) critical = parseSize(self.options.critical) if vsize >= critical: # count number of critical jobs which = [t for t in l if t[1] >= critical] return util.critical( '%d %s(s) above critical level - highest is %d at %s' % ( len(which), self.process_type, pid, formatting.formatStorage(vsize))) if vsize >= warning: # count number of warning jobs which = [t for t in l if t[1] >= warning] return util.warning( '%d %s(s) above warning level - highest is %d at %s' % ( len(which), self.process_type, pid, formatting.formatStorage(vsize))) return util.ok('No %s processes above warning level ' '(highest is %d at %s)' % ( self.process_type, pid, formatting.formatStorage(vsize)))
def configure_pipeline(self, pipeline, properties): element = pipeline.get_by_name('encoder') if properties.has_key('bitrate'): element.set_property('bitrate', properties['bitrate']) if properties.has_key('complexity'): element.set_property('complexity', properties['complexity']) if properties.has_key('sharpness'): element.set_property('sharpness', properties['sharpness']) if properties.has_key('key-frame-distance'): element.set_property('key-frame-distance', properties['key-frame-distance']) if properties.has_key('buffer-delay'): element.set_property('buffer-delay', properties['buffer-delay']) self.uiState.set('complexity', element.get_property('complexity')) self.uiState.set('bitrate', formatStorage(element.get_property('bitrate')) + 'bit/s')
def get_pipeline_string(self, properties): directory = properties['directory'] self.directory = directory self.fixRenamedProperties(properties, [('rotateType', 'rotate-type')]) rotateType = properties.get('rotate-type', 'none') # validate rotate-type and size/time properties first if not rotateType in ['none', 'size', 'time']: m = messages.Error(T_(N_( "The configuration property 'rotate-type' should be set to " "'size', time', or 'none', not '%s'. " "Please fix the configuration."), rotateType), mid='rotate-type') self.addMessage(m) raise errors.ComponentSetupHandledError() # size and time types need the property specified if rotateType in ['size', 'time']: if rotateType not in properties.keys(): m = messages.Error(T_(N_( "The configuration property '%s' should be set. " "Please fix the configuration."), rotateType), mid='rotate-type') self.addMessage(m) raise errors.ComponentSetupHandledError() # now act on the properties if rotateType == 'size': self.setSizeRotate(properties['size']) self.uiState.set('rotate-type', 'every %sB' % \ format.formatStorage(properties['size'])) elif rotateType == 'time': self.setTimeRotate(properties['time']) self.uiState.set('rotate-type', 'every %s' % \ format.formatTime(properties['time'])) else: self.uiState.set('rotate-type', 'disabled') # FIXME: should add a way of saying "do first cycle at this time" return self.pipe_template
def _allocateCacheSpace(self, usage, size): if usage + size < self._cacheMaxUsage: self._cacheUsage += size self.updateCacheUsageStatistics() return defer.succeed((self._cacheUsageLastUpdate, size)) self.debug('cache usage will be %sbytes, need more cache', formatting.formatStorage(usage + size)) if not self._cleanupEnabled: # No space available and cleanup disabled: allocation failed. self.debug('not allowed to clean up cache, ' 'so cannot cache %d' % size) return defer.succeed(None) d = self._cleanUp() d.addCallback(self._allocateCacheSpaceAfterCleanUp, size) return d
def updateState(self, set): c = self bytes_sent = c.getBytesSent() bytes_received = c.getBytesReceived() uptime = c.getUptime() set('stream-mime', c.get_mime()) set('stream-url', c.getUrl()) set('stream-uptime', formatting.formatTime(uptime)) bitspeed = bytes_received * 8 / uptime currentbitrate = self.getCurrentBitrate() set('stream-bitrate', formatting.formatStorage(bitspeed) + 'bit/s') set('stream-current-bitrate', formatting.formatStorage(currentbitrate) + 'bit/s') set('stream-totalbytes', formatting.formatStorage(bytes_received) + 'Byte') set('stream-bitrate-raw', bitspeed) set('stream-totalbytes-raw', bytes_received) set('clients-current', str(c.getClients())) set('clients-max', str(c.getMaxClients())) set('clients-peak', str(c.getPeakClients())) set('clients-peak-time', c.getPeakEpoch()) set('clients-average', str(int(c.getAverageClients()))) bitspeed = bytes_sent * 8 / uptime set('consumption-bitrate', formatting.formatStorage(bitspeed) + 'bit/s') set( 'consumption-bitrate-current', formatting.formatStorage(currentbitrate * c.getClients()) + 'bit/s') set('consumption-totalbytes', formatting.formatStorage(bytes_sent) + 'Byte') set('consumption-bitrate-raw', bitspeed) set('consumption-totalbytes-raw', bytes_sent)
def testGibibyte(self): value = 1024 * 1024 * 1024 self.assertEquals(formatting.formatStorage(value, 4), "1.0737 G")
def _updateVSize(self, vsize): # given int for vsize in bytes, update the label if not vsize: self._label_vsize.set_text(_('Unknown')) else: self._label_vsize.set_text('%sB' % formatting.formatStorage(vsize))
def _setEaterBytesReadCurrent(self, state, value): txt = value and (formatStorage(value) + _('Byte')) or '' self.labels['bytes-read-current'].set_text(txt) self._updateConnectionTime() self._updateDisconnectionTime()
def setFeederClientBytesReadTotal(self, state, value): txt = value and (formatting.formatStorage(value) + _('Byte')) or '' self.labels['bytes-read-total'].set_text(txt)
def testTebibyte(self): value = 1024 * 1024 * 1024 * 1024 assert formatStorage(value, 4) == "1.0995 T"
def testPebibyte(self): value = 1024 * 1024 * 1024 * 1024 * 1024 self.assertEquals(formatting.formatStorage(value, 4), "1.1259 P")
def testExbibyte(self): value = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 assert formatStorage(value, 4) == "1.1529 E"
pass else: return defer.fail(e) # Calculate the cached file total size usage = sum([d[1].st_size for d in files]) # Delete the cached file starting by the oldest accessed ones files.sort(key=lambda d: d[1].st_atime) rmlist = [] for path, info in files: usage -= info.st_size rmlist.append(path) if usage <= self._cacheMinUsage: # We reach the cleanup limit self.debug('cleaned up, cache use is now %sbytes', format.formatStorage(usage)) break d = threads.deferToThread(self._rmfiles, rmlist) d.addBoth(self._setCacheUsage, usage) return d def _allocateCacheSpaceAfterCleanUp(self, usage, size): if (self._cacheUsage + size) >= self._cacheSize: # There is not enough space, allocation failed self.updateCacheUsageStatistics() self.debug('not enough space in cache, ' 'cannot cache %d > %d' % (self._cacheUsage + size, self._cacheSize)) return None # There is enough space to allocate, allocation succeed
def testMegabyte(self): value = 1000 * 1000 self.assertEquals(formatting.formatStorage(value), "1.00 M")
def testBytes(self): value = 4 self.assertEquals(formatting.formatStorage(value), "4.00 ")
class Disker(feedcomponent.ParseLaunchComponent, log.Loggable): logCategory = "disker" componentMediumClass = DiskerMedium checkOffset = True pipe_template = 'multifdsink name=fdsink sync-method=2 mode=1 sync=false' file = None directory = None location = None caps = None last_tstamp = None indexLocation = None writeIndex = False syncOnTdt = False timeOverlap = 0 reactToMarks = False _offset = 0L _headers_size = 0 _index = None _nextIsKF = False _lastTdt = None _lastEntry = None # last KF/TDT _clients = {} # dict of clients {fd: (index, synced)} _startFilenameTemplate = None # template to use when starting off recording _startTime = None # time of event when starting _rotateTimeDelayedCall = None _pollDiskDC = None # _pollDisk delayed calls _symlinkToLastRecording = None _symlinkToCurrentRecording = None # see the commented out import statement for IStateCacheableListener at # the beginning of this file # implements(IStateCacheableListener) ### BaseComponent methods def init(self): self._can_schedule = (eventcalendar.HAS_ICALENDAR and eventcalendar.HAS_DATEUTIL) self.uiState.addKey('filename', None) self.uiState.addKey('recording', False) self.uiState.addKey('can-schedule', self._can_schedule) self.uiState.addKey('has-schedule', False) self.uiState.addKey('rotate-type', None) self.uiState.addKey('disk-free', None) # list of (dt (in UTC, without tzinfo), which, content) self.uiState.addListKey('next-points') self.uiState.addListKey('filelist') self._diskPoller = poller.Poller(self._pollDisk, DISKPOLL_FREQ, start=False) ### uiState observer triggers def observerAppend(self, observer, num): # PB may not have finished setting up its state and doing a # remoteCall immediately here may cause some problems to the other # side. For us to send the initial disk usage value with no # noticeable delay, we will do it in a callLater with a timeout # value of 0 self.debug("observer has started watching us, starting disk polling") if not self._diskPoller.running and not self._pollDiskDC: self._pollDiskDC = reactor.callLater(0, self._diskPoller.start, immediately=True) # Start the BaseComponent pollers feedcomponent.ParseLaunchComponent.observerAppend(self, observer, num) def observerRemove(self, observer, num): if num == 0: # cancel delayed _pollDisk calls if there's any if self._pollDiskDC: self._pollDiskDC.cancel() self._pollDiskDC = None self.debug("no more observers left, shutting down disk polling") self._diskPoller.stop() # Stop the BaseComponent pollers feedcomponent.ParseLaunchComponent.observerRemove(self, observer, num) def check_properties(self, props, addMessage): props = self.config['properties'] rotateType = props.get('rotate-type', 'none') if not rotateType in ['none', 'size', 'time']: msg = messages.Error(T_( N_("The configuration property 'rotate-type' should be set to " "'size', time', or 'none', not '%s'. " "Please fix the configuration."), rotateType), mid='rotate-type') addMessage(msg) raise errors.ConfigError(msg) if rotateType in ['size', 'time']: if rotateType not in props.keys(): msg = messages.Error(T_( N_("The configuration property '%s' should be set. " "Please fix the configuration."), rotateType), mid='rotate-type') addMessage(msg) raise errors.ConfigError(msg) if props[rotateType] == 0: msg = messages.Error(T_(N_("Configuration error: " \ "'rotate-type' %s value cannot be set to 0."), rotateType), mid='rotate-type') addMessage(msg) raise errors.ConfigError(msg) ### ParseLaunchComponent methods def get_pipeline_string(self, properties): directory = properties['directory'] self.directory = directory self.fixRenamedProperties(properties, [('rotateType', 'rotate-type')]) rotateType = properties.get('rotate-type', 'none') # now act on the properties if rotateType == 'size': self.setSizeRotate(properties['size']) self.uiState.set('rotate-type', 'every %sB' % \ formatting.formatStorage(properties['size'])) elif rotateType == 'time': self.setTimeRotate(properties['time']) self.uiState.set('rotate-type', 'every %s' % \ formatting.formatTime(properties['time'])) else: self.uiState.set('rotate-type', 'disabled') # FIXME: should add a way of saying "do first cycle at this time" return self.pipe_template def configure_pipeline(self, pipeline, properties): self.debug('configure_pipeline for disker') self._clock = pipeline.get_clock() self._symlinkToLastRecording = \ properties.get('symlink-to-last-recording', None) self._symlinkToCurrentRecording = \ properties.get('symlink-to-current-recording', None) self._recordAtStart = properties.get('start-recording', True) self._defaultFilenameTemplate = properties.get( 'filename', '%s.%%Y%%m%%d-%%H%%M%%S' % self.getName()) self._startFilenameTemplate = self._defaultFilenameTemplate icalfn = properties.get('ical-schedule') if self._can_schedule and icalfn: self.scheduleRecordings(open(icalfn, 'r')) elif icalfn: # ical schedule is set, but self._can_schedule is False def missingModule(moduleName): m = messages.Error(T_( N_("An iCal file has been specified for scheduling, " "but the '%s' module is not installed.\n"), moduleName), mid='error-python-%s' % moduleName) documentation.messageAddPythonInstall(m, moduleName) self.debug(m) self.addMessage(m) if not eventcalendar.HAS_ICALENDAR: missingModule('icalendar') if not eventcalendar.HAS_DATEUTIL: missingModule('dateutil') # self._can_schedule is False, so one of the above surely happened raise errors.ComponentSetupHandledError() self.writeIndex = properties.get('write-index', False) self.reactToMarks = properties.get('react-to-stream-markers', False) self.syncOnTdt = properties.get('sync-on-tdt', False) self.timeOverlap = properties.get('time-overlap', 0) sink = self.get_element('fdsink') if gstreamer.element_factory_has_property('multifdsink', 'resend-streamheader'): sink.set_property('resend-streamheader', False) else: self.debug("resend-streamheader property not available, " "resending streamheader when it changes in the caps") sink.get_pad('sink').connect('notify::caps', self._notify_caps_cb) # connect to client-removed so we can detect errors in file writing sink.connect('client-removed', self._client_removed_cb) if self.writeIndex: sink.connect('client-added', self._client_added_cb) if self.reactToMarks: pfx = properties.get('stream-marker-filename-prefix', '%03d.') self._markerPrefix = pfx if self.reactToMarks or self.writeIndex or self.syncOnTdt: sink.get_pad("sink").add_data_probe(self._src_pad_probe) ### our methods def _tdt_to_datetime(self, s): ''' TDT events contains a structure representing the UTC time of the stream with the fields: 'year', 'month', 'day', 'hour', 'minute', 'second' Can raise and Exception if the structure doesn't cotains all the requiered fields. Protect with try-except. ''' if s.get_name() != 'tdt': return None t = dt.datetime(s['year'], s['month'], s['day'], s['hour'], s['minute'], s['second']) return time.mktime(t.timetuple()) def _getStats(self, fd): sink = self.get_element('fdsink') stats = sink.emit('get-stats', fd) if len(stats) <= 6: self.warning("The current version of multifdsink doesn't " "include the timestamp of the first and last " "buffers sent: the indexing will be disabled.") m = messages.Warning( T_( N_("Versions up to and including %s of the '%s' " "GStreamer plug-in can't be used to write index " "files.\n"), '0.10.30', 'multifdsink')) self.addMessage(m) self.writeIndex = False return None return stats def _updateIndex(self, offset, timestamp, isKeyframe, tdt=0): for fd, val in self._clients.items(): index, synced = val if not synced: stats = self._getStats(fd) # Check if multifdsink can be used for indexing if not stats: return # Very unlikely, but if we are not synced yet, # add this entry to the index because it's going # to be the sync point, and continue if stats[6] == gst.CLOCK_TIME_NONE: index.addEntry(offset, timestamp, isKeyframe, tdt, False) continue # if we know when the client was synced, trim the index. index.updateStart(stats[6]) self._clients[fd] = (index, True) # At this point we should have only one entry in the index # which will be written to file after getting the next sync # buffer and we can update its duration and length. index.addEntry(offset, timestamp, isKeyframe, tdt, True) self._lastEntry = (offset, timestamp, isKeyframe, tdt) def _pollDisk(self): # Figure out the remaining disk space where the disker is saving # files to self._pollDiskDC = None s = None try: s = os.statvfs(self.directory) except Exception, e: self.debug('failed to figure out disk space: %s', log.getExceptionMessage(e)) if not s: free = None else: free = formatting.formatStorage(s.f_frsize * s.f_bavail) if self.uiState.get('disk-free') != free: self.debug("disk usage changed, reporting to observers") self.uiState.set('disk-free', free)
pass else: return defer.fail(e) # Calculate the cached file total size usage = sum([d[1].st_size for d in files]) # Delete the cached file starting by the oldest accessed ones files.sort(key=lambda d: d[1].st_atime) rmlist = [] for path, info in files: usage -= info.st_size rmlist.append(path) if usage <= self._cacheMinUsage: # We reach the cleanup limit self.debug('cleaned up, cache use is now %sbytes', formatting.formatStorage(usage)) break d = threads.deferToThread(self._rmfiles, rmlist) d.addBoth(self._setCacheUsage, usage) return d def _allocateCacheSpaceAfterCleanUp(self, usage, size): if (self._cacheUsage + size) >= self._cacheSize: # There is not enough space, allocation failed self.updateCacheUsageStatistics() self.debug('not enough space in cache, ' 'cannot cache %d > %d' % (self._cacheUsage + size, self._cacheSize)) return None # There is enough space to allocate, allocation succeed
def _formatBytes(value): return formatting.formatStorage(value) + _('Byte')
def testKibibyte(self): value = 1024 self.assertEquals(formatting.formatStorage(value), "1.02 k") self.assertEquals(formatting.formatStorage(value, 3), "1.024 k")
def testMebibyte(self): value = 1024 * 1024 self.assertEquals(formatting.formatStorage(value), "1.05 M") self.assertEquals(formatting.formatStorage(value, 3), "1.049 M") self.assertEquals(formatting.formatStorage(value, 4), "1.0486 M")
def testTebibyte(self): value = 1024 * 1024 * 1024 * 1024 self.assertEquals(formatting.formatStorage(value, 4), "1.0995 T")
def testExbibyte(self): value = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 self.assertEquals(formatting.formatStorage(value, 4), "1.1529 E")
def testPebibyte(self): value = 1024 * 1024 * 1024 * 1024 * 1024 assert formatStorage(value, 4) == "1.1259 P"
def _formatBitrate(value): return formatting.formatStorage(value) + _('bit/s')
def setFeederClientBytesReadCurrent(self, state, value): txt = value and (formatting.formatStorage(value) + _("Byte")) or "" self.labels["bytes-read-current"].set_text(txt) self.updateConnectionTime() self.updateDisconnectionTime()
def setFeederClientBytesReadTotal(self, state, value): txt = value and (formatting.formatStorage(value) + _("Byte")) or "" self.labels["bytes-read-total"].set_text(txt)
def setFeederClientBytesReadCurrent(self, state, value): txt = value and (formatting.formatStorage(value) + _('Byte')) or '' self.labels['bytes-read-current'].set_text(txt) self.updateConnectionTime() self.updateDisconnectionTime()