def __init__(self):
"""
Constructor
Args:
available_servers(list)
"""
self.swarm_servers = parse_config('orchastrator.json')['swarm_servers']
self.available_servers = parse_config(
'orchastrator.json')['available_servers']
self.apps_by_hosts = self.take_containers_by_hosts()
def __init__(self):
"""
Constructor
"""
# self.__user = kwargs.get('username')
# self.__password = kwargs.get('password')
self.__user = parse_config("orchastrator.json")["user"]
self.__password = parse_config("orchastrator.json")["password"]
self.__docker_client_api = docker.from_env()
self.ssh_client = paramiko.client.SSHClient()
self.host_ip = socket.gethostbyname(socket.gethostname())
def take_containers_by_hosts(self):
names_by_hosts = {}
for host in parse_config('orchastrator.json')['swarm_servers']:
names_by_hosts[host] = dict(
Counter(self.list_containers_by_host(host)))
return names_by_hosts
def list_swarm_servers(self):
"""
List the servers in the swarm
Returns:
self.swarm_servers(list)
"""
return parse_config("orchastrator.json")["swarm_servers"]
def list_available_servers(self):
"""
List the available servers remain
Returns:
self.available_servers(list)
"""
return parse_config("orchastrator.json")["available_servers"]
def join_server_swarm(self, host_ip):
"""
Join server to the swarm
Args:
host_ip(str)
"""
#####First way
# self.ssh_client.connect(host_ip, username=self.user, password=self.password)
# _, stdout, _ = self.ssh_client.exec_command('docker swarm join --token {} {}:2377'. \
# format(self.__token, self.__master))
# stdout = '\n'.join(map(lambda x: x.rstrip(), stdout.readlines()))
# if re.search(r'This node joined a swarm as a worker', stdout, re.I|re.S):
# self.remove_available_server(host_ip)
# self.add_swarm_server(host_ip)
# else:
# return "Node {} can't be joined to the swarm".format(host_ip)
#####Second way
logger = Logger(filename="orchastrator",
logger_name="SwarmManagment join_server_swarm")
docker_api = self.get_docker_api(host_ip)
response = False
try:
response = docker_api.swarm.join(remote_addrs= \
[parse_config("orchastrator.json")["master"]], \
join_token = parse_config("orchastrator.json")["token"])
except docker.errors.APIError as e:
logger.info(
"Exception handling swarm joining but config will be updated and corrected"
)
logger.clear_handler()
self.remove_available_server(host_ip)
self.add_swarm_server(host_ip)
if response == True:
logger.info(
"Node {} was successfully joined to the swarm".format(host_ip))
logger.clear_handler()
self.remove_available_server(host_ip)
self.add_swarm_server(host_ip)
else:
logger.error(
"Node {} can't be joined to the swarm".format(host_ip))
logger.clear_handler()
return "Node {} can't be joined to the swarm".format(host_ip)
def __init__(self):
"""
Constructor of swarm manager
Args:
available_servers(list)
swarm_servers(list)
user(str)
password(str)
master_node(str)
token(str)
"""
self.ssh_client = paramiko.SSHClient()
self.ssh_client.load_system_host_keys()
# self.available_servers = kwargs.get('available_servers', [])
# self.swarm_servers = kwargs.get('swarm_servers', [])
# self.user = kwargs.get('user')
# self.password = kwargs.get('password')
# self.master_nodes = kwargs.get('master_nodes', [])
# self.__master = kwargs.get('master', None)
# self.__token = kwargs.get('token')
self.available_servers = parse_config(
"orchastrator.json")["available_servers"]
self.swarm_servers = parse_config("orchastrator.json")["swarm_servers"]
self.user = parse_config("orchastrator.json")["user"]
self.password = parse_config("orchastrator.json")["password"]
self.master_nodes = parse_config("orchastrator.json")["master_nodes"]
self.__master = parse_config("orchastrator.json")["master"]
self.__token = parse_config("orchastrator.json")["token"]
def __init__(self):
"""
Constructor of Platform_Orchastration
"""
# self.available_servers = kwargs.get('available_servers', [])
# self.swarm_servers = kwargs.get('swarm_servers', [])
# self.master_nodes = kwargs.get('master_nodes', [])
# self.__master = kwargs.get('master', None)
# self.__token = kwargs.get('token')
# self.__user = kwargs.get('username')
# self.__password = kwargs.get('password')
# self.__docker_client_api = docker.from_env()
# self.stats_colector = StatsCollector()
# self.swarm_manager = SwarmManagment(available_servers=self.available_servers,
# swarm_servers=self.swarm_servers,
# master_nodes=self.master_nodes,
# master=self.__master,
# token=self.__token,
# user=self.__user,
# password=self.__password
# )
self.available_servers = parse_config(
"orchastrator.json")["available_servers"]
self.swarm_servers = parse_config("orchastrator.json")["swarm_servers"]
self.user = parse_config("orchastrator.json")["user"]
self.password = parse_config("orchastrator.json")["password"]
self.master_nodes = parse_config("orchastrator.json")["master_nodes"]
self.__master = parse_config("orchastrator.json")["master"]
self.__token = parse_config("orchastrator.json")["token"]
self.__docker_client_api = docker.from_env()
self.stats_colector = StatsCollector()
self.swarm_manager = SwarmManagment()
def making_host_decision(self, application, decision, release_node=False):
"""
Make decision on which host to run container
Args:
application(str)
decision(str)
Returns:
host(str)
"""
logger = Logger(filename="orchastrator",
logger_name="DecisionMaker making_host_decision")
swarm_manager = SwarmManagment()
app_per_node = "{}_per_node".format(application)
app_by_hosts = self.counting_app_by_host(application)
if release_node:
del (app_by_hosts[release_node])
host_number = len(app_by_hosts.keys())
if decision is 'up':
application_number = 0
for host in app_by_hosts.keys():
if app_by_hosts[host][application] == 0:
return host
else:
application_number += app_by_hosts[host][application]
average_app_number = application_number / host_number
# print("Average => {}".format(average_app_number))
# print("Appp => {}".format(parse_config('orchastrator.json')[app_per_node]))
logger.info("Aplication {} ||| Average => {}\tApp_per_node => {}". \
format(application, average_app_number, parse_config('orchastrator.json')[app_per_node]))
logger.clear_handler()
###logic for adding node to the swarm
if average_app_number >= parse_config(
'orchastrator.json')[app_per_node]:
if len(parse_config('orchastrator.json')
['available_servers']) != 0:
new_server = parse_config(
'orchastrator.json')['available_servers'][0]
swarm_manager.join_server_swarm(host_ip=parse_config(
'orchastrator.json')['available_servers'][0])
return new_server
else:
logger.critical("There are not any available servers should" \
"look at host stat to run on the lowest" \
"loaded host a container")
logger.clear_handler()
# print("There are not any available servers should \
# look at host stat to run on the lowest \
# loaded host a container")
###logic for adding node to the swarm
for host in app_by_hosts.keys():
if app_by_hosts[host][application] < average_app_number and \
app_by_hosts[host][application] < parse_config('orchastrator.json')[app_per_node]:
return host
for host in app_by_hosts.keys():
return host
elif decision is 'down':
application_number = 0
for host in app_by_hosts.keys():
application_number += app_by_hosts[host][application]
min_app = "{}_min".format(application)
# print("Min_app => {}\t app_num {}".format(parse_config('orchastrator.json')[min_app], application_number))
logger.warning("Application => {} ||| min_apps on platform=> {}\tcurrent app_num {}". \
format(application, parse_config('orchastrator.json')[min_app], application_number))
logger.clear_handler()
if application_number == parse_config(
'orchastrator.json')[min_app]:
return None
average_app_number = application_number / host_number
for host in app_by_hosts.keys():
if app_by_hosts[host][application] > average_app_number and \
app_by_hosts[host][application] < parse_config('orchastrator.json')[app_per_node]:
return host
for host in app_by_hosts.keys():
return host
decision_maker = DecisionMaker()
swarm_manager = SwarmManagment()
container_manager = ContainerManagement()
app_for_incremnting = None
app_for_decrementing = None
####for admin request tool
print(decision_maker.release_node('10.102.7.123'))
####for admin request tool
###Running container if minimum quota is not applied
apps_count = decision_maker.calculating_app_on_hosts()
for app in apps_count:
min_app = "{}_min".format(app)
while apps_count[app] < parse_config('orchastrator.json')[min_app]:
print(
"Running container from app {} because of minimum quota limitation"
.format(app))
host = decision_maker.making_host_decision(app, decision='up')
container_manager.run_container(host_ip=host, application=app)
###new object to take the new platform configuration
decision_maker = DecisionMaker()
container_manager = ContainerManagement()
###new object to take the new platform configuration
apps_count = decision_maker.calculating_app_on_hosts()
time.sleep(10)
###Running container if minimum quota is not applied
containers_stats = stats_collector.parsed_stats()
print("Stats of containers are taken => {}".format(containers_stats))
