def update_kubam_ip():
if not request.json:
return jsonify({'error': 'expected request with kubam_ip '}), 400
if "kubam_ip" not in request.json:
return jsonify({'error': 'expected request with kubam_ip '}), 400
ip = request.json['kubam_ip']
err, msg = YamlDB.update_kubam_ip(KUBAM_CFG, ip)
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({'kubam_ip': ip}), 201
def update_proxy():
if not request.json:
return jsonify({'error': 'expected request with proxy '}), 400
if "proxy" not in request.json:
return jsonify({'error': 'expected request with proxy'}), 400
proxy = request.json['proxy']
err, msg = YamlDB.update_proxy(KUBAM_CFG, proxy)
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({'proxy': proxy}), 201
def update_public_keys():
if not request.json:
return jsonify({'error': 'expected request with keys '}), 400
if "keys" not in request.json:
return jsonify({'error': 'expected request with keys '}), 400
keys = request.json['keys']
err, msg = YamlDB.update_public_keys(KUBAM_CFG, keys)
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({'keys' : keys}), 201
def create_creds():
if not request.json:
return jsonify({'error': 'expected credentials hash'}), 400
credentials = {}
credentials['user'] = request.json['credentials']['user']
credentials['password'] = request.json['credentials']['password']
credentials['ip'] = request.json['credentials']['server']
if credentials['ip'] == "":
return jsonify({'error': "Please enter a valid UCSM IP address."}), 401
#app.logger.info("starting login attempt to UCS.")
h, err = UCSSession.login(credentials['user'],
credentials['password'],
credentials['ip'])
if h == "":
return jsonify({'error': err}), 401
# write datafile.
YamlDB.update_ucs_creds(KUBAM_CFG, credentials)
UCSSession.logout(h)
return jsonify({'login': "******"}), 201
def update_ucs_org():
if not request.json:
return jsonify({'error': 'expected request with org'}), 400
if "org" not in request.json:
return jsonify({'error': 'expected request with org'}), 400
org = request.json['org']
err, msg = YamlDB.update_org(KUBAM_CFG, org)
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({'org' : org}), 201
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 get_networks():
err, msg, handle = login()
if err != 0:
return not_logged_in(msg)
vlans = UCSNet.listVLANs(handle)
logout(handle)
err, msg, net_hash = YamlDB.get_network(KUBAM_CFG)
err, msg, net_settings = YamlDB.get_ucs_network(KUBAM_CFG)
selected_vlan = ""
if "vlan" in net_settings:
selected_vlan = net_settings["vlan"]
return jsonify({
'vlans': [{
"name": vlan.name,
"id": vlan.id,
"selected": (vlan.name == selected_vlan)
} for vlan in vlans],
'network':
net_hash
}), 200
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
def login():
err, msg, config = YamlDB.open_config(KUBAM_CFG)
if err == 0:
if "ucsm" in config and "credentials" in config["ucsm"]:
creds = config["ucsm"]["credentials"]
if "user" in creds and "password" in creds and "ip" in creds:
h, msg = UCSSession.login(creds["user"], creds["password"], creds["ip"])
if h != "":
return 0, "", h
return 1, msg, ""
return 1, "error logging in: %s" % msg, ""
def update_iso_map():
app.logger.info("request.json")
app.logger.info(request.json)
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
isos = request.json['iso_map']
err, msg = YamlDB.update_iso_map(KUBAM_CFG, isos)
if err != 0:
return jsonify({'error': msg}), 400
return get_iso_map()
def disk_operation(server_group):
"""
Figure out the operation and do it.
"""
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"]
## login to UCS Manager and do the action.
if sg["type"] == "ucsm":
try:
handle = UCSUtil.ucs_login(sg)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_UNAUTHORIZED
if request.method == "DELETE":
js, rc = Disks.delete_ucsm(handle, wanted)
js, rc = Disks.list_ucsm(handle, wanted)
return jsonify(js), rc
## login to UCS Central and do the action
elif sg["type"] == "ucsc":
try:
handle = UCSCUtil.ucsc_login(sg)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_UNAUTHORIZED
if request.method == "DELETE":
js, rc = Disks.delete_ucsc(handle, wanted)
js, rc = Disks.list_ucsc(handle, wanted)
return jsonify(js), rc
def test_update_iso_map(self):
err, msg = YamlDB.update_iso_map("/tmp/bfoo.yaml", [{
"os":
"centos7.3",
"file":
"/Users/vallard/Downloads/kubam/CentOS-7-x86_64-Minimal-1611.iso"
}, {
"os":
"esxi6.0",
"file":
"/Users/vallard/Downloads/kubam/Vmware-ESXi-6.0.0-5050593-Custom-Cisco-6.0.3.2.iso"
}])
assert (err == 0)
def update_settings():
app.logger.info(request.json)
if not request.json:
return jsonify({'error': 'expected kubam_ip and keys in json request'}), 400
if not "kubam_ip" in request.json:
return jsonify({'error': 'Please enter the IP address of the kubam server'}), 400
if not "keys" in request.json:
return jsonify({'error': 'Please specify keys. See documentation for how this should look: https://ciscoucs.github.io/kubam/docs/settings.'}), 400
# proxy and org are not manditory.
if "proxy" in request.json:
proxy = request.json['proxy']
err, msg = YamlDB.update_proxy(KUBAM_CFG, proxy)
if err != 0:
return jsonify({'error': msg}), 400
if "org" in request.json:
org = request.json['org']
err, msg = YamlDB.update_org(KUBAM_CFG, org)
if err != 0:
return jsonify({'error': msg}), 400
# update the kubam_IP if it is changed.
ip = request.json['kubam_ip']
err, msg = YamlDB.update_kubam_ip(KUBAM_CFG, ip)
if err != 0:
return jsonify({'error': msg}), 400
# update the keys if changed.
keys = request.json['keys']
app.logger.info(keys)
err, msg = YamlDB.update_public_keys(KUBAM_CFG, keys)
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({"status": "ok"}), 201
def select_vlan():
if not request.json:
return jsonify({'error': 'expected hash of VLANs'}), 400
err, msg, handle = login()
if err != 0:
return not_logged_in(msg)
#app.logger.info("Request is: ")
#app.logger.info(request)
vlan = request.json['vlan']
err, msg = YamlDB.update_ucs_network(KUBAM_CFG, {"vlan": vlan})
if err != 0:
return jsonify({'error': msg}), 500
# return the existing networks now with the new one chosen.
return get_networks()
def powerstat(server_group):
"""
Get the power stat for the servers.
"""
powerstat = ""
wanted_servers = "all"
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 request.json and "servers" in request.json:
wanted_servers = request.json["servers"]
current_app.logger.info(wanted_servers)
if sg['type'] == "ucsm":
powerstat = powerstat_ucsm(sg, wanted_servers)
elif sg['type'] == "ucsc":
powerstat = powerstat_ucsc(sg, wanted_servers)
else:
return jsonify({"error": "powerstat not supported on this type of server"}), Const.HTTP_BAD_REQUEST
return jsonify({"status" : powerstat }), Const.HTTP_OK
def mkboot_iso():
# get the iso map
err, msg, isos = YamlDB.get_iso_map(KUBAM_CFG)
if err != 0:
return jsonify({"error": msg}), 400
if len(isos) == 0:
return jsonify({"error": "No ISOS have been mapped. Please map an ISO image with an OS"}), 400
err, msg = IsoMaker.mkboot_iso(isos)
if err != 0:
return jsonify({"error": msg}), 400
err, msg = Builder.deploy_server_images(KUBAM_CFG)
if err != 0:
return jsonify({"error": msg}), 400
return jsonify({"status": "ok"}), 201
def create_servers(req):
"""
Create a new UCS Domain
Format of request should be JSON that looks like:
{"name", "ucs01", "type" : "ucsm", "credentials":
{"user": "******", "password": "******", "ip" : "172.28.225.163" }}
"""
err, msg = YamlDB.check_valid_server_group(req)
if err != 0:
return {"error": msg}, Const.HTTP_BAD_REQUEST
# Make sure we can log in first.
if not 'type' in req:
return {"error": "No server type sent as part of request"}, Const.HTTP_UNAUTHORIZED
if req['type'] == "ucsm":
try:
UCSUtil.check_ucs_login(req)
except KubamError as e:
return {"error": str(e)}, Const.HTTP_UNAUTHORIZED
elif req["type"] == "ucsc":
try:
UCSCUtil.check_ucsc_login(req)
except KubamError as e:
return {"error":str(e)}, Const.HTTP_UNAUTHORIZED
elif req["type"] == "imc":
try:
IMCUtil.check_imc_login(req)
except KubamError as e:
return {"error":str(e)}, Const.HTTP_UNAUTHORIZED
else:
return {"error": "type: {0} is not recognized".format(req["type"])}, Const.HTTP_UNAUTHORIZED
db = YamlDB()
err, msg = db.new_server_group(Const.KUBAM_CFG, req)
if err == 1:
return {"error": msg}, Const.HTTP_BAD_REQUEST
return {"status": "new server group {0} created!".format(req['name'])}, Const.HTTP_CREATED
def deploy_server_images(config):
err = 0
msg = "ok"
err, msg, config = YamlDB.parse_config(config, True)
if err > 0:
return err, msg
for host in config["hosts"]:
err, msg, template = build_template(host, config)
if err > 0:
break
err, msg = build_boot_image(host, template)
if err == 1:
break
return err, msg
def get_full_org(handle):
full_org = ""
err, msg, org = YamlDB.get_org(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 = UCSUtil.create_org(handle, org)
return err, msg, full_org
def destroy():
app.logger.info("Deleting deployment")
err, msg, handle = login()
if err != 0:
return not_logged_in(msg)
err, msg, hosts = YamlDB.get_hosts(KUBAM_CFG)
if err != 0:
return jsonify({'error': msg}), 400
if len(hosts) == 0:
return jsonify({"status": "no servers deployed"}), 200
err, msg = UCSServer.deleteKubeServers(handle, "org-root/org-kubam", hosts)
if err != 0:
return jsonify({'error': msg}), 400
err, msg = UCSNet.deleteKubeNetworking(handle, "org-root/org-kubam")
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({"status": "ok"}), 201
def login():
err, msg, config = YamlDB.open_config(KUBAM_CFG)
if err == 0:
if "ucsm" in config and "credentials" in config["ucsm"]:
creds = config["ucsm"]["credentials"]
if "user" in creds and "password" in creds and "ip" in creds:
h, msg = UCSSession.login(creds["user"], creds["password"],
creds["ip"])
if h != "":
return 0, "", h
return 1, msg, ""
else:
msg = "kubam.yaml file does not include the user, password, and ip properties to login."
err = 1
else:
msg = "UCS Credentials have not been entered. Please login to UCS to continue."
err = 1
return err, msg, ""
def make_ucs():
ucs_util = UCSUtil()
try:
handle = ucs_util.ucs_login()
except KubamError as e:
return 1, str(e)
err, msg, full_org = ucs_util.get_full_org(handle)
if err != 0:
return err, msg
db = YamlDB()
err, msg, net_settings = db.get_ucs_network(Const.KUBAM_CFG)
selected_vlan = ""
if "vlan" in net_settings:
selected_vlan = net_settings["vlan"]
if selected_vlan == "":
UCSUtil.ucs_logout(handle)
return 1, "No VLAN selected in UCS configuration."
ucs_net = UCSNet()
err, msg = ucs_net.create_kube_networking(handle, full_org, selected_vlan)
if err != 0:
UCSUtil.ucs_logout(handle)
return err, msg
# Get the selected servers and hosts
err, msg, hosts = db.get_hosts(Const.KUBAM_CFG)
err, msg, servers = db.get_ucs_servers(Const.KUBAM_CFG)
err, msg, kubam_ip = db.get_kubam_ip(Const.KUBAM_CFG)
ucs_server = UCSServer()
err, msg = ucs_server.create_server_resources(handle, full_org, hosts, servers, kubam_ip)
if err != 0:
UCSUtil.ucs_logout(handle)
return err, msg
UCSUtil.ucs_logout(handle)
return err, msg
def create_vmedia(server_group):
"""
Create the Vmedia policy for a server group
"""
db = YamlDB()
# get server group.
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"]
# go through all hosts associated with this server group
err, msg, hosts = db.list_hosts(Const.KUBAM_CFG)
if err == 1:
return jsonify({'error': msg}), Const.HTTP_BAD_REQUEST
hosts = [x for x in hosts if 'server_group' in x and x['server_group'] == server_group]
if len(hosts) < 1:
return jsonify({'error': 'no hosts associated with server group'}), Const.HTTP_OK
# get the os image they use
oses = list(set([ x["os"] for x in hosts]))
# create those vmedia policies
err = 0
msg = ""
err, msg, kubam_ip = db.get_kubam_ip(Const.KUBAM_CFG)
if kubam_ip is None:
return jsonify({'error': 'Please define the KUBAM IP first.'} ), Const.HTTP_OK
handle = ""
if sg['type'] == 'ucsm':
try:
handle = UCSUtil.ucs_login(sg)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
err, msg = UCSServer.make_vmedias(handle, org, kubam_ip, oses)
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_BAD_REQUEST
err, msg = UCSCServer.make_vmedias(handle, org, kubam_ip, oses)
UCSCUtil.ucsc_logout(handle)
elif sg['type'] == 'imc':
try:
handle = IMCUtil.imc_login(sg)
except KubamError as e:
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
try:
IMCServer.mount_media(handle, kubam_ip, hosts[0]['name'], oses[0])
except KubamError as e:
IMCUtil.imc_logout(handle)
return jsonify({"error": str(e)}), Const.HTTP_BAD_REQUEST
IMCUtil.imc_logout(handle)
if err != 0:
return jsonify({'error': msg}), Const.HTTP_BAD_REQUEST
return jsonify({"status": oses}), Const.HTTP_CREATED
def delete_templates(self, server_group, req):
ucs_templates = self.get_templates(server_group)
db = YamlDB()
msg = db.delete_template(Const.KUBAM_CFG, req, server_group, ucs_templates)
return {"status": msg}, Const.HTTP_NO_CONTENT
def update_templates(self, server_group, req):
ucs_templates = self.get_templates(server_group)
db = YamlDB()
msg = db.assign_template(Const.KUBAM_CFG, req, server_group, ucs_templates)
return {"status": msg}, Const.HTTP_CREATED
def get_iso_map():
db = YamlDB()
err, msg, iso_images = db.get_iso_map(Const.KUBAM_CFG)
if err != 0:
return jsonify({'error': msg}), 400
return jsonify({'iso_map': iso_images}), 200
def test_get_ucs_servers(self):
err, msg, servers = YamlDB.get_ucs_servers("/tmp/bfoo.yaml")
assert (err == 0)
assert ("blades" in servers)
def test_get_ucs_vlan(self):
err, msg, net = YamlDB.get_ucs_network("/tmp/bfoo.yaml")
assert (err == 0)
assert ("vlan" in net)
def test_add_ucs_servers(self):
err, msg = YamlDB.update_ucs_servers("/tmp/bfoo.yaml", {
"blades": ["1/1", "1/2"],
"rack_servers": ["7", "8", "9"]
})
assert (err == 0)
def test_add_ucs_vlan(self):
err, msg = YamlDB.update_ucs_network("/tmp/bfoo.yaml",
{"vlan": "default"})
assert (err == 0)
