def make_images(hosts):
"""
given an array of host dictionaries, build an image for each one.
"""
# make the post directory
err, msg = Builder.make_post()
if err > 0:
return err, msg
db = YamlDB()
err, msg, config = db.parse_config(Const.KUBAM_CFG, True)
if err > 0:
return err, msg
for host in hosts:
err, msg, template, net_template = Builder.build_template(host, config)
if err > 0:
print err, msg
break
err, msg = Builder.build_boot_image(host, template, net_template)
if err == 1:
print err, msg
break
return err, msg
def deploy_servers(server_group):
"""
Given a server group, deploy the resources in this form:
1. If a service profile template is defined, create a sp from the template and associate
2. If no service profile is defined, create all resources (like we did before)
"""
#TODO: deploy only hosts that are given as parameters.
db = YamlDB()
try:
sg = db.get_server_group(Const.KUBAM_CFG, server_group)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
org = "org-root"
if "org" in sg:
org = sg["org"]
err, msg, hosts = db.get_hosts_in_server_group(Const.KUBAM_CFG, server_group)
if err != 0:
return jsonify({"error": msg}), Const.HTTP_BAD_REQUEST
if len(hosts) < 1:
return jsonify({"error": "No hosts defined in the server group"}), Const.HTTP_BAD_REQUEST
if sg['type'] == 'ucsc':
return deploy_ucsc(sg, hosts, org)
elif sg['type'] == 'ucsm':
return deploy_ucs(sg, hosts, org)
return jsonify({"error": "server group type is not supported.".format(sg['type'])}), Const.HTTP_BAD_REQUEST
def power_server(server_group, req_json, action):
"""
Power actions for a server: off, on, hardreset, softreset
"""
db = YamlDB()
# get server group.
servers = ""
try:
sg = db.get_server_group(Const.KUBAM_CFG, server_group)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
try:
servers = req_json['servers']
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
# find out if server is ucsc or ucs
err = 0
msg = ""
powerstat = ""
if sg['type'] == "ucsm":
return power_server_ucsm(sg, servers, action)
elif sg['type'] == "ucsc":
return power_server_ucsc(sg, servers, action)
def get_server_status(server_group):
"""
Get the FSM or status of the server... what its doing now.
Expects { servers: { blade: [ 1/1, 1/2, ...], rack_server: [ 1, 2, 3] }}
(with quotes of course for proper json)
if nothing is passed, returns everything.
"""
wanted = "all"
try:
db = YamlDB()
sg = db.get_server_group(Const.KUBAM_CFG, server_group)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
if request.json and "servers" in request.json:
wanted = request.json["servers"]
if sg["type"] == "ucsm":
return get_server_status_ucsm(sg, wanted)
elif sg["type"] == "ucsc":
return get_server_status_ucsc(sg, wanted)
return jsonify({
"error":
"server group {0} is not a supported type".format(sg["type"])
}), Const.HTTP_BAD_REQUEST
def destroy_ucs():
ucs_util = UCSUtil()
try:
handle = ucs_util.ucs_login()
except KubamError as e:
return 1, str(e)
db = YamlDB()
err, msg, hosts = db.get_hosts(Const.KUBAM_CFG)
if err != 0:
return 1, msg
if len(hosts) == 0:
return 0, "no servers deployed"
err, msg, full_org = ucs_util.get_full_org(handle)
if err != 0:
return err, msg
ucs_server = UCSServer()
err, msg = ucs_server.delete_server_resources(handle, full_org, hosts)
if err != 0:
return 1, msg
ucs_net = UCSNet()
err, msg = ucs_net.delete_kube_networking(handle, full_org)
if err != 0:
return 1, msg
return 0, "ok"
def ucsc_login(server_group):
"""
login to a UCS and return a login handle
"""
if not isinstance(server_group, dict):
raise KubamError("Login format is not correct")
if "credentials" in server_group:
credentials = server_group["credentials"]
if "user" in credentials and "password" in credentials and "ip" in credentials:
ucs_session = UCSCSession()
db = YamlDB()
err, msg, password = db.decrypt_password(
credentials['password'])
if err == 1:
raise KubamError(msg)
h, msg = ucs_session.login(credentials['user'], password,
credentials['ip'])
if msg:
raise KubamError(msg)
if h:
return h
else:
raise KubamError("Not logged in into UCS")
else:
raise KubamError(
"The file kubam.yaml does not include the user, password, and IP properties to login."
)
else:
raise KubamError(
"UCS Credentials have not been entered. Please login to UCS to continue."
)
def create_hosts(req):
"""
Create a new host entry
"""
db = YamlDB()
err, msg = db.new_hosts(Const.KUBAM_CFG, req)
if err == 1:
return {'error': msg}, 400
return {'status': "Hosts created!"}, 201
def list_network():
"""
Lists all the network groups
"""
db = YamlDB()
err, msg, net_list = db.list_network_group(Const.KUBAM_CFG)
if err == 1:
return {"error": msg}, Const.HTTP_SERVER_ERROR
return {"networks": net_list}, Const.HTTP_OK
def update_network(req):
"""
Update network settings of one of the network groups.
"""
db = YamlDB()
err, msg = db.update_network_group(Const.KUBAM_CFG, req)
if err == 1:
return {"error": msg}, Const.HTTP_BAD_REQUEST
return {"status": "ok"}, Const.HTTP_CREATED
def list_aci():
"""
Basic test to see if site is up.
should return { 'status' : 'ok'}
"""
db = YamlDB()
err, msg, aci_list = db.list_aci(Const.KUBAM_CFG)
if err == 1:
return {'error': msg}, 500
return {'aci': aci_list}, 200
def list_hosts():
"""
Basic test to see if site is up.
Should return { 'status' : 'ok'}
"""
db = YamlDB()
err, msg, host_list = db.list_hosts(Const.KUBAM_CFG)
if err == 1:
return {'error': msg}, 500
return {"hosts": host_list}, 200
def list_servers():
"""
/ basic test to see if site is up.
should return { 'status' : 'ok'}
"""
db = YamlDB()
err, msg, sg = db.list_server_group(Const.KUBAM_CFG)
if err == 1:
return {"error": msg}, Const.HTTP_SERVER_ERROR
return {"servers": sg}, Const.HTTP_OK
def create_network(req):
"""
Create a new network group
"""
db = YamlDB()
err, msg = db.new_network_group(Const.KUBAM_CFG, req)
if err == 1:
return {"error": msg}, Const.HTTP_BAD_REQUEST
return {
"status": "Network {0} created!".format(req['name'])
}, Const.HTTP_CREATED
def update_aci(req):
"""
Update an ACI group
"""
err, msg = UCSUtil.check_aci_login(req)
if err == 1:
return jsonify({'error': msg}), 400
db = YamlDB()
err, msg = db.update_aci(Const.KUBAM_CFG, req)
if err == 1:
return {'error': msg}, 400
return {'status': "ACI group {0} updated!".format(req["name"])}, 201
def update_iso_map():
if not request.json:
return jsonify({'error': 'expected request with iso_map '}), 400
if "iso_map" not in request.json:
return jsonify({'error': 'expected request with iso_map '}), 400
iso_images = request.json['iso_map']
db = YamlDB()
err, msg = db.update_iso_map(Const.KUBAM_CFG, iso_images)
if err != 0:
return jsonify({'error': msg}), 400
return get_iso_map()
def update_servers(req):
"""
Update a server group
"""
try:
UCSUtil.check_ucs_login(req)
except KubamError as e:
return {"error": str(e)}, Const.HTTP_UNAUTHORIZED
db = YamlDB()
err, msg = db.update_server_group(Const.KUBAM_CFG, req)
if err == 1:
return {"error": msg}, Const.HTTP_BAD_REQUEST
return {"status": "server group {0} updated!".format(req['name'])}, Const.HTTP_CREATED
def update_hosts(req):
"""
Given a list of hosts will completely rewrite
the existing hosts entries as long as the values
of each entry are correct.
Should be an array of hosts passed in.
Basically does the same thing as a create.
"""
db = YamlDB()
err, msg = db.new_hosts(Const.KUBAM_CFG, req)
if err == 1:
return {'error': msg}, 400
return {"status": "hosts updated"}, 201
def get_templates(server_group):
ucs_templates = []
db = YamlDB()
sg = db.get_server_group(Const.KUBAM_CFG, server_group)
if sg['type'] == "ucsc":
handle = UCSCUtil.ucsc_login(sg)
ucs_templates = UCSCTemplate.list_templates(handle)
UCSCUtil.ucsc_logout(handle)
elif sg['type'] == "ucsm":
handle = UCSUtil.ucs_login(sg)
ucs_templates = UCSTemplate.list_templates(handle)
UCSUtil.ucs_logout(handle)
return ucs_templates
def get_valid_isos(os_list):
valid_os = []
db = YamlDB()
err, msg, iso_map = db.get_iso_map(Const.KUBAM_CFG)
if err != 0:
return 1, msg, None
if iso_map == None:
return 1, "Please upload ISO Images first", None
for i in os_list:
valid_iso = [x for x in iso_map if x["os"] == i]
if not i in [x["os"] for x in iso_map]:
return 1, "Please map {0} to an iso image".format(i), None
valid_os.append(valid_iso[0])
return 0, None, valid_os
def get_valid_hosts(host_list):
valid_hosts = []
db = YamlDB()
err, msg, hosts = db.list_hosts(Const.KUBAM_CFG)
if err != 0:
return err, msg, hosts
if isinstance(host_list, list):
for i in host_list:
valid_host = [x for x in hosts if x["name"] == i]
if len(valid_host) == 0:
return 1, "{0} is not a valid host".format(i), ""
valid_hosts.append(valid_host[0])
else:
valid_hosts = hosts
return 0, None, valid_hosts
def delete_servers(req):
"""
Delete the UCS server group or CIMC from the config.
"""
if not isinstance(req, dict):
return {"error": "invalid parameters: {0}".format(req)}, Const.HTTP_BAD_REQUEST
if not "name" in req:
return {"error": "please give the server group name you wish to delete"}, Const.HTTP_BAD_REQUEST
name = req['name']
db = YamlDB()
err, msg = db.delete_server_group(Const.KUBAM_CFG, name)
if err == 1:
return {"error": msg}, Const.HTTP_BAD_REQUEST
else:
return {"status": "Server group deleted"}, Const.HTTP_NO_CONTENT
def get_full_org(self, handle):
db = YamlDB()
err, msg, org = db.get_org(Const.KUBAM_CFG)
if err != 0:
return err, msg, org
if org == "":
org = "kubam"
if org == "root":
full_org = "org-root"
else:
full_org = "org-root/org-" + org
if org != "root":
err, msg = self.create_org(handle, org)
return err, msg, full_org
def delete_aci(req):
"""
Delete the ACI group from the config.
"""
if not isinstance(req, dict):
return {'error': 'no details sent'}, Const.HTTP_BAD_REQUEST
if not 'name' in req:
return {
'error': 'no name given for ACI to delete'
}, Const.HTTP_BAD_REQUEST
name = req['name']
db = YamlDB()
err, msg = db.delete_aci(Const.KUBAM_CFG, name)
if err == 1:
return {'error': msg}, 400
else:
return {'status': "ACI group deleted"}, 201
def create_aci(req):
"""
Create a new ACI entry
Format of request should be JSON that looks like:
{"name", "aci01", "credentials" : {"user":"******", "password": "******",
"ip" : "172.28.225.163" }, ...}
"""
# Make sure we can log in first.
msg, code = UCSUtil.check_aci_login(req)
if code == 400:
return msg, code
db = YamlDB()
err, msg = db.new_aci(Const.KUBAM_CFG, req)
if err == 1:
return {'error': msg}, 400
return {
'status': "new ACI group {0} created!".format(req["name"])
}, 201
def delete_hosts(req):
"""
Delete the hosts group from the config.
"""
if not isinstance(req, dict):
return {
"error": "invalid parameters: {0}".format(req)
}, Const.HTTP_BAD_REQUEST
if not "name" in req:
return {
"error": "please give the name of the host you wish to delete"
}, Const.HTTP_BAD_REQUEST
name = req["name"]
db = YamlDB()
err, msg = db.delete_hosts(Const.KUBAM_CFG, name)
if err == 1:
return {'error': msg}, 400
else:
return {'status': "Hosts deleted"}, 201
def select_servers(server_group):
"""
Given a server group, select the servers from the server group (if this is UCS) that should be
selected to be deployed and placed in a kubam group
"""
# make sure we got some data.
if not request.json:
return jsonify({"error": "expected hash of servers"}), Const.HTTP_BAD_REQUEST
if "servers" not in request.json:
return jsonify({"error": "expected 'servers' with hash of servers in request"}), Const.HTTP_BAD_REQUEST
# we expect servers to be a hash of like:
# {servers: {blades: ["1/1", "1/2",..], rack: ["6", "7"]}}
ucs_servers = request.json['servers']
if ucs_servers:
db = YamlDB()
err, msg = db.update_ucs_servers(Const.KUBAM_CFG, ucs_servers, server_group)
if err != 0:
return jsonify({"error": msg}), Const.HTTP_BAD_REQUEST
return jsonify({"status": "ok"}), Const.HTTP_CREATED
def delete_network(req):
"""
Delete the network group from the config.
"""
if not isinstance(req, dict):
return {
"error":
"no parameters given to delete. Please send the network name to delete"
}, Const.HTTP_BAD_REQUEST
if not "name" in req:
return {
"error": "please send the 'name' of the network to delete"
}, Const.HTTP_BAD_REQUEST
name = req['name']
db = YamlDB()
err, msg = db.delete_network_group(Const.KUBAM_CFG, name)
if err == 1:
return {"error": msg}, Const.HTTP_BAD_REQUEST
else:
return {"status": "Network deleted"}, Const.HTTP_CREATED
def get_server_fsm(server_group):
wanted = "all"
try:
db = YamlDB()
sg = db.get_server_group(Const.KUBAM_CFG, server_group)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
if request.json and "servers" in request.json:
wanted = request.json["servers"]
if sg['type'] == 'ucsm':
return ucs_fsm(sg, wanted)
elif sg['type'] == 'ucsc':
return ucsc_fsm(sg, wanted)
return jsonify({
"error":
"server group {0} is not a supported type".format(sg["type"])
}), Const.HTTP_BAD_REQUEST
def get_servers(server_group):
"""
List all the servers in the server group
or in this case the domain.
1. Make call to UCS to grab the servers.
2. Make call to database to see which ones are selected.
3. Call servers_to_api which merges the two adding 'selected: true' to the servers that are selected.
"""
db = YamlDB()
try:
sg = db.get_server_group(Const.KUBAM_CFG, server_group)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
if sg['type'] == "ucsm":
try:
handle = UCSUtil.ucs_login(sg)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_UNAUTHORIZED
ucs_servers = UCSServer.list_servers(handle)
UCSUtil.ucs_logout(handle)
elif sg['type'] == 'ucsc':
try:
handle = UCSCUtil.ucsc_login(sg)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_UNAUTHORIZED
ucs_servers = UCSCServer.list_servers(handle)
UCSCUtil.ucsc_logout(handle)
# Gets a hash of severs of form:
# {blades: ["1/1", "1/2",..], rack: ["6", "7"]}
err, msg, db_servers = db.get_ucs_servers(Const.KUBAM_CFG, server_group)
if err != 0:
return jsonify({"error": msg}), Const.HTTP_BAD_REQUEST
if db_servers is None:
return jsonify({"servers": ucs_servers})
ucs_servers = UCSUtil.servers_to_api(ucs_servers, db_servers)
if err != 0:
return jsonify({"error": msg}), Const.HTTP_BAD_REQUEST
return jsonify({"servers": ucs_servers}), Const.HTTP_OK
def mkboot_iso():
# Get the ISO map
db = YamlDB()
err, msg, iso_images = db.get_iso_map(Const.KUBAM_CFG)
if err != 0:
return jsonify({"error": msg}), 400
if len(iso_images) == 0:
return jsonify({
"error":
"No ISOS have been mapped. Please map an ISO image with an OS"
}), 400
iso_maker = IsoMaker()
err, msg = iso_maker.mkboot_iso(isos)
if err != 0:
return jsonify({"error": msg}), 400
builder = Builder()
err, msg = builder.deploy_server_images(Const.KUBAM_CFG)
if err != 0:
return jsonify({"error": msg}), 400
return jsonify({"status": "ok"}), 201
