def delete(self, item):
""""""
path = self.on_get_path(item.id)
if path:
self.row_deleted(path)
Queue.delete(self, item)
self.cache.clear()
def delete(self, item): """""" path = self.on_get_path(item.id) if path: self.row_deleted(path) Queue.delete(self, item) self.cache.clear()
def index(request):
will = Player("Will")
will.add_games(["TicTacToe"])
jason = Player("Jason")
jason.add_games(["TicTacToe", "Poker"])
queue = Queue()
queue.add_players([will, jason])
games = ["TicTacToe", "Chess", "Poker"]
context = {'queue': queue, 'games': games}
return render(request, 'web/index.html', context)
def move(self, item, direction): """""" if item: path = self.on_get_path(item.parent_id) if path: iter = self.get_iter(path) else: iter = None prev = self.get_children(item.parent_id) self.cache.clear() Queue.move(self, item, direction) next = self.get_children(item.parent_id) self.rows_reordered(path, iter, [next.index(item) for item in prev])
def __init__(self, icons):
"""(status_icon, name, progress, current_size, total_size, speed, time, info)"""
gtk.GenericTreeModel.__init__(self)
Queue.__init__(self)
self.cache = Cache()
self.column_types = (gtk.gdk.Pixbuf, str, int, str, str, str, str, str)
self.column_values = (lambda x: icons.get_icon(x.type, x.status),
lambda x: x.get_name(),
lambda x: x.get_progress(),
lambda x: x.get_current_size(),
lambda x: x.get_total_size(),
lambda x: x.get_speed(), lambda x: x.get_time(),
lambda x: x.get_info())
def move(self, item, direction):
""""""
if item:
path = self.on_get_path(item.parent_id)
if path:
iter = self.get_iter(path)
else:
iter = None
prev = self.get_children(item.parent_id)
self.cache.clear()
Queue.move(self, item, direction)
next = self.get_children(item.parent_id)
self.rows_reordered(path, iter,
[next.index(item) for item in prev])
def add(self, items):
""""""
if Queue.add(self, items):
for id in [item.id for item in items]:
path = self.on_get_path(id)
self.row_inserted(path, self.get_iter(path))
return True
def __init__(self, icons): """(status_icon, name, progress, current_size, total_size, speed, time, info)""" gtk.GenericTreeModel.__init__(self) Queue.__init__(self) self.cache = Cache() self.column_types = (gtk.gdk.Pixbuf, str, int, str, str, str, str, str) self.column_values = ( lambda x: icons.get_icon(x.type, x.status), lambda x: x.get_name(), lambda x: x.get_progress(), lambda x: x.get_current_size(), lambda x: x.get_total_size(), lambda x: x.get_speed(), lambda x: x.get_time(), lambda x: x.get_info() )
def add(self, items): """""" if Queue.add(self, items): for id in [item.id for item in items]: path = self.on_get_path(id) self.row_inserted(path, self.get_iter(path)) return True
def ping(service):
print("ping", service)
if service == "store":
Store = store.get_store(
StoreConfig(
label="store",
type="es_vec",
parameters=StoreParameters(
host_name="192.46.212.142",
image_index_name="image",
video_index_name="video",
text_index_name="text",
),
))
Store.connect()
response = Store.ping()
click.echo(response)
elif service == "queue":
queue = Queue.make(
QueueConfig(
label="Queue",
type="rabbitmq",
parameters=QueueParameters(
host_name="rabbitmq",
queues=[
{
"name": "tattle-search-index-queue"
},
{
"name": "tattle-search-report-queue"
},
],
),
))
queue.connect()
def __init__(self, mode, lambd, mu, theta, servers_count,
core_servers_count, L, H, simulation_time, max_queue_size,
is_debug):
self.lambd = lambd
self.mu = mu
self.theta = theta
self.servers_count = int(servers_count)
self.core_servers_count = int(core_servers_count)
self.L = int(L)
self.H = int(H)
self.simulation_time = simulation_time
self.is_debug = is_debug
self.auto_continue = not self.is_debug
self.mode = mode
self.flow = Flow(lambd, mu, is_debug)
self.queue = Queue(int(max_queue_size), is_debug)
self.generated_request = Request(-1, 0, 0, 0)
self.system_state = States.IDLE
self.prev_system_state = States.IDLE
self.served_count = 0
self.served_sum_w = 0
self.served_sum_wq = 0
self.servers = []
self.generated_requests = []
self.time = 0
self.prev_time = 0
self.up_down_time = 0
self.prev_up_down_time = 0
self.up_down_count = 0
self.up_down_mean = 0
self.state_time = dict.fromkeys(States.get_States_list(States), 0)
self.state_count = dict.fromkeys(States.get_States_list(States), 0)
for i in range(int(servers_count)):
self.servers.append(
Server(i, True if i < int(core_servers_count) else False,
is_debug))
def __init__(self, *player_data):
self.queue = Queue()
for player in player_data:
name = player[0]
list_of_games = player[1:]
player = Player(name)
player.add_games(list_of_games)
self.queue.add_player(player)
def __init__(self, configPath):
self.config = config.load(configPath)
if self.config.operators:
self.operators = Operator(self.config.operators)
if self.config.store:
self.store = store.get_store(self.config.store)
if self.config.queue:
# print("---> 1", self.config.queue)
self.queue = Queue.make(self.config.queue)
if self.config.server:
self.server = Server(self.config.server)
class SelectingChessFixture(object):
@convert_arg(using=IterableConverter())
def __init__(self, *player_data):
self.queue = Queue()
for player in player_data:
name = player[0]
list_of_games = player[1:]
player = Player(name)
player.add_games(list_of_games)
self.queue.add_player(player)
def add_player(self, name):
self.queue.add_player(Player(name))
def player_chooses_game(self, game):
self.game = game
def filtered_players(self):
filtered_players = self.queue.filter(self.game)
return [player.name for player in filtered_players]
def __init__(self, urllist, visits, min, max):
self.bots = 3 # max amount of bots to use; can be changed at later time; atm used for sorted amount
self.count = 0 # returning bots
self.ip = None
self.alive = True
self.targets = {} # {url: visits}
self.recentIPs = Queue(10)
self.min = int(min)
self.max = int(max)
self.visits = int(visits)
if not path.exists(urllist):
exit('Error: Unable to locate `{}`'.format(urllist))
# read the url list
with open(urllist, 'r') as f:
try:
for url in [_ for _ in f.read().split('\n') if _]:
self.targets[url] = 0 # initial view
except Exception as err:exit('Error:', err)
def reset(service):
print("reset", service)
if service == "store":
Store = store.get_store(
StoreConfig(
label="store",
type="es_vec",
parameters=StoreParameters(
host_name="es",
image_index_name="image",
video_index_name="video",
text_index_name="text",
),
))
Store.connect()
Store.reset()
print("Store reset")
elif service == "queue":
queue = Queue.make(
QueueConfig(
label="Queue",
type="rabbitmq",
parameters=QueueParameters(
host_name="rabbitmq",
queues=[
{
"name": "tattle-search-index-queue"
},
{
"name": "tattle-search-report-queue"
},
],
),
))
queue.connect()
queue.reset()
def __init__(self, urllist, visits, min, max):
super().__init__()
self.bots = 2 # max amount of bots to use
self.count = 0 # returning bots
self.ip = None
self.alive = True
self.targets = {} # {url: visits}
self.recentIPs = Queue(5)
self.min = int(min)
self.max = int(max)
self.visits = int(visits)
if not path.exists(urllist):
exit(f'Error: Unable to locate {format(urllist)}')
# read the url list
with open(urllist, 'r') as f:
try:
for url in [_ for _ in f.read().split('\n') if _]:
self.targets[url] = 0 # initial view
except Exception as err:
exit(f'Error: ? {err}')
def setUp(self): """""" self.manager = UploadManager(Queue()) #disable scheduler self.manager.scheduling = True self.manager.add_package(PACKAGE)
class TestQueue(unittest.TestCase): """""" def setUp(self): """""" self.queue = Queue() self.queue.add_package(FILE_LIST) def test_delete_package(self): """""" package = self.queue.add_package(FILE_LIST) packages = self.queue.get_children() self.assertEqual(len(packages), 2) self.queue.delete(package) self.assertEqual(len(self.queue.get_children()), 1) self.assertEqual(self.queue.get_item(package.id), None) def test_delete_file(self): """""" package = self.queue.add_package(FILE_LIST) file1, file2 = self.queue.get_children(package.id) old_size = self.queue.get_item(package.id).total_size self.queue.delete(file1) size = self.queue.get_item(package.id).total_size self.assertEqual(size, old_size-file1.total_size) self.assertEqual(len(self.queue.get_children(package.id)), 1) self.assertEqual(self.queue.get_item(file1.id), None) self.queue.delete(file2) self.assertEqual(self.queue.get_item(file2.id), None) self.assertEqual(self.queue.get_item(package.id), None) def test_delete_link(self): """""" package = self.queue.add_package(FILE_LIST) file1, file2 = self.queue.get_children(package.id) link1, link2 = self.queue.get_children(file1.id) p_size = self.queue.get_item(package.id).total_size f_size = file1.total_size self.queue.delete(link1) size = self.queue.get_item(file1.id).total_size self.assertEqual(size, f_size-link1.total_size) size = self.queue.get_item(package.id).total_size self.assertEqual(size, p_size-link1.total_size) self.assertEqual(len(self.queue.get_children(file1.id)), 1) self.assertEqual(self.queue.get_item(link1.id), None) self.queue.delete(file2) self.queue.delete(link2) self.assertEqual(self.queue.get_item(link2.id), None) self.assertEqual(self.queue.get_item(file1.id), None) self.assertEqual(self.queue.get_item(package.id), None) def test_move_up_link(self): package = self.queue.get_children().pop() file1, file2 = self.queue.get_children(package.id) link1, link2 = self.queue.get_children(file1.id) self.queue.move_up(link2) link3, link4 = self.queue.get_children(file1.id) self.assertEqual(link1, link4) self.assertEqual(link2, link3) self.queue.move_up(link1) link3, link4 = self.queue.get_children(file1.id) self.assertEqual(link1, link3) self.assertEqual(link2, link4) self.queue.move_up(link1) link3, link4 = self.queue.get_children(file1.id) self.assertEqual(link1, link3) self.assertEqual(link2, link4) def test_move_down_link(self): package = self.queue.get_children().pop() file1, file2 = self.queue.get_children(package.id) link1, link2 = self.queue.get_children(file1.id) self.queue.move_down(link1) link3, link4 = self.queue.get_children(file1.id) self.assertEqual(link1, link4) self.assertEqual(link2, link3) self.queue.move_down(link2) link3, link4 = self.queue.get_children(file1.id) self.assertEqual(link1, link3) self.assertEqual(link2, link4) self.queue.move_down(link2) link3, link4 = self.queue.get_children(file1.id) self.assertEqual(link1, link3) self.assertEqual(link2, link4) def test_move_up_file(self): package = self.queue.get_children().pop() file1, file2 = self.queue.get_children(package.id) link1, link2 = self.queue.get_children(file1.id) link3, link4 = self.queue.get_children(file2.id) self.queue.move_up(file2) file3, file4 = self.queue.get_children(package.id) link5, link6 = self.queue.get_children(file3.id) link7, link8 = self.queue.get_children(file4.id) self.assertEqual(file1, file4) self.assertEqual(file2, file3) self.assertEqual(link1, link7) self.assertEqual(link2, link8) self.assertEqual(link3, link5) self.assertEqual(link4, link6) self.queue.move_up(file2) file3, file4 = self.queue.get_children(package.id) link5, link6 = self.queue.get_children(file3.id) link7, link8 = self.queue.get_children(file4.id) self.assertEqual(file1, file4) self.assertEqual(file2, file3) self.assertEqual(link1, link7) self.assertEqual(link2, link8) self.assertEqual(link3, link5) self.assertEqual(link4, link6) def mtest_move_down_file(self): package = self.queue.get_children().pop() file1, file2 = self.queue.get_children(package.id) link1, link2 = self.queue.get_children(file1.id) link3, link4 = self.queue.get_children(file2.id) self.queue.move_down(file1) file3, file4 = self.queue.get_children(package.id) link5, link6 = self.queue.get_children(file3.id) link7, link8 = self.queue.get_children(file4.id) self.assertEqual(file1, file4) self.assertEqual(file2, file3) self.assertEqual(link1, link7) self.assertEqual(link2, link8) self.assertEqual(link3, link5) self.assertEqual(link4, link6) self.queue.move_down(file1) file3, file4 = self.queue.get_children(package.id) link5, link6 = self.queue.get_children(file3.id) link7, link8 = self.queue.get_children(file4.id) self.assertEqual(file1, file4) self.assertEqual(file2, file3) self.assertEqual(link1, link7) self.assertEqual(link2, link8) self.assertEqual(link3, link5) self.assertEqual(link4, link6) def test_move_up_package(self): """""" self.queue.add_package(FILE_LIST) package1, package2 = self.queue.get_children() file1, file2 = self.queue.get_children(package1.id) file3, file4 = self.queue.get_children(package2.id) link1, link2 = self.queue.get_children(file1.id) link3, link4 = self.queue.get_children(file2.id) link5, link6 = self.queue.get_children(file3.id) link7, link8 = self.queue.get_children(file4.id) self.queue.move_up(package2) package3, package4 = self.queue.get_children() file5, file6 = self.queue.get_children(package3.id) file7, file8 = self.queue.get_children(package4.id) link9, link10 = self.queue.get_children(file5.id) link11, link12 = self.queue.get_children(file6.id) link13, link14 = self.queue.get_children(file7.id) link15, link16 = self.queue.get_children(file8.id) self.assertEqual(package1, package4) self.assertEqual(package2, package3) self.assertEqual(file1, file7) self.assertEqual(file2, file8) self.assertEqual(file3, file5) self.assertEqual(file4, file6) self.assertEqual(link1, link13) self.assertEqual(link2, link14) self.assertEqual(link3, link15) self.assertEqual(link4, link16) self.assertEqual(link5, link9) self.assertEqual(link6, link10) self.assertEqual(link7, link11) self.assertEqual(link8, link12) self.queue.move_up(package2) package3, package4 = self.queue.get_children() file5, file6 = self.queue.get_children(package3.id) file7, file8 = self.queue.get_children(package4.id) link9, link10 = self.queue.get_children(file5.id) link11, link12 = self.queue.get_children(file6.id) link13, link14 = self.queue.get_children(file7.id) link15, link16 = self.queue.get_children(file8.id) self.assertEqual(package1, package4) self.assertEqual(package2, package3) self.assertEqual(file1, file7) self.assertEqual(file2, file8) self.assertEqual(file3, file5) self.assertEqual(file4, file6) self.assertEqual(link1, link13) self.assertEqual(link2, link14) self.assertEqual(link3, link15) self.assertEqual(link4, link16) self.assertEqual(link5, link9) self.assertEqual(link6, link10) self.assertEqual(link7, link11) self.assertEqual(link8, link12) def test_move_down_package(self): """""" package_id = self.queue.add_package(FILE_LIST) package1, package2 = self.queue.get_children() file1, file2 = self.queue.get_children(package1.id) file3, file4 = self.queue.get_children(package2.id) link1, link2 = self.queue.get_children(file1.id) link3, link4 = self.queue.get_children(file2.id) link5, link6 = self.queue.get_children(file3.id) link7, link8 = self.queue.get_children(file4.id) self.queue.move_down(package1) package3, package4 = self.queue.get_children() file5, file6 = self.queue.get_children(package3.id) file7, file8 = self.queue.get_children(package4.id) link9, link10 = self.queue.get_children(file5.id) link11, link12 = self.queue.get_children(file6.id) link13, link14 = self.queue.get_children(file7.id) link15, link16 = self.queue.get_children(file8.id) self.assertEqual(package1, package4) self.assertEqual(package2, package3) self.assertEqual(file1, file7) self.assertEqual(file2, file8) self.assertEqual(file3, file5) self.assertEqual(file4, file6) self.assertEqual(link1, link13) self.assertEqual(link2, link14) self.assertEqual(link3, link15) self.assertEqual(link4, link16) self.assertEqual(link5, link9) self.assertEqual(link6, link10) self.assertEqual(link7, link11) self.assertEqual(link8, link12) self.queue.move_down(package1) package3, package4 = self.queue.get_children() file5, file6 = self.queue.get_children(package3.id) file7, file8 = self.queue.get_children(package4.id) link9, link10 = self.queue.get_children(file5.id) link11, link12 = self.queue.get_children(file6.id) link13, link14 = self.queue.get_children(file7.id) link15, link16 = self.queue.get_children(file8.id) self.assertEqual(package1, package4) self.assertEqual(package2, package3) self.assertEqual(file1, file7) self.assertEqual(file2, file8) self.assertEqual(file3, file5) self.assertEqual(file4, file6) self.assertEqual(link1, link13) self.assertEqual(link2, link14) self.assertEqual(link3, link15) self.assertEqual(link4, link16) self.assertEqual(link5, link9) self.assertEqual(link6, link10) self.assertEqual(link7, link11) self.assertEqual(link8, link12) def test_propagate_status(self): """""" package = self.queue.get_children().pop() file1, file2 = self.queue.get_children(package.id) link1, link2 = self.queue.get_children(file1.id) link3, link4 = self.queue.get_children(file2.id) #p : pend, f: pend pend, l: pend pend pend pend link1.set_status(cons.STATUS_ACTIVE) #p : active, f: active pend, l: active pend pend pend self.assertEqual(file1.status, cons.STATUS_ACTIVE) self.assertEqual(package.status, cons.STATUS_ACTIVE) link2.set_status(cons.STATUS_WAIT) #p : active, f: active pend, l: active wait pend pend self.assertEqual(file1.status, cons.STATUS_ACTIVE) self.assertEqual(package.status, cons.STATUS_ACTIVE) link1.set_status(cons.STATUS_PEND) #p : wait, f: wait pend, l: pend wait pend pend self.assertEqual(file1.status, cons.STATUS_WAIT) self.assertEqual(package.status, cons.STATUS_WAIT) link1.set_status(cons.STATUS_ACTIVE) #p : active, f: active pend, l: active wait pend pend link1.set_status(cons.STATUS_ERROR) link2.set_status(cons.STATUS_ERROR) #p : pend, f: error pend, l: error error pend pend self.assertEqual(file1.status, cons.STATUS_ERROR) self.assertEqual(package.status, cons.STATUS_PEND) link1.set_status(cons.STATUS_WAIT) #p : wait, f: wait pend, l: wait error pend pend self.assertEqual(file1.status, cons.STATUS_WAIT) self.assertEqual(package.status, cons.STATUS_WAIT) link1.set_status(cons.STATUS_CORRECT) link2.set_status(cons.STATUS_CORRECT) #p : pend, f: correct pend, l: correct correct pend pend self.assertEqual(file1.status, cons.STATUS_CORRECT) self.assertEqual(package.status, cons.STATUS_PEND) link3.set_status(cons.STATUS_ACTIVE) #p : active, f: correct active, l: correct correct active pend self.assertEqual(file2.status, cons.STATUS_ACTIVE) self.assertEqual(package.status, cons.STATUS_ACTIVE) link3.set_status(cons.STATUS_CORRECT) link4.set_status(cons.STATUS_CORRECT) #p : correct, f: correct correct, l: correct correct correct correct self.assertEqual(file2.status, cons.STATUS_CORRECT) self.assertEqual(package.status, cons.STATUS_CORRECT) def test_sort_status(self): tmp = self.queue.sort_status(cons.STATUS_CORRECT, cons.STATUS_STOP) self.assertEqual(tmp, cons.STATUS_STOP) tmp = self.queue.sort_status(cons.STATUS_STOP, cons.STATUS_ERROR) self.assertEqual(tmp, cons.STATUS_ERROR) tmp = self.queue.sort_status(cons.STATUS_ERROR, cons.STATUS_PEND) self.assertEqual(tmp, cons.STATUS_PEND) tmp = self.queue.sort_status(cons.STATUS_PEND, cons.STATUS_WAIT) self.assertEqual(tmp, cons.STATUS_WAIT) tmp = self.queue.sort_status(cons.STATUS_WAIT, cons.STATUS_ACTIVE) self.assertEqual(tmp, cons.STATUS_ACTIVE) def tearDown(self): """""" del self.queue
class Simulation:
"""
This class represents simulation process
"""
def __init__(self, mode, lambd, mu, theta, servers_count,
core_servers_count, L, H, simulation_time, max_queue_size,
is_debug):
self.lambd = lambd
self.mu = mu
self.theta = theta
self.servers_count = int(servers_count)
self.core_servers_count = int(core_servers_count)
self.L = int(L)
self.H = int(H)
self.simulation_time = simulation_time
self.is_debug = is_debug
self.auto_continue = not self.is_debug
self.mode = mode
self.flow = Flow(lambd, mu, is_debug)
self.queue = Queue(int(max_queue_size), is_debug)
self.generated_request = Request(-1, 0, 0, 0)
self.system_state = States.IDLE
self.prev_system_state = States.IDLE
self.served_count = 0
self.served_sum_w = 0
self.served_sum_wq = 0
self.servers = []
self.generated_requests = []
self.time = 0
self.prev_time = 0
self.up_down_time = 0
self.prev_up_down_time = 0
self.up_down_count = 0
self.up_down_mean = 0
self.state_time = dict.fromkeys(States.get_States_list(States), 0)
self.state_count = dict.fromkeys(States.get_States_list(States), 0)
for i in range(int(servers_count)):
self.servers.append(
Server(i, True if i < int(core_servers_count) else False,
is_debug))
def update_state_time(self):
self.state_time[self.prev_system_state] += self.time - self.prev_time
def update_state_count(self):
self.state_count[self.prev_system_state] += 1
def update_system_state(self):
self.prev_system_state = self.system_state
self.system_state = self.get_system_state()
def get_system_state(self):
"""
Calculate server state
"""
if self.mode == "m/m/c/r":
return States.IDLE
if self.mode == "m/m/c[c0]/r":
if self.system_state == States.IDLE:
if len(self.queue.requests
) == 0 and self.get_deployed_servers_count(
) == self.core_servers_count:
return States.IDLE
if len(self.queue.requests) > 0:
return States.TURN_UP
if len(self.queue.requests
) == 0 and self.get_deployed_servers_count(
) > self.core_servers_count:
return States.TURN_OFF
return "Error[IDLE]"
if self.system_state == States.TURN_UP:
if len(self.queue.requests
) == 0 and self.get_deployed_servers_count(
) == self.core_servers_count:
return States.IDLE
if len(self.queue.requests) > 0:
return States.TURN_UP
if len(self.queue.requests
) == 0 and self.get_deployed_servers_count(
) > self.core_servers_count:
return States.TURN_OFF
return "Error[TURN_UP]"
if self.system_state == States.TURN_OFF:
if len(self.queue.requests
) == 0 and self.get_deployed_servers_count(
) > self.core_servers_count:
return States.TURN_OFF
if len(self.queue.requests
) == 0 and self.get_deployed_servers_count(
) == self.core_servers_count:
return States.IDLE
if len(self.queue.requests) > 0:
return States.TURN_UP
return "Error[TURN_OFF]"
return "Error[m/m/c[c0]/r]"
if self.mode == "m/m/c[c0]/r[l,h]":
if self.system_state == States.IDLE:
if len(self.queue.requests) >= self.H:
return States.TURN_UP
if len(self.queue.requests) < self.H:
return States.IDLE
return "Error[IDLE]"
if self.system_state == States.TURN_UP or self.system_state == States.FULL:
if len(self.queue.requests) <= self.L:
return States.TURN_OFF
if len(
self.queue.requests
) > self.L and self.servers_count == self.get_deployed_servers_count(
):
return States.FULL
if len(self.queue.requests) > self.L:
return States.TURN_UP
return "Error[TURN_UP]"
if self.system_state == States.TURN_OFF:
if len(self.queue.requests) >= self.H:
return States.TURN_UP
if len(self.queue.
requests) < self.H and self.get_deployed_servers_count(
) == self.core_servers_count:
return States.IDLE
if len(self.queue.
requests) < self.H and self.get_deployed_servers_count(
) > self.core_servers_count:
return States.TURN_OFF
return "Error[TURN_OFF]"
return "Error[m/m/c[c0]/r[l,h]]"
return "Error[mode not supported]"
def update_time(self):
if self.system_state == States.IDLE:
self.prev_up_down_time = 0
else:
if self.prev_system_state == States.IDLE:
self.prev_up_down_time = self.time
else:
if self.system_state != self.prev_system_state:
if self.system_state == States.TURN_OFF or self.prev_system_state == States.TURN_OFF:
self.up_down_count += 1
self.up_down_time += self.time - self.prev_up_down_time
self.up_down_mean = self.up_down_time / self.up_down_count
self.prev_time = self.time
self.time = self.get_system_time()
def get_system_time(self):
"""
Calculate time after last event
"""
first_generated_request = self.get_first_arrived_generated_request()
first_served_server = self.get_first_served_server()
first_turned_server = self.get_first_turned_server()
next_arrive_time = first_generated_request.arrival_time
next_serve_time = float(
'inf'
) if first_served_server.ID == -1 else first_served_server.departure_time
next_turn_time = float('inf') if (
first_turned_server.ID == -1 and
(self.system_state != States.TURN_UP or self.system_state !=
States.FULL)) else first_turned_server.turn_on_time
t = min([next_arrive_time, next_serve_time, next_turn_time])
if self.is_debug:
t0 = "%.3f" % first_generated_request.arrival_time
t1 = "never" if next_serve_time == float(
'inf') else "%.3f" % next_serve_time
t2 = "never" if next_turn_time == float(
'inf') else "%.3f" % next_turn_time
if t == next_arrive_time: event = "ARRIVE"
if t == next_serve_time: event = "SERVE"
if t == next_turn_time: event = "TURN"
print(" Event=", event, ", arrive= ", t0, ", ", "serve= ", t1,
"(#", first_served_server.ID, "),"
"turn up= ", t2, "(#", first_turned_server.ID, ")")
return t
def get_free_deployed_server(self):
"""
Return free working server
"""
free_server = False
for server in self.servers:
if not server.is_busy and server.is_deployed and not server.to_be_turned_off:
return server
return free_server
def get_free_deployed_servers_count(self):
"""
Return count of free working servers
"""
count = 0
for server in self.servers:
if not server.is_busy and server.is_deployed and not server.to_be_turned_off:
count += 1
return count
def get_busy_deployed_servers_count(self):
"""
Return count of busy working servers
"""
count = 0
for server in self.servers:
if server.is_busy and server.is_deployed:
count += 1
return count
def get_deployed_servers_count(self):
"""
Return working servers count
"""
count = 0
for server in self.servers:
if server.is_deployed:
count += 1
return count
def get_first_arrived_generated_request(self):
"""
Return request to be served first
"""
generated_request = self.generated_requests[0]
for request in self.generated_requests:
if request.arrival_time < generated_request.arrival_time:
generated_request = request
return generated_request
def get_first_served_server(self):
"""
Return server to be served first
"""
served_server = Server(-1, True, False)
served_server.departure_time = float('inf')
for server in self.servers:
if server.is_busy and server.is_deployed and server.departure_time < served_server.departure_time:
served_server = server
return served_server
def get_first_turned_server(self):
"""
Return server to be turned on first
"""
served_server = Server(-1, True, False)
served_server.turn_on_time = float('inf')
for server in self.servers:
if server.to_be_turned_on and server.turn_on_time < served_server.turn_on_time:
served_server = server
return served_server
def get_servers_to_turn_off(self):
"""
Return servers list to be turned off
"""
result = []
# sort servers by departure time
self.servers.sort(key=lambda x: x.departure_time)
for i in range(0, len(self.servers)):
self.servers[i].ID = i
# turn off c(t)-c0 served deployed servers
turned_off_servers = 0
for server in self.servers:
if turned_off_servers < self.get_deployed_servers_count(
) - self.core_servers_count and server.is_deployed:
turned_off_servers += 1
result.append(server)
return result
def pop_generated_request(self, request):
"""
Delete request from list of generated request waiting to be served
"""
request_id = 0
for req in self.generated_requests:
if req.ID == request.ID:
self.generated_requests.pop(request_id)
break
request_id += 1
def has_turned_servers(self):
turned_count = 0
for server in self.servers:
if server.is_deployed:
turned_count += 1
return True if turned_count != self.core_servers_count else False
def turn_on_servers(self):
# start turning up servers
for server in self.servers:
self.servers[server.ID].turn_on(self.time, self.theta)
# time = turn up server, change server state to deployed
for server in self.servers:
if server.turn_on_time == self.time:
self.servers[server.ID].deploy()
def turn_off_servers(self):
servers_to_turn_off = self.get_servers_to_turn_off()
for server in self.servers:
self.servers[server.ID].turn_off()
for server in servers_to_turn_off:
if server.departure_time == self.time and server.is_busy and server.is_deployed and server.to_be_turned_off:
served_request = self.servers[server.ID].unload_and_undeploy()
self.served_count += 1
self.served_sum_w += served_request.w
self.served_sum_wq += served_request.wq
for server in self.servers:
if server.departure_time == self.time and server.is_busy and server.is_deployed and not server.to_be_turned_off:
served_request = self.servers[server.ID].unload()
self.served_count += 1
self.served_sum_w += served_request.w
self.served_sum_wq += served_request.wq
def handle_idle(self):
for server in self.servers:
self.servers[server.ID].idle()
def handle_idle_mode(self):
self.handle_idle()
self.serve_request()
self.handle_request()
self.handle_queue()
def handle_turn_on_mode(self):
self.turn_on_servers()
self.serve_request()
self.handle_request()
self.handle_queue()
def handle_turn_off_mode(self):
self.turn_off_servers()
self.handle_request()
self.handle_queue()
def serve_request(self):
# time = departure time, serve request
for server in self.servers:
if server.departure_time == self.time and server.is_busy and server.is_deployed:
served_request = self.servers[server.ID].unload()
self.served_count += 1
self.served_sum_w += served_request.w
self.served_sum_wq += served_request.wq
def handle_request(self):
# time = new request arrive, handle request
first_generated_request = self.get_first_arrived_generated_request()
if first_generated_request.arrival_time == self.time:
if self.get_free_deployed_servers_count() > 0:
self.servers[self.get_free_deployed_server().ID].load(
self.generated_request)
else:
self.queue.push(self.generated_request)
self.pop_generated_request(first_generated_request)
if (len(self.generated_requests) < 2 * self.servers_count):
self.generated_request = self.flow.generate()
self.generated_requests.append(self.generated_request)
def handle_queue(self):
# handle queue at current time
for request in self.queue.requests:
if self.get_free_deployed_servers_count() > 0:
request_from_queue = self.queue.pop(request, self.time)
request_from_queue.queue_size_at_serving = len(
self.queue.requests)
request_from_queue.server_arrival_time = self.time
self.servers[self.get_free_deployed_server().ID].load(
request_from_queue)
else:
break
def start(self):
"""
Run simulation
"""
if self.is_debug: print("Simulation started")
self.generated_request = self.flow.generate()
self.generated_requests.append(self.generated_request)
while self.time < self.simulation_time:
self.run()
if self.is_debug:
print("Simulation ended")
def start_requests(self, requestsToServe):
"""
Run simulation
"""
if self.is_debug: print("Simulation started")
self.generated_request = self.flow.generate()
self.generated_requests.append(self.generated_request)
heating = 250000
is_heated = False
while self.served_count < requestsToServe + heating:
self.run()
if self.served_count == heating and is_heated is False:
is_heated = True
self.queue.blocked = 0
self.served_count = 0
self.served_sum_w = 0
self.served_sum_wq = 0
if self.is_debug:
print("Simulation ended")
def run(self):
if self.is_debug: print("TIME = ", self.time)
# IDLE
if self.system_state == States.IDLE:
self.handle_idle_mode()
# TURN UP or FULL
elif self.system_state == States.TURN_UP or self.system_state == States.FULL:
self.handle_turn_on_mode()
# TURN DOWN
elif self.system_state == States.TURN_OFF:
self.handle_turn_off_mode()
self.update_system_state()
self.update_time()
self.update_state_time()
self.update_state_count()
self.debug_run()
def debug_run(self):
if self.is_debug:
print(" ", self.system_state)
print(" Q = ", len(self.queue.requests), ", ", "blocked = ",
self.queue.blocked, ", ", " busy = ",
self.get_busy_deployed_servers_count(), "/",
self.get_deployed_servers_count(), ",", " free = ",
self.get_free_deployed_servers_count(), "/",
self.get_deployed_servers_count(), ",", "C = ",
self.servers_count, ",", " generated = ",
self.flow.generated_count, ",", " served =",
self.served_count)
# for server in self.servers:
# server.get_info()
print(" up-down: count = ", self.up_down_count, ", mean = ",
self.up_down_mean, ", total = ", self.up_down_time)
print(self.state_count)
print(self.state_time)
if self.is_debug and not self.auto_continue:
user_input = input(
" Press Enter to for next step, or input 'True' to turn on auto continue mode: "
)
if bool(user_input) == True:
self.auto_continue = True
def setUp(self): """""" self.queue = Queue() self.queue.add_package(FILE_LIST)
def update_cb(self, item, status=None): """""" Queue.update_cb(self, item, status) self.update_row(item.id)
credentials = CredentialsLoader().get_credentials()
mode = credentials['general']['mode']
operator = credentials['general']['operator']
reddit = praw.Reddit(user_agent=consts.user_agent,
client_id=credentials['reddit']['client_id'],
client_secret=credentials['reddit']['client_secret'],
username=credentials['reddit']['username'],
password=credentials['reddit']['password'])
print("CoffinBot Queue Client v{} Ctrl+C to stop".format(consts.version))
failure_counter = 1 # 1 by default since it is the wait timer multiplier
q = Queue()
q.enter_queue()
def signal_handler(sig, frame):
print("Exiting...")
q.exit_queue()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
while True:
try:
for i in q.get_jobs():
print(i, i.origin_host, i.origin_id)
class QueueTests(unittest.TestCase):
def setUp(self):
self.TicTacToe = "TicTacToe"
self.Chess = "Chess"
self.queue = Queue()
def test_a_player_can_be_added(self):
player = self.create_player()
self.add_player_to_queue(player)
self.assertEqual(1, self.get_length_of_queue())
def test_two_players_can_be_added_sequentially(self):
players = self.create_players(2)
self.add_player_to_queue(players[0])
self.assertEqual(1, self.get_length_of_queue())
self.add_player_to_queue(players[1])
self.assertEqual(2, self.get_length_of_queue())
def test_the_same_player_cannot_be_added_twice(self):
player = self.create_player()
self.add_player_to_queue(player)
self.add_player_to_queue(player)
self.assertEqual(1, self.get_length_of_queue())
def test_filter_single_player(self):
player = self.create_player(games=[self.TicTacToe])
self.add_player_to_queue(player)
self.assertItemsEqual([player], self.queue.filter(self.TicTacToe))
def test_filter_two_players_by_tic_tac_toe(self):
player = self.create_player(games=[self.TicTacToe])
player_without_tic_tac_toe = self.create_player()
self.add_player_to_queue(player)
self.add_player_to_queue(player_without_tic_tac_toe)
self.assertItemsEqual([player], self.queue.filter(self.TicTacToe))
def test_filter_two_player_by_chess(self):
player = self.create_player(games=[self.Chess])
player_without_chess = self.create_player(games=[self.TicTacToe])
self.add_player_to_queue(player)
self.add_player_to_queue(player_without_chess)
self.assertItemsEqual([player], self.queue.filter(self.Chess))
def test_add_players_to_queue(self):
number_of_players = 2
players = self.create_players(number_of_players)
self.add_players_to_queue(players)
self.assertEqual(number_of_players, self.get_length_of_queue())
def create_player(self, games=[], name="John"):
player = Player(name)
player.games = games
return player
def create_players(self, number_of_players, games=[]):
players = []
for _ in range(number_of_players):
player = self.create_player(games=games)
players.append(player)
return players
def get_length_of_queue(self):
return len(self.queue)
def add_players_to_queue(self, players):
self.queue.add_players(players)
def add_player_to_queue(self, player):
self.queue.add_player(player)
def setUp(self):
""""""
self.queue = Queue()
self.queue.add_package(FILE_LIST)
import pytest
from core.queue import Queue, DequeQueue, EmptyQueueError
@pytest.mark.parametrize("cls", [Queue, DequeQueue])
def test_init(cls):
queue = Queue()
assert len(queue) == 0
@pytest.mark.parametrize("queue", [Queue(), DequeQueue()])
def test_dequeue_empty(queue):
with pytest.raises(EmptyQueueError):
queue.dequeue()
@pytest.mark.parametrize("queue", [Queue(), DequeQueue()])
def test_peek_empty(queue):
with pytest.raises(EmptyQueueError):
queue.peek()
@pytest.mark.parametrize("queue", [Queue(), DequeQueue()])
def test_queue(queue):
queue.enqueue(1)
queue.enqueue(2)
assert queue.peek() == 1
assert queue.dequeue() == 1
def update_cb(self, item, status=None):
""""""
Queue.update_cb(self, item, status)
self.update_row(item.id)
args = parser.parse_args()
print("CoffinBot v{} Ctrl+C to stop".format(consts.version))
mark_read = []
failure_counter = 1 # 1 by default since it is the wait timer multiplier
# Queue mode
if args.queue:
# Normal
q = None
else:
# Use the queue
from core.queue import Queue
q = Queue()
while True:
try:
failure = False
if mark_read: # Needed to clear after a Reddit disconnection error
reddit.inbox.mark_read(mark_read)
mark_read.clear()
# for all unread messages
for message in reddit.inbox.unread():
# for all unread comments
if message.was_comment:
result = None
# username mentions are simple
if message.subject == "username mention":
result = process_comment(reddit,
def setUp(self):
self.TicTacToe = "TicTacToe"
self.Chess = "Chess"
self.queue = Queue()
def test_init(cls):
queue = Queue()
assert len(queue) == 0
class TestQueue(unittest.TestCase):
""""""
def setUp(self):
""""""
self.queue = Queue()
self.queue.add_package(FILE_LIST)
def test_delete_package(self):
""""""
package = self.queue.add_package(FILE_LIST)
packages = self.queue.get_children()
self.assertEqual(len(packages), 2)
self.queue.delete(package)
self.assertEqual(len(self.queue.get_children()), 1)
self.assertEqual(self.queue.get_item(package.id), None)
def test_delete_file(self):
""""""
package = self.queue.add_package(FILE_LIST)
file1, file2 = self.queue.get_children(package.id)
old_size = self.queue.get_item(package.id).total_size
self.queue.delete(file1)
size = self.queue.get_item(package.id).total_size
self.assertEqual(size, old_size - file1.total_size)
self.assertEqual(len(self.queue.get_children(package.id)), 1)
self.assertEqual(self.queue.get_item(file1.id), None)
self.queue.delete(file2)
self.assertEqual(self.queue.get_item(file2.id), None)
self.assertEqual(self.queue.get_item(package.id), None)
def test_delete_link(self):
""""""
package = self.queue.add_package(FILE_LIST)
file1, file2 = self.queue.get_children(package.id)
link1, link2 = self.queue.get_children(file1.id)
p_size = self.queue.get_item(package.id).total_size
f_size = file1.total_size
self.queue.delete(link1)
size = self.queue.get_item(file1.id).total_size
self.assertEqual(size, f_size - link1.total_size)
size = self.queue.get_item(package.id).total_size
self.assertEqual(size, p_size - link1.total_size)
self.assertEqual(len(self.queue.get_children(file1.id)), 1)
self.assertEqual(self.queue.get_item(link1.id), None)
self.queue.delete(file2)
self.queue.delete(link2)
self.assertEqual(self.queue.get_item(link2.id), None)
self.assertEqual(self.queue.get_item(file1.id), None)
self.assertEqual(self.queue.get_item(package.id), None)
def test_move_up_link(self):
package = self.queue.get_children().pop()
file1, file2 = self.queue.get_children(package.id)
link1, link2 = self.queue.get_children(file1.id)
self.queue.move_up(link2)
link3, link4 = self.queue.get_children(file1.id)
self.assertEqual(link1, link4)
self.assertEqual(link2, link3)
self.queue.move_up(link1)
link3, link4 = self.queue.get_children(file1.id)
self.assertEqual(link1, link3)
self.assertEqual(link2, link4)
self.queue.move_up(link1)
link3, link4 = self.queue.get_children(file1.id)
self.assertEqual(link1, link3)
self.assertEqual(link2, link4)
def test_move_down_link(self):
package = self.queue.get_children().pop()
file1, file2 = self.queue.get_children(package.id)
link1, link2 = self.queue.get_children(file1.id)
self.queue.move_down(link1)
link3, link4 = self.queue.get_children(file1.id)
self.assertEqual(link1, link4)
self.assertEqual(link2, link3)
self.queue.move_down(link2)
link3, link4 = self.queue.get_children(file1.id)
self.assertEqual(link1, link3)
self.assertEqual(link2, link4)
self.queue.move_down(link2)
link3, link4 = self.queue.get_children(file1.id)
self.assertEqual(link1, link3)
self.assertEqual(link2, link4)
def test_move_up_file(self):
package = self.queue.get_children().pop()
file1, file2 = self.queue.get_children(package.id)
link1, link2 = self.queue.get_children(file1.id)
link3, link4 = self.queue.get_children(file2.id)
self.queue.move_up(file2)
file3, file4 = self.queue.get_children(package.id)
link5, link6 = self.queue.get_children(file3.id)
link7, link8 = self.queue.get_children(file4.id)
self.assertEqual(file1, file4)
self.assertEqual(file2, file3)
self.assertEqual(link1, link7)
self.assertEqual(link2, link8)
self.assertEqual(link3, link5)
self.assertEqual(link4, link6)
self.queue.move_up(file2)
file3, file4 = self.queue.get_children(package.id)
link5, link6 = self.queue.get_children(file3.id)
link7, link8 = self.queue.get_children(file4.id)
self.assertEqual(file1, file4)
self.assertEqual(file2, file3)
self.assertEqual(link1, link7)
self.assertEqual(link2, link8)
self.assertEqual(link3, link5)
self.assertEqual(link4, link6)
def mtest_move_down_file(self):
package = self.queue.get_children().pop()
file1, file2 = self.queue.get_children(package.id)
link1, link2 = self.queue.get_children(file1.id)
link3, link4 = self.queue.get_children(file2.id)
self.queue.move_down(file1)
file3, file4 = self.queue.get_children(package.id)
link5, link6 = self.queue.get_children(file3.id)
link7, link8 = self.queue.get_children(file4.id)
self.assertEqual(file1, file4)
self.assertEqual(file2, file3)
self.assertEqual(link1, link7)
self.assertEqual(link2, link8)
self.assertEqual(link3, link5)
self.assertEqual(link4, link6)
self.queue.move_down(file1)
file3, file4 = self.queue.get_children(package.id)
link5, link6 = self.queue.get_children(file3.id)
link7, link8 = self.queue.get_children(file4.id)
self.assertEqual(file1, file4)
self.assertEqual(file2, file3)
self.assertEqual(link1, link7)
self.assertEqual(link2, link8)
self.assertEqual(link3, link5)
self.assertEqual(link4, link6)
def test_move_up_package(self):
""""""
self.queue.add_package(FILE_LIST)
package1, package2 = self.queue.get_children()
file1, file2 = self.queue.get_children(package1.id)
file3, file4 = self.queue.get_children(package2.id)
link1, link2 = self.queue.get_children(file1.id)
link3, link4 = self.queue.get_children(file2.id)
link5, link6 = self.queue.get_children(file3.id)
link7, link8 = self.queue.get_children(file4.id)
self.queue.move_up(package2)
package3, package4 = self.queue.get_children()
file5, file6 = self.queue.get_children(package3.id)
file7, file8 = self.queue.get_children(package4.id)
link9, link10 = self.queue.get_children(file5.id)
link11, link12 = self.queue.get_children(file6.id)
link13, link14 = self.queue.get_children(file7.id)
link15, link16 = self.queue.get_children(file8.id)
self.assertEqual(package1, package4)
self.assertEqual(package2, package3)
self.assertEqual(file1, file7)
self.assertEqual(file2, file8)
self.assertEqual(file3, file5)
self.assertEqual(file4, file6)
self.assertEqual(link1, link13)
self.assertEqual(link2, link14)
self.assertEqual(link3, link15)
self.assertEqual(link4, link16)
self.assertEqual(link5, link9)
self.assertEqual(link6, link10)
self.assertEqual(link7, link11)
self.assertEqual(link8, link12)
self.queue.move_up(package2)
package3, package4 = self.queue.get_children()
file5, file6 = self.queue.get_children(package3.id)
file7, file8 = self.queue.get_children(package4.id)
link9, link10 = self.queue.get_children(file5.id)
link11, link12 = self.queue.get_children(file6.id)
link13, link14 = self.queue.get_children(file7.id)
link15, link16 = self.queue.get_children(file8.id)
self.assertEqual(package1, package4)
self.assertEqual(package2, package3)
self.assertEqual(file1, file7)
self.assertEqual(file2, file8)
self.assertEqual(file3, file5)
self.assertEqual(file4, file6)
self.assertEqual(link1, link13)
self.assertEqual(link2, link14)
self.assertEqual(link3, link15)
self.assertEqual(link4, link16)
self.assertEqual(link5, link9)
self.assertEqual(link6, link10)
self.assertEqual(link7, link11)
self.assertEqual(link8, link12)
def test_move_down_package(self):
""""""
package_id = self.queue.add_package(FILE_LIST)
package1, package2 = self.queue.get_children()
file1, file2 = self.queue.get_children(package1.id)
file3, file4 = self.queue.get_children(package2.id)
link1, link2 = self.queue.get_children(file1.id)
link3, link4 = self.queue.get_children(file2.id)
link5, link6 = self.queue.get_children(file3.id)
link7, link8 = self.queue.get_children(file4.id)
self.queue.move_down(package1)
package3, package4 = self.queue.get_children()
file5, file6 = self.queue.get_children(package3.id)
file7, file8 = self.queue.get_children(package4.id)
link9, link10 = self.queue.get_children(file5.id)
link11, link12 = self.queue.get_children(file6.id)
link13, link14 = self.queue.get_children(file7.id)
link15, link16 = self.queue.get_children(file8.id)
self.assertEqual(package1, package4)
self.assertEqual(package2, package3)
self.assertEqual(file1, file7)
self.assertEqual(file2, file8)
self.assertEqual(file3, file5)
self.assertEqual(file4, file6)
self.assertEqual(link1, link13)
self.assertEqual(link2, link14)
self.assertEqual(link3, link15)
self.assertEqual(link4, link16)
self.assertEqual(link5, link9)
self.assertEqual(link6, link10)
self.assertEqual(link7, link11)
self.assertEqual(link8, link12)
self.queue.move_down(package1)
package3, package4 = self.queue.get_children()
file5, file6 = self.queue.get_children(package3.id)
file7, file8 = self.queue.get_children(package4.id)
link9, link10 = self.queue.get_children(file5.id)
link11, link12 = self.queue.get_children(file6.id)
link13, link14 = self.queue.get_children(file7.id)
link15, link16 = self.queue.get_children(file8.id)
self.assertEqual(package1, package4)
self.assertEqual(package2, package3)
self.assertEqual(file1, file7)
self.assertEqual(file2, file8)
self.assertEqual(file3, file5)
self.assertEqual(file4, file6)
self.assertEqual(link1, link13)
self.assertEqual(link2, link14)
self.assertEqual(link3, link15)
self.assertEqual(link4, link16)
self.assertEqual(link5, link9)
self.assertEqual(link6, link10)
self.assertEqual(link7, link11)
self.assertEqual(link8, link12)
def test_propagate_status(self):
""""""
package = self.queue.get_children().pop()
file1, file2 = self.queue.get_children(package.id)
link1, link2 = self.queue.get_children(file1.id)
link3, link4 = self.queue.get_children(file2.id)
#p : pend, f: pend pend, l: pend pend pend pend
link1.set_status(cons.STATUS_ACTIVE)
#p : active, f: active pend, l: active pend pend pend
self.assertEqual(file1.status, cons.STATUS_ACTIVE)
self.assertEqual(package.status, cons.STATUS_ACTIVE)
link2.set_status(cons.STATUS_WAIT)
#p : active, f: active pend, l: active wait pend pend
self.assertEqual(file1.status, cons.STATUS_ACTIVE)
self.assertEqual(package.status, cons.STATUS_ACTIVE)
link1.set_status(cons.STATUS_PEND)
#p : wait, f: wait pend, l: pend wait pend pend
self.assertEqual(file1.status, cons.STATUS_WAIT)
self.assertEqual(package.status, cons.STATUS_WAIT)
link1.set_status(cons.STATUS_ACTIVE)
#p : active, f: active pend, l: active wait pend pend
link1.set_status(cons.STATUS_ERROR)
link2.set_status(cons.STATUS_ERROR)
#p : pend, f: error pend, l: error error pend pend
self.assertEqual(file1.status, cons.STATUS_ERROR)
self.assertEqual(package.status, cons.STATUS_PEND)
link1.set_status(cons.STATUS_WAIT)
#p : wait, f: wait pend, l: wait error pend pend
self.assertEqual(file1.status, cons.STATUS_WAIT)
self.assertEqual(package.status, cons.STATUS_WAIT)
link1.set_status(cons.STATUS_CORRECT)
link2.set_status(cons.STATUS_CORRECT)
#p : pend, f: correct pend, l: correct correct pend pend
self.assertEqual(file1.status, cons.STATUS_CORRECT)
self.assertEqual(package.status, cons.STATUS_PEND)
link3.set_status(cons.STATUS_ACTIVE)
#p : active, f: correct active, l: correct correct active pend
self.assertEqual(file2.status, cons.STATUS_ACTIVE)
self.assertEqual(package.status, cons.STATUS_ACTIVE)
link3.set_status(cons.STATUS_CORRECT)
link4.set_status(cons.STATUS_CORRECT)
#p : correct, f: correct correct, l: correct correct correct correct
self.assertEqual(file2.status, cons.STATUS_CORRECT)
self.assertEqual(package.status, cons.STATUS_CORRECT)
def test_sort_status(self):
tmp = self.queue.sort_status(cons.STATUS_CORRECT, cons.STATUS_STOP)
self.assertEqual(tmp, cons.STATUS_STOP)
tmp = self.queue.sort_status(cons.STATUS_STOP, cons.STATUS_ERROR)
self.assertEqual(tmp, cons.STATUS_ERROR)
tmp = self.queue.sort_status(cons.STATUS_ERROR, cons.STATUS_PEND)
self.assertEqual(tmp, cons.STATUS_PEND)
tmp = self.queue.sort_status(cons.STATUS_PEND, cons.STATUS_WAIT)
self.assertEqual(tmp, cons.STATUS_WAIT)
tmp = self.queue.sort_status(cons.STATUS_WAIT, cons.STATUS_ACTIVE)
self.assertEqual(tmp, cons.STATUS_ACTIVE)
def tearDown(self):
""""""
del self.queue