diff --git a/glance/common/animation.py b/glance/common/animation.py deleted file mode 100644 index 0a6ed62fac..0000000000 --- a/glance/common/animation.py +++ /dev/null @@ -1,203 +0,0 @@ -# vim: tabstop=4 shiftwidth=4 softtabstop=4 - -# Copyright 2012 OpenStack LLC. -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import sys -import threading -import time - -from glance.common import exception -from glance.common import utils - - -class UploadProgressStatus(threading.Thread): - """ - A class for showing: - 1. progress; - 2. rate; - 3. ETA; - 4. and status, e.g. active or stalled. - In order to sample the rate as closely as possible, this - implementation uses two FIFO buffers (times and bytes) - to record fine-grain transfer rate over a period of time. - """ - NUM_OF_ELEMENTS = 20 # number of element in FIFO - TIME_TO_STALL = 5 # if no data transfer longer this - # time(secs), the network will be - # considered as stalled. - REFRESH_STATUS_INTERVAL = 0.1 # time interval to refresh screen - MIN_SAMPLING_INTERVAL = 0.15 # Minimum sampling time for data - CALC_ETA_WITH_AVE_RATE = True # calc eta with average rate - - def __init__(self, transfer_info): - self.current_size = 0L - self.size = transfer_info['size'] - self.last_start = 0.0 - self.last_bytes = 0L - self.elapsed_time = 0.0 - self.total_times = 0.0 - self.total_bytes = 0L - self.nelements = self.NUM_OF_ELEMENTS - self.times = [0.0, ] * self.nelements - self.bytes = [0L, ] * self.nelements - self.index = 0 - self.stalled = False - self.transfer_info = transfer_info - threading.Thread.__init__(self) - - def run(self): - self.start = self.last_start = time.time() - while self.current_size != self.size: - time.sleep(self.REFRESH_STATUS_INTERVAL) - bytes = self.transfer_info['so_far'] - self.sampling(bytes, time.time()) - self.render() - sys.stdout.write("\n") - sys.stdout.flush() - - def _reset_buffer(self): - self.times = [0.0, ] * self.nelements - self.bytes = [0L, ] * self.nelements - - def _update(self, bytes, time): - self.elapsed_time = time - self.last_start - transferred_bytes = bytes - self.current_size - self.last_bytes += transferred_bytes - self.current_size += transferred_bytes - - if self.elapsed_time < self.MIN_SAMPLING_INTERVAL: - return False - - if transferred_bytes == 0: - if self.elapsed_time > self.TIME_TO_STALL: - self.stalled = True - self._reset_buffer() - self.last_bytes = 0 - return False - - if self.stalled: - self.stalled = False - self.elapsed_time = 1.0 - - return True - - def render(self): - - fraction = self.current_size / float(self.size) - - percentage = fraction * 100.0 - str_percent = "[%3d%%]" % percentage - - try: - height, width = utils.get_terminal_size() - sys.stdout.write("\b" * width) - - eta = self._calc_eta() - rate = self._get_speed() - width -= len(eta) - width -= len(rate) - - bar = ('=' * int((width - len(str_percent)) * fraction) - + str_percent) - padding = ' ' * (width - len(bar)) - sys.stdout.write(bar + padding + rate + eta) - sys.stdout.flush() - - except (exception.Invalid, NotImplementedError): - - sys.stdout.write("\b" * 6) # use the len of [%3d%%] - percent = (str_percent + ' ' - if self.current_size == self.size else str_percent) - percent += ' ' + self._get_speed() + 'ETA ' + self._calc_eta() - sys.stdout.write(percent) - sys.stdout.write("\b" * len(percent)) - sys.stdout.flush() - - def _get_speed(self): - speed, unit = self._calc_speed() - if speed > 0.0: - if speed >= 99.95: - rate = "%4f" % speed - elif speed >= 9.995: - rate = "%4.1f" % speed - else: - rate = "%4.2f" % speed - return " " + rate + unit + ", " - else: - return " ?B/s " - - def _calc_eta(self): - if self.stalled or self.current_size < self.size * 0.01: - return "ETA ??h ??m ??s" - if self.CALC_ETA_WITH_AVE_RATE: - eta = ((self.size - self.current_size) - * (time.time() - self.start) / self.current_size) - else: - eta = (((self.size - self.current_size) - * self.total_times) / (self.total_bytes)) - eta = int(eta) - hrs = mins = secs = 0 - hrs = eta / 3600 - secs = eta - hrs * 3600 - if secs >= 60: - mins = secs / 60 - secs = secs % 60 - - return "ETA %dh %2dm %2ds" % (hrs, mins, secs) - - def _calc_speed(self): - idx = 0 - units = ('B/s', 'K/s', 'M/s', 'G/s') - total_times = self.total_times + time.time() - self.last_start - total_bytes = self.total_bytes + self.last_bytes - - if self.stalled or total_times == 0: - return None, None - speed = total_bytes / float(total_times) - - if speed < 1024: - idx = 0 - elif speed < 1048576.: # 1024*1024 - idx = 1 - speed /= 1024. - elif speed < 1073741824.: # 1024*1024*1024 - idx = 2 - speed /= 1048576. - else: - idx = 3 - speed /= 1073741824. - - return speed, units[idx] - - def sampling(self, bytes, time): - if not self._update(bytes, time): - return - - self.total_times -= self.times[self.index] - self.total_bytes -= self.bytes[self.index] - - self.times[self.index] = self.elapsed_time - self.bytes[self.index] = self.last_bytes - - self.total_times += self.elapsed_time - self.total_bytes += self.last_bytes - - self.last_start = time - self.last_bytes = 0L - - self.index += 1 - if self.index == self.nelements: - self.index = 0