def execute(self, server, cmd_data_json):
if ("parent_name" not in cmd_data_json
or "vlan_id" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'create vlan request must have parent name' +
' and vlan id defined, got: ' + str(cmd_data_json))
parent = cmd_data_json["parent_name"]
vlan_id = cmd_data_json["vlan_id"]
cmd = "net-vlan-create"
call = NaElement(cmd)
vi = NaElement("vlan-info")
vi.child_add_string("parent-interface", parent)
vi.child_add_string("vlanid", vlan_id)
if "node_name" in cmd_data_json:
vi.child_add_string("node", cmd_data_json["node_name"])
call.child_add(vi)
_, err_resp = self._INVOKE_CHECK(server, call,
cmd + ": " + parent + ":" + vlan_id)
if err_resp:
return err_resp
return self._CREATE_EMPTY_RESPONSE(True, "")
def execute(self, server, cmd_data_json):
if ("name" not in cmd_data_json or "ipspace" not in cmd_data_json
or "ip_ranges" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
"subnet ip range " + self._get_cmd_type() + " commands must" +
" have name, ipspace and ip_ranges defined" + ", got: " +
str(cmd_data_json))
name = cmd_data_json["name"]
ipspace = cmd_data_json["ipspace"]
iprs = cmd_data_json["ip_ranges"]
cmd = ("net-subnet-" + self._get_cmd_type() + "-ranges")
call = NaElement(cmd)
call.child_add_string("subnet-name", name)
call.child_add_string("ipspace", ipspace)
el_iprs = NaElement("ip-ranges")
for ip_range in iprs:
el_iprs.child_add_string("ip-range", ip_range)
call.child_add(el_iprs)
_, err_resp = self._INVOKE_CHECK(
server, call, cmd + ": " + name + " [" + ipspace + "]" +
self._get_cmd_type() + str(iprs))
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
return self._CREATE_EMPTY_RESPONSE(True, "")
def create(self, cluster):
api_call = NaElement('net-interface-create')
api_child_data_protocols = NaElement('data-protocols')
api_child_data_protocols.child_add_string('data-protocol',
self.data_protocol)
api_call.child_add(api_child_data_protocols)
api_call.child_add_string('vserver', self.vserver)
if (self.data_protocol == 'none') or (self.data_protocol == 'nfs') or (
self.data_protocol == 'cifs') or (self.data_protocol
== 'iscsi'):
api_call.child_add_string('interface-name', self.interface_name)
api_call.child_add_string('role', self.role)
api_call.child_add_string('home-node', self.home_node)
api_call.child_add_string('home-port', self.home_port)
api_call.child_add_string('address', self.address)
api_call.child_add_string('netmask', self.netmask)
elif (self.data_protocol == 'fcp'):
api_call.child_add_string('interface-name', self.interface_name)
api_call.child_add_string('role', self.role)
api_call.child_add_string('home-node', self.home_node)
api_call.child_add_string('home-port', self.home_port)
output = cluster.run_command(api_call)
return output.results_status(), output.sprintf()
def execute(self, server, cmd_data_json):
if ("parent_name" not in cmd_data_json
or "vlan_id" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'get vlan request must have parent name' +
' and vlan id defined, got: ' + str(cmd_data_json))
parent = cmd_data_json["parent_name"]
vlan_id = cmd_data_json["vlan_id"]
cmd = "net-vlan-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_vi = NaElement("vlan-info")
qe_vi.child_add_string("parent-interface", parent)
qe_vi.child_add_string("vlanid", vlan_id)
if "node_name" in cmd_data_json:
qe_vi.child_add_string("node", cmd_data_json["node_name"])
qe.child_add(qe_vi)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
vi = NaElement("vlan-info")
vi.child_add_string("interface-name", "<interface-name>")
vi.child_add_string("node", "<node>")
vi.child_add_string("parent-interface", "<parent-interface>")
vi.child_add_string("vlanid", "<vlanid>")
des_attr.child_add(vi)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(
server, call, cmd + ": " + parent + ":" + vlan_id)
if err_resp:
return err_resp
#LOGGER.debug(resp.sprintf())
vlan_cnt = self._GET_INT(resp, 'num-records')
if not vlan_cnt or vlan_cnt < 1:
# either None or 0 evaluates to False
return self._CREATE_FAIL_RESPONSE(
'no vlans or too many found for query: [' +
str(cmd_data_json) + '] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE('no vlan data found in: ' +
resp.sprintf())
vlan_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"name": self._GET_STRING(vlan_info, "interface-name"),
"node_name": self._GET_STRING(vlan_info, "node"),
"parent_name": self._GET_STRING(vlan_info, "parent-interface"),
"vlan_id": self._GET_STRING(vlan_info, "vlanid")
}
return {'success': True, 'errmsg': '', 'data': dd}
def create(self, cluster):
api_call = NaElement('aggr-create')
api_call.child_add_string('aggregate', self.aggr_name)
api_call.child_add_string('disk-count', self.disk_count)
api_call.child_add_string('disk-type', self.disk_type)
api_call.child_add_string('raid-type', self.raid_type)
api_call.child_add_string('raid-size', self.raid_size)
api_child_nodes = NaElement('nodes')
api_child_nodes.child_add_string('node-name', self.node_name)
api_call.child_add(api_child_nodes)
output = cluster.run_command(api_call)
return output.results_status(), output.sprintf()
def set_properties(self, cluster):
api_call = NaElement('vserver-modify')
api_call.child_add_string('vserver-name', self.vserver_name)
api_child_aggrs = NaElement('aggr-list')
for aggr in self.aggr_list:
api_child_aggrs.child_add_string('aggr-name', aggr)
api_child_protocols = NaElement('allowed-protocols')
for protocol in self.allowed_protocols:
api_child_protocols.child_add_string('protocol', protocol)
api_call.child_add(api_child_aggrs)
api_call.child_add(api_child_protocols)
output = cluster.run_command(api_call)
return output.results_status(), output.sprintf()
def execute(self, server, cmd_data_json):
if "name" not in cmd_data_json:
return self._CREATE_FAIL_RESPONSE(
"broadcast domain status commands must" +
" have name defined, got: " + str(cmd_data_json))
name = cmd_data_json["name"]
cmd = "net-port-broadcast-domain-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_bcdi = NaElement("net-port-broadcast-domain-info")
qe_bcdi.child_add_string("broadcast-domain", name)
qe.child_add(qe_bcdi)
call.child_add(qe)
dattr = NaElement("desired-attributes")
bcdi = NaElement("net-port-broadcast-domain-info")
bcdi.child_add_string("port-update-status-combined",
"<port-update-status-combined>")
dattr.child_add(bcdi)
call.child_add(dattr)
resp, err_resp = self._INVOKE_CHECK(server, call, cmd + ": " + name)
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
bcd_cnt = self._GET_INT(resp, 'num-records')
if bcd_cnt != 1:
# too many bc domains found for query
return self._CREATE_FAIL_RESPONSE(
'too many broadcast domains found for' + ' query: [' +
str(cmd_data_json) + '] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE(
'no broadcast domain info data found in: ' + resp.sprintf())
bcd_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"update_status":
self._GET_STRING(bcd_info, "port-update-status-combined"),
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("name" not in cmd_data_json or "ipspace" not in cmd_data_json
or "ports" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
"broadcast domain port " + self._get_cmd_type() +
" commands must" + " have name, ipspace and ports defined" +
", got: " + str(cmd_data_json))
name = cmd_data_json["name"]
ipspace = cmd_data_json["ipspace"]
ports = cmd_data_json["ports"]
cmd = ("net-port-broadcast-domain-" + self._get_cmd_type() + "-ports")
call = NaElement(cmd)
call.child_add_string("broadcast-domain", name)
call.child_add_string("ipspace", ipspace)
ports_el = NaElement("ports")
for port_name in ports:
ports_el.child_add_string("net-qualified-port-name", port_name)
call.child_add(ports_el)
resp, err_resp = self._INVOKE_CHECK(
server, call, cmd + ": " + name + " [" + ipspace + "]" +
self._get_cmd_type() + str(ports))
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
dd = {
"update_status": self._GET_STRING(resp,
"port-update-status-combined"),
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("name" not in cmd_data_json or "mtu" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
"broadcast domain create commands must" +
" have name and mtu defined, got: " + str(cmd_data_json))
name = cmd_data_json["name"]
mtu = cmd_data_json["mtu"]
cmd = "net-port-broadcast-domain-create"
call = NaElement(cmd)
call.child_add_string("broadcast-domain", name)
call.child_add_string("mtu", mtu)
if "ipspace" in cmd_data_json:
call.child_add_string("ipspace", cmd_data_json["ipspace"])
if "ports" in cmd_data_json:
ports = NaElement("ports")
for port_name in cmd_data_json["ports"]:
ports.child_add_string("net-qualified-port-name", port_name)
call.child_add(ports)
resp, err_resp = self._INVOKE_CHECK(server, call, cmd + ": " + name)
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
dd = {
"update_status": self._GET_STRING(resp,
"port-update-status-combined"),
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("node" not in cmd_data_json or "port" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'find port by pattern request must have' +
' node and port defined, got: ' + str(cmd_data_json))
node = cmd_data_json["node"]
port = cmd_data_json["port"]
cmd = "net-port-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_npi = NaElement("net-port-info")
qe_npi.child_add_string("node", node)
qe_npi.child_add_string("port", port)
qe.child_add(qe_npi)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
npi = NaElement("net-port-info")
npi.child_add_string("port", "<port>")
des_attr.child_add(npi)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(server, call,
cmd + ": " + node + ":" + port)
if err_resp:
return err_resp
#LOGGER.debug(resp.sprintf())
ports = []
if resp.child_get("attributes-list"):
for port_info in resp.child_get("attributes-list").children_get():
ports.append(self._GET_STRING(port_info, "port"))
return {'success': True, 'errmsg': '', 'data': {'ports': ports}}
def execute(self, server, cmd_data_json):
if ("node" not in cmd_data_json or "port" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'get port request must have node and port defined, got: ' +
str(cmd_data_json))
node = cmd_data_json["node"]
port = cmd_data_json["port"]
cmd = "net-port-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_npi = NaElement("net-port-info")
qe_npi.child_add_string("node", node)
qe_npi.child_add_string("port", port)
qe.child_add(qe_npi)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
npi = NaElement("net-port-info")
npi.child_add_string("node", "<node>")
npi.child_add_string("port", "<port>")
npi.child_add_string("autorevert-delay", "<autorevert-delay>")
npi.child_add_string("ignore-health-status", "<ignore-health-status>")
npi.child_add_string("ipspace", "<ipspace>")
npi.child_add_string("role", "<role>")
npi.child_add_string("is-administrative-up", "<is-administrative-up>")
npi.child_add_string("mtu-admin", "<mtu-admin>")
npi.child_add_string("is-administrative-auto-negotiate",
"<is-administrative-auto-negotiate>")
npi.child_add_string("administrative-speed", "<administrative-speed>")
npi.child_add_string("administrative-duplex",
"<administrative-duplex>")
npi.child_add_string("administrative-flowcontrol",
"<administrative-flowcontrol>")
npi.child_add_string("link-status", "<link-status>")
npi.child_add_string("health-status", "<health-status>")
npi.child_add_string("mac-address", "<mac-address>")
npi.child_add_string("broadcast-domain", "<broadcast-domain>")
npi.child_add_string("mtu", "<mtu>")
npi.child_add_string("is-operational-auto-negotiate",
"<is-operational-auto-negotiate>")
npi.child_add_string("operational-speed", "<operational-speed>")
npi.child_add_string("operational-duplex", "<operational-duplex>")
npi.child_add_string("operational-flowcontrol",
"<operational-flowcontrol>")
npi.child_add_string("port-type", "<port-type>")
npi.child_add_string("vlan-id", "<vlan-id>")
npi.child_add_string("vlan-node", "<vlan-node>")
npi.child_add_string("vlan-port", "<vlan-port>")
des_attr.child_add(npi)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(server, call,
cmd + ": " + node + ":" + port)
if err_resp:
return err_resp
#LOGGER.debug(resp.sprintf())
port_cnt = self._GET_INT(resp, 'num-records')
if port_cnt != 1:
# too many ports received for query
return self._CREATE_FAIL_RESPONSE(
'too many ports found for query: [' + str(cmd_data_json) +
'] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE('no port data found in: ' +
resp.sprintf())
port_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"node":
self._GET_STRING(port_info, "node"),
"port":
self._GET_STRING(port_info, "port"),
"auto_rev_delay":
self._GET_STRING(port_info, "autorevert-delay"),
"ignr_health":
self._GET_STRING(port_info, "ignore-health-status"),
"ipspace":
self._GET_STRING(port_info, "ipspace"),
"role":
self._GET_STRING(port_info, "role"),
"admin_up":
self._GET_STRING(port_info, "is-administrative-up"),
"admin_mtu":
self._GET_STRING(port_info, "mtu-admin"),
"admin_auto":
self._GET_STRING(port_info, "is-administrative-auto-negotiate"),
"admin_speed":
self._GET_STRING(port_info, "administrative-speed"),
"admin_duplex":
self._GET_STRING(port_info, "administrative-duplex"),
"admin_flow":
self._GET_STRING(port_info, "administrative-flowcontrol"),
"status":
self._GET_STRING(port_info, "link-status"),
"health":
self._GET_STRING(port_info, "health-status"),
"mac":
self._GET_STRING(port_info, "mac-address"),
"broadcast_domain":
self._GET_STRING(port_info, "broadcast-domain"),
"mtu":
self._GET_STRING(port_info, "mtu"),
"auto":
self._GET_STRING(port_info, "is-operational-auto-negotiate"),
"speed":
self._GET_STRING(port_info, "operational-speed"),
"duplex":
self._GET_STRING(port_info, "operational-duplex"),
"flow":
self._GET_STRING(port_info, "operational-flowcontrol"),
"type":
self._GET_STRING(port_info, "port-type"),
"vlan_id":
self._GET_STRING(port_info, "vlan-id"),
"vlan_node":
self._GET_STRING(port_info, "vlan-node"),
"vlan_port":
self._GET_STRING(port_info, "vlan-port")
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("node" not in cmd_data_json or "name" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'get port group request must have node ' +
'and name defined, got: ' + str(cmd_data_json))
node = cmd_data_json["node"]
name = cmd_data_json["name"]
cmd = "net-port-ifgrp-get"
call = NaElement(cmd)
call.child_add_string("ifgrp-name", name)
call.child_add_string("node", node)
des_attr = NaElement("desired-attributes")
npgi = NaElement("net-ifgrp-info")
npgi.child_add_string("node", "<node>")
npgi.child_add_string("ifgrp-name", "<ifgrp-name>")
npgi.child_add_string("mode", "<mode>")
npgi.child_add_string("distribution-function",
"<distribution-function>")
npgi.child_add_string("port-participation", "<port-participation>")
ps = NaElement("ports")
ps.child_add_string("lif-bindable", "<lif-bindable>")
npgi.child_add(ps)
psd = NaElement("down-ports")
psd.child_add_string("lif-bindable", "<lif-bindable>")
npgi.child_add(psd)
psu = NaElement("up-ports")
psu.child_add_string("lif-bindable", "<lif-bindable>")
npgi.child_add(psu)
des_attr.child_add(npgi)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(server, call,
cmd + ": " + node + ":" + name)
if err_resp:
return err_resp
#LOGGER.debug(resp.sprintf())
if not resp.child_get("attributes"):
return self._CREATE_FAIL_RESPONSE('no port group data found in: ' +
resp.sprintf())
pg_info = resp.child_get("attributes").children_get()[0]
dd = {
"node": self._GET_STRING(pg_info, "node"),
"name": self._GET_STRING(pg_info, "ifgrp-name"),
"mode": self._GET_STRING(pg_info, "mode"),
"dist": self._GET_STRING(pg_info, "distribution-function"),
"part": self._GET_STRING(pg_info, "port-participation"),
"ports": self._GET_CONTENT_LIST(pg_info, "ports"),
"ports_down": self._GET_CONTENT_LIST(pg_info, "down-ports"),
"ports_up": self._GET_CONTENT_LIST(pg_info, "up-ports")
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("name" not in cmd_data_json and "uuid" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'get aggr request must have either ' +
'name or uuid defined, got: ' + str(cmd_data_json))
cmd = "aggr-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qi_aa = NaElement("aggr-attributes")
for key in ["name", "uuid"]:
if key in cmd_data_json:
qi_aa.child_add_string("aggregate-" + key, cmd_data_json[key])
if "nodes" in cmd_data_json:
qi_nodes = NaElement("nodes")
for node_name in cmd_data_json["nodes"]:
qi_nodes.child_add_string("node-name", node_name)
qi_aa.child_add(qi_nodes)
qe.child_add(qi_aa)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
agg_attr = NaElement("aggr-attributes")
agg_attr.child_add_string("aggregate-name", "<aggregate-name>")
agg_attr.child_add_string("aggregate-uuid", "<aggregate-uuid>")
agg_spc = NaElement("aggr-space-attributes")
agg_spc.child_add_string("percent-used-capacity",
"<percent-used-capacity>")
agg_spc.child_add_string("physical-used-percent",
"<physical-used-percent>")
agg_spc.child_add_string("size-available", "<size-available>")
agg_spc.child_add_string("size-total", "<size-total>")
agg_spc.child_add_string("size-used", "<size-used>")
agg_spc.child_add_string("total-reserved-space",
"<total-reserved-space>")
agg_attr.child_add(agg_spc)
agg_vcnt = NaElement("aggr-volume-count-attributes")
agg_vcnt.child_add_string("flexvol-count", "<flexvol-count>")
agg_attr.child_add(agg_vcnt)
des_attr.child_add(agg_attr)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(
server, call, cmd + ": <-- " + str(cmd_data_json))
if err_resp:
return err_resp
agg_cnt = self._GET_INT(resp, 'num-records')
if agg_cnt != 1:
# too many aggregates found for query
return self._CREATE_FAIL_RESPONSE('too many aggregates found for' +
' query: [' +
str(cmd_data_json) +
'] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE(
'no aggregate info data found in: ' + resp.sprintf())
agg_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"name": self._GET_STRING(agg_info, "aggregate-name"),
"uuid": self._GET_STRING(agg_info, "aggregate-uuid"),
}
agg_si = agg_info.child_get("aggr-space-attributes")
if agg_si:
dd["pct_used_cap"] = self._GET_INT(agg_si, "percent-used-capacity")
dd["pct_used_phys"] = self._GET_INT(agg_si,
"physical-used-percent")
dd["size_avail"] = self._GET_INT(agg_si, "size-available")
dd["size_total"] = self._GET_INT(agg_si, "size-total")
dd["size_used"] = self._GET_INT(agg_si, "size-used")
dd["size_reserve"] = self._GET_INT(agg_si, "total-reserved-space")
add_vco = agg_info.child_get("aggr-volume-count-attributes")
if add_vco:
dd["flexvol_cnt"] = self._GET_INT(add_vco, "flexvol-count")
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("id" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE('get job request must have ' +
'id defined, got: ' +
str(cmd_data_json))
jid = cmd_data_json['id']
cmd = "job-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qi_ji = NaElement("job-info")
qi_ji.child_add_string("job-id", jid)
qe.child_add(qi_ji)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
ji = NaElement("job-info")
ji.child_add_string("job-id", "<job-id>")
ji.child_add_string("job-vserver", "<job-vserver>")
ji.child_add_string("job-completion", "<job-completion>")
ji.child_add_string("job-state", "<job-state>")
ji.child_add_string("job-status-code", "<job-status-code>")
des_attr.child_add(ji)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(
server, call, cmd + ": <-- " + str(cmd_data_json))
#LOGGER.debug(resp.sprintf())
if err_resp:
return err_resp
job_cnt = self._GET_INT(resp, 'num-records')
if job_cnt != 1:
# too many jobs found for query
return self._CREATE_FAIL_RESPONSE('too many jobs found for' +
' query: [' +
str(cmd_data_json) +
'] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE('no job info data found in: ' +
resp.sprintf())
job_info = resp.child_get("attributes-list").children_get()[0]
dd = {
'id': self._GET_INT(job_info, "job-id"),
'svm': self._GET_STRING(job_info, "job-vserver"),
'msg': self._GET_STRING(job_info, "job-completion"),
'status': self._GET_STRING(job_info, "job-state"),
'errno': self._GET_INT(job_info, "job-status-code")
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if ("name" not in cmd_data_json or "bc_domain" not in cmd_data_json
or "ipspace" not in cmd_data_json
or "subnet" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
"subnet create commands must" +
" have name, broadcast domain, ipspace" +
" and subnet defined, got: " + str(cmd_data_json))
name = cmd_data_json["name"]
bcdom = cmd_data_json["bc_domain"]
ipspace = cmd_data_json["ipspace"]
subnet = cmd_data_json["subnet"]
cmd = "net-subnet-create"
call = NaElement(cmd)
call.child_add_string("subnet-name", name)
call.child_add_string("broadcast-domain", bcdom)
call.child_add_string("ipspace", ipspace)
call.child_add_string("subnet", subnet)
# make sure that create call returns record!
call.child_add_string("return-record", True)
if "gateway" in cmd_data_json:
call.child_add_string("gateway", cmd_data_json["gateway"])
if "ip_ranges" in cmd_data_json:
iprs = NaElement("ip-ranges")
for ip_range in cmd_data_json["ip_ranges"]:
iprs.child_add_string("ip-range", ip_range)
call.child_add(iprs)
resp, err_resp = self._INVOKE_CHECK(server, call, cmd + ": " + name)
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
if not resp.child_get("result"):
# no result data in response
return self._CREATE_FAIL_RESPONSE(
'no result data for create subnet' + ' with input: [' +
str(cmd_data_json) + '] result is: ' + resp.sprintf())
si_info = resp.child_get("result").child_get("net-subnet-info")
dd = {
"bc_domain": self._GET_STRING(si_info, "broadcast-domain"),
"gateway": self._GET_STRING(si_info, "gateway"),
"ipspace": self._GET_STRING(si_info, "ipspace"),
"subnet": self._GET_STRING(si_info, "subnet"),
"name": self._GET_STRING(si_info, "subnet-name"),
"ip_count": self._GET_INT(si_info, "total-count"),
"ip_used": self._GET_INT(si_info, "used-count"),
"ip_avail": self._GET_INT(si_info, "available-count"),
"ip_ranges": self._GET_CONTENT_LIST(si_info, "ip-ranges")
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
# create the node details query first to see if valid
qe_ndt = NaElement("node-details-info")
qpcnt = 0
if 'name' in cmd_data_json:
qe_ndt.child_add_string("node", cmd_data_json['name'])
qpcnt += 1
if 'uuid' in cmd_data_json:
qe_ndt.child_add_string("node-uuid", cmd_data_json['uuid'])
qpcnt += 1
if qpcnt < 1:
return self._CREATE_FAIL_RESPONSE(
'need at least one query parameter, got: ' +
str(cmd_data_json))
api = NaElement("system-node-get-iter")
xi = NaElement("desired-attributes")
xi1 = NaElement("node-details-info")
xi1.child_add_string("node-uuid", "<node-uuid>")
xi1.child_add_string("node", "<node>")
xi1.child_add_string("node-serial-number", "<node-serial-number>")
xi1.child_add_string("node-system-id", "<node-system-id>")
xi1.child_add_string("product-version", "<product-version>")
xi1.child_add_string("is-node-healthy", "<is-node-healthy>")
xi1.child_add_string("node-uptime", "<node-uptime>")
xi.child_add(xi1)
api.child_add(xi)
qe = NaElement("query")
qe.child_add(qe_ndt)
api.child_add(qe)
resp, err_resp = self._INVOKE_CHECK(server, api,
"system-node-get-iter")
if err_resp:
return err_resp
node_cnt = self._GET_INT(resp, 'num-records')
if node_cnt != 1:
# too many nodes found for query
return self._CREATE_FAIL_RESPONSE(
'too many nodes found for query: [' + str(cmd_data_json) +
'] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE('no node data found in: ' +
resp.sprintf())
node_detail = resp.child_get("attributes-list").children_get()[0]
uuid = self._GET_STRING(node_detail, "node-uuid")
name = self._GET_STRING(node_detail, "node")
serial = self._GET_STRING(node_detail, "node-serial-number")
sysid = self._GET_STRING(node_detail, "node-system-id")
version = self._GET_STRING(node_detail, "product-version")
healthy = self._GET_BOOL(node_detail, "is-node-healthy")
uptime = self._GET_INT(node_detail, "node-uptime")
return {
'success': True,
'errmsg': '',
'data': {
"name": name,
"serial": serial,
"id": sysid,
"uuid": uuid,
"version": version,
"healthy": healthy,
"uptime": uptime
}
}
def execute(self, server, cmd_data_json):
if ("name" not in cmd_data_json or "bc_domain" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
"subnet get commands must" +
" have name and broadcast domain" + " defined, got: " +
str(cmd_data_json))
name = cmd_data_json["name"]
bcdom = cmd_data_json["bc_domain"]
cmd = "net-subnet-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qi_si = NaElement("net-subnet-info")
qi_si.child_add_string("broadcast-domain", bcdom)
qi_si.child_add_string("subnet-name", name)
qe.child_add(qi_si)
call.child_add(qe)
dattr = NaElement("desired-attributes")
si = NaElement("net-subnet-info")
si.child_add_string("subnet-name", "<subnet-name>")
si.child_add_string("broadcast-domain", "<broadcast-domain>")
si.child_add_string("ipspace", "<ipspace>")
si.child_add_string("subnet", "<subnet>")
si.child_add_string("gateway", "<gateway>")
iprs = NaElement("ip-ranges")
iprs.child_add_string("ip-range", "<ip-range>")
si.child_add(iprs)
si.child_add_string("total-count", "<total-count>")
si.child_add_string("used-count", "<used-count>")
si.child_add_string("available-count", "<available-count>")
dattr.child_add(si)
call.child_add(dattr)
resp, err_resp = self._INVOKE_CHECK(server, call, cmd + ": " + name)
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
si_cnt = self._GET_INT(resp, 'num-records')
if si_cnt != 1:
# too many subnets found for query
return self._CREATE_FAIL_RESPONSE('too many subnets found for' +
' query: [' +
str(cmd_data_json) +
'] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE(
'no subnet info data found in: ' + resp.sprintf())
si_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"bc_domain": self._GET_STRING(si_info, "broadcast-domain"),
"gateway": self._GET_STRING(si_info, "gateway"),
"ipspace": self._GET_STRING(si_info, "ipspace"),
"subnet": self._GET_STRING(si_info, "subnet"),
"name": self._GET_STRING(si_info, "subnet-name"),
"ip_count": self._GET_INT(si_info, "total-count"),
"ip_used": self._GET_INT(si_info, "used-count"),
"ip_avail": self._GET_INT(si_info, "available-count"),
"ip_ranges": self._GET_CONTENT_LIST(si_info, "ip-ranges")
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if "name" not in cmd_data_json:
return self._CREATE_FAIL_RESPONSE(
"get broadcast domain commands must" +
" have name defined, got: " + str(cmd_data_json))
name = cmd_data_json["name"]
cmd = "net-port-broadcast-domain-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_bcdi = NaElement("net-port-broadcast-domain-info")
qe_bcdi.child_add_string("broadcast-domain", name)
qe.child_add(qe_bcdi)
call.child_add(qe)
dattr = NaElement("desired-attributes")
bcdi = NaElement("net-port-broadcast-domain-info")
bcdi.child_add_string("broadcast-domain", "<broadcast-domain>")
bcdi.child_add_string("ipspace", "<ipspace>")
bcdi.child_add_string("mtu", "<mtu>")
bcdi.child_add_string("port-update-status-combined",
"<port-update-status-combined>")
ports = NaElement("ports")
pi = NaElement("port-info")
pi.child_add_string("port", "<port>")
pi.child_add_string("port-update-status", "<port-update-status>")
pi.child_add_string("port-update-status-details",
"<port-update-status-details>")
ports.child_add(pi)
bcdi.child_add(ports)
fog = NaElement("failover-groups")
fog.child_add_string("failover-group", "<failover-group>")
bcdi.child_add(fog)
subs = NaElement("subnet-names")
subs.child_add_string("subnet-name", "<subnet-name>")
bcdi.child_add(subs)
dattr.child_add(bcdi)
call.child_add(dattr)
resp, err_resp = self._INVOKE_CHECK(server, call, cmd + ": " + name)
if err_resp:
return err_resp
# LOGGER.debug(resp.sprintf())
bcd_cnt = self._GET_INT(resp, 'num-records')
if bcd_cnt != 1:
# too many bc domains found for query
return self._CREATE_FAIL_RESPONSE(
'too many broadcast domains found for' + ' query: [' +
str(cmd_data_json) + '] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE(
'no broadcast domain info data found in: ' + resp.sprintf())
bcd_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"name":
self._GET_STRING(bcd_info, "broadcast-domain"),
"mtu":
self._GET_STRING(bcd_info, "mtu"),
"ipspace":
self._GET_STRING(bcd_info, "ipspace"),
"update_status":
self._GET_STRING(bcd_info, "port-update-status-combined"),
"ports": [],
"failovergrps":
self._GET_CONTENT_LIST(bcd_info, "failover-groups"),
"subnets":
self._GET_CONTENT_LIST(bcd_info, "subnet-names")
}
if bcd_info.child_get("ports"):
# port info data available, process
for port_info in bcd_info.child_get("ports").children_get():
dd['ports'].append({
"name":
self._GET_STRING(port_info, "port"),
"update_status":
self._GET_STRING(port_info, "port-update-status"),
"status_detail":
self._GET_STRING(port_info, "port-update-status-details")
})
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if not ("uuid" in cmd_data_json or "name" in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'get IPSpace request must have uuid' + ' defined, got: ' +
str(cmd_data_json))
cmd = "net-ipspaces-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_ii = NaElement("net-ipspaces-info")
mark = "unknown"
if "uuid" in cmd_data_json:
mark = cmd_data_json["uuid"]
qe_ii.child_add_string("uuid", mark)
if "name" in cmd_data_json:
mark = cmd_data_json["name"]
qe_ii.child_add_string("ipspace", mark)
qe.child_add(qe_ii)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
ii = NaElement("net-ipspaces-info")
ii.child_add_string("ipspace", "<ipspace>")
ii.child_add_string("uuid", "<uuid>")
bcd = NaElement("broadcast-domains")
bcd.child_add_string("broadcast-domain-name",
"<broadcast-domain-name>")
ii.child_add(bcd)
pts = NaElement("ports")
pts.child_add_string("net-qualified-port-name",
"<net-qualified-port-name>")
ii.child_add(pts)
vser = NaElement("vservers")
vser.child_add_string("vserver-name", "<vserver-name>")
ii.child_add(vser)
des_attr.child_add(ii)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(server, call, cmd + ": " + mark)
if err_resp:
return err_resp
vlan_cnt = self._GET_INT(resp, 'num-records')
if vlan_cnt != 1:
# too many vlan's found for query
return self._CREATE_FAIL_RESPONSE(
'too many ipspaces found for query: [' + str(cmd_data_json) +
'] result is: ' + resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE('no ipspace data found in: ' +
resp.sprintf())
ips_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"name": self._GET_STRING(ips_info, "ipspace"),
"uuid": self._GET_STRING(ips_info, "uuid"),
"bc_domains": self._GET_CONTENT_LIST(ips_info,
"broadcast-domains"),
"ports": self._GET_CONTENT_LIST(ips_info, "ports"),
"vservers": self._GET_CONTENT_LIST(ips_info, "vservers")
}
return {'success': True, 'errmsg': '', 'data': dd}
def execute(self, server, cmd_data_json):
if (
"name" not in cmd_data_json and
"uuid" not in cmd_data_json):
return self._CREATE_FAIL_RESPONSE(
'get SVM request must have name'
+ ' or uuid defined, got: '
+ str(cmd_data_json))
cmd = "vserver-get-iter"
call = NaElement(cmd)
qe = NaElement("query")
qe_vsi = NaElement("vserver-info")
if "name" in cmd_data_json:
qe_vsi.child_add_string(
"vserver-name",
cmd_data_json["name"])
elif "uuid" in cmd_data_json:
qe_vsi.child_add_string(
"uuid", cmd_data_json["uuid"])
qe.child_add(qe_vsi)
call.child_add(qe)
des_attr = NaElement("desired-attributes")
vsi = NaElement("vserver-info")
for prot_attr in ["allowed-protocols", "disallowed-protocols"]:
alp = NaElement(prot_attr)
alp.child_add_string("protocol","<protocol>")
vsi.child_add(alp)
vsi.child_add_string("ipspace","<ipspace>")
vsi.child_add_string("is-config-locked-for-changes","<is-config-locked-for-changes>")
vsi.child_add_string("operational-state","<operational-state>")
vsi.child_add_string("operational-state-stopped-reason","<operational-state-stopped-reason>")
vsi.child_add_string("root-volume","<root-volume>")
vsi.child_add_string("root-volume-aggregate","<root-volume-aggregate>")
vsi.child_add_string("root-volume-security-style","<root-volume-security-style>")
vsi.child_add_string("state","<state>")
vsi.child_add_string("uuid","<uuid>")
vsi.child_add_string("volume-delete-retention-hours","<volume-delete-retention-hours>")
vsi.child_add_string("vserver-name","<vserver-name>")
des_attr.child_add(vsi)
call.child_add(des_attr)
resp, err_resp = self._INVOKE_CHECK(
server, call,
cmd + ": " + str(cmd_data_json))
if err_resp:
return err_resp
#LOGGER.debug(resp.sprintf())
svm_cnt = self._GET_INT(resp, 'num-records')
if svm_cnt != 1:
# not exactly one svm received for query
return self._CREATE_FAIL_RESPONSE(
'not exactly one SVM received for: ['
+ str(cmd_data_json) + '] result is: '
+ resp.sprintf())
if not resp.child_get("attributes-list"):
return self._CREATE_FAIL_RESPONSE(
'no svm data found in: '
+ resp.sprintf())
svm_info = resp.child_get("attributes-list").children_get()[0]
dd = {
"name": self._GET_STRING(svm_info, "vserver-name"),
"uuid": self._GET_STRING(svm_info, "uuid"),
"ipspace": self._GET_STRING(svm_info, "ipspace"),
"root_aggr": self._GET_STRING(svm_info, "root-volume-aggregate"),
"root_sec_style": self._GET_STRING(svm_info, "root-volume-security-style"),
"root_name": self._GET_STRING(svm_info, "root-volume"),
"root_retent": self._GET_STRING(svm_info, "volume-delete-retention-hours"),
"locked": self._GET_BOOL(svm_info, "is-config-locked-for-changes"),
"svm_state": self._GET_STRING(svm_info, "state"),
"proto_enabled": self._GET_CONTENT_LIST(svm_info, "allowed-protocols"),
"proto_inactive": self._GET_CONTENT_LIST(svm_info, "disallowed-protocols")
}
dd["oper_state"] = self._GET_STRING(svm_info, "operational-state")
if self._GET_STRING(svm_info, "operational-state-stopped-reason"):
dd["oper_state"] += " caused by: " + self._GET_STRING(
svm_info, "operational-state-stopped-reason")
return {
'success' : True, 'errmsg': '', 'data': dd}