def __init__(self, bufferSize, epsilon, delta, vectorSize, historySize=0):
self.epsilon = epsilon
self.delta = delta
self.buffer = CircularList(bufferSize) # moving average buffer
self.models = ModelList(historySize)
self.mask = None
self.time = 0
self.movingAverage = 'No Moving Average'
self.movingAverageDistance = -1
self.modelVectorsDistance = -1
self.winner = 'No Winner'
self.newWinnerIndex = -1
self.previousWinnerIndex = -1
self.verbosity = 0
self.tolerance = delta
self.addModels = 1
self.winnerCount = 0
self.printDistance = 0
self.newModelVector = (None, None)
self.mapModelVector = (None, None)
self.regions = [] #list of region objects
self.prevVec = None
self.eventState = False #keep track of start of events
#Initialize region for state -1
self.regions.append(
Region(vectorSize, vectorSize, [],
len(self.models) - 1))
def move_application(self, app):
old_host = app.host_server
cluster_list = self.manager.get_docker_cluster()
circular_cluster_list = CircularList(
self.manager.order_cluster_by_load(cluster_list))
if app.host_server in circular_cluster_list:
index = circular_cluster_list.index(app.host_server)
app.host_server = circular_cluster_list[index + 1].hostname
else:
# Assign the first one in the list if not found above
app.host_server = circular_cluster_list[0].hostname
self.logger.info(
"Moving app {app_name} from {old_host} to {new_host}".format(
app_name=app.hostname,
old_host=old_host,
new_host=app.host_server))
self.logger.info("Bootstrapping the application on the new host")
self.start_application(app)
def create_containers(self,
user,
number,
formation_name,
cpu_shares,
ram,
port_list,
hostname_scheme,
volume_list,
docker_image,
force_host_server=None):
f = Formation(user, formation_name)
# Convert ram to bytes from MB
ram = ram * 1024 * 1024
# Get the cluster machines on each creation
cluster_list = self.get_docker_cluster()
circular_cluster_list = CircularList(
self.order_cluster_by_load(cluster_list))
# Loop for the requested amount of containers to be created
for i in range(1, number + 1):
# [{"host_port":ssh_host_port, "container_port":ssh_container_port}]
ssh_host_port = 9022 + i
ssh_container_port = 22
host_server = circular_cluster_list[i].hostname
hostname = '{hostname}{number}'.format(hostname=hostname_scheme,
number=str(i).zfill(3))
# First check if we can add this host to salt. If not exit with -1
if self.check_salt_key_used(hostname):
self.logger.error(
'Salt key is already taken for {hostname}'.format(
hostname=hostname))
sys.exit(-1)
# We are being asked to overwrite this
if force_host_server:
host_server = force_host_server
validated_ports = []
while self.check_port_used(host_server, ssh_host_port):
ssh_host_port = ssh_host_port + 1
for port in port_list:
self.logger.info(
"Checking if port {port} on {host} is in use".format(
port=port, host=host_server))
if ':' in port:
ports = port.split(':')
# Only check if the host port is free. The container port should be free
while self.check_port_used(host_server, ports[0]):
ports[0] = int(ports[0]) + 1
# Add this to the validated port list
validated_ports.append(
'{host_port}:{container_port}'.format(
host_port=str(ports[0]),
container_port=str(ports[1])))
else:
while self.check_port_used(host_server, port):
port = int(port) + 1
validated_ports.append(str(port))
self.logger.info(
'Adding app to formation {formation_name}: {hostname} cpu_shares={cpu} '
'ram={ram} ports={ports} host_server={host_server} docker_image={docker_image}'
.format(formation_name=formation_name,
hostname=hostname,
cpu=cpu_shares,
ram=ram,
ports=validated_ports,
host_server=host_server,
docker_image=docker_image))
f.add_app(None, '{hostname}'.format(hostname=hostname), cpu_shares,
ram, validated_ports, ssh_host_port, ssh_container_port,
host_server, docker_image, volume_list)
# Lets get this party started
for app in f.application_list:
self.start_application(app)
#self.logger.info("Sleeping 2 seconds while the container starts")
#time.sleep(2)
#self.bootstrap_application(app)
self.logger.info("Saving the formation to ETCD")
self.save_formation_to_etcd(f)
def addItem(self, vector):
tmp = CircularList(self.bucketSize)
tmp.vector = vector
tmp.counter = 0
CircularList.addItem(self, tmp)
print('pick up: {}'.format(pick_up))
destination = get_destination(cup_list, pick_up, min_cup, max_cup)
if debug:
print('destination: {}'.format(destination))
cup_list.insert_at(destination, pick_up)
cup_list.rotate()
if debug:
print()
return cup_list
puzzle_input = sys.stdin.read().strip()
print(puzzle_input)
cups = CircularList()
for x in puzzle_input:
cups.add(int(x))
min_cup = min(cups)
max_cup = max(cups)
move_number = 1
while move_number <= 100:
cups = move(move_number, cups, min_cup, max_cup, False)
move_number += 1
print('-- final --')
print('cups: {}'.format(cups))
# For final answer, rotate head until 1 is first.
while cups._head.data != 1:
