def set_port_name_config_bool(self, request, arg, switch_info, maskbit):
try:
dpid = switch_info.dpid.as_host()
if dpid not in self.switchstats.dp_stats:
return webservice.notFound(request, "Switch not active to set config.")
portname = arg['<port name>']
port = None
for p in self.switchstats.dp_stats[dpid]['ports']:
if p['name'] == portname:
port = p
break
if port is None:
return webservice.notFound(request, "Port not active to set config.")
content = json_parse_message_body(request)
if content != True and content != False:
return webservice.badRequest(request, "Excepts a boolean value as message body.")
port_no = port['port_no']
hw_addr = port['hw_addr'].replace('-',':')
mask = 0 | maskbit
if content:
config = 0
else:
config = 0xffffffff
ret = self.switchstats.send_port_mod(dpid, port_no, hw_addr, mask, config)
request.write(simplejson.dumps(ret))
request.finish()
return NOT_DONE_YET
except Exception, e:
return self.err(Failure(), request, "set_port_name_config",
"Could not set port name config.")
def find_cert(cert_dict):
if fp in cert_dict:
request.write(cert_dict[fp])
request.finish()
else:
webservice.notFound(
request, "No approved cert with fingerprint = '%s'" % fp)
def ok(res):
if res is None:
webservice.notFound(request,
"%s '%s' does not exist." % (type_str.capitalize(),
mangle_name(dirname,name)))
else:
request.write(ret)
request.finish()
def ok(res):
if res is None:
webservice.notFound(
request, "%s '%s' does not exist." %
(type_str.capitalize(), mangle_name(dirname, name)))
else:
request.write(ret)
request.finish()
def single_interface_cb(res, name):
if len(errCalled) > 0:
return
for i in res:
n = self._get_name_for_iface(i)
if name == n:
request.write(simplejson.dumps(i))
request.finish()
return
msg = "Host '%s' has no interface '%s'." % (mangled_name, name)
lg.error(msg)
webservice.notFound(request, msg)
def single_interface_cb(res, name):
if len(errCalled) > 0:
return
for i in res:
n = self._get_name_for_iface(i)
if name == n:
request.write(simplejson.dumps(i))
request.finish()
return
msg = "Host '%s' has no interface '%s'." % (mangled_name, name)
lg.error(msg)
webservice.notFound(request, msg)
def do_get_principal_groups(request,arg):
dirname = arg.get('<dir name>', None)
instance = self._dm.get_directory_instance(dirname)
if instance is None:
return webservice.notFound(request,"Directory '%s' does not exist."
%dirname)
type_str = get_principal_type_from_args(arg)
ptype = name_to_type_map.get(type_str)
if ptype is None:
return webservice.notFound(request,"Invalid principal type %s"
%type_str)
if instance._instance.group_enabled(ptype) == Directory.NO_SUPPORT:
return simplejson.dumps(())
return self._do_single_name_op(request,arg,"get_group_membership")
def do_get_principal_groups(request, arg):
dirname = arg.get('<dir name>', None)
instance = self._dm.get_directory_instance(dirname)
if instance is None:
return webservice.notFound(
request, "Directory '%s' does not exist." % dirname)
type_str = get_principal_type_from_args(arg)
ptype = name_to_type_map.get(type_str)
if ptype is None:
return webservice.notFound(
request, "Invalid principal type %s" % type_str)
if instance._instance.group_enabled(ptype) == Directory.NO_SUPPORT:
return simplejson.dumps(())
return self._do_single_name_op(request, arg,
"get_group_membership")
def get_port_name_config(self, request, arg, switch_info):
try:
portname = arg['<port name>']
dpid = switch_info.dpid.as_host()
dentry = sentry = None
for loc in switch_info.locations:
if loc.port_name == portname:
dentry = loc
break
if dpid in self.switchstats.dp_stats:
ports = self.switchstats.dp_stats[dpid]['ports']
for p in ports:
if p['name'] == portname:
sentry = p
if dentry is None and sentry is None:
return webservice.notFound(request, "Port '%s' not on switch." % portname)
request.write(simplejson.dumps(self.__init_port_config__(arg, portname, dentry, sentry)))
request.finish()
return NOT_DONE_YET
except:
return self.err(Failure(), request, "get_port_name_config",
"Could not retrieve switch port name config.")
def group_op(self, request, group_info, mangled_group, ptype_str, otype_str):
try:
def ok(res):
if isinstance(res, GroupInfo):
request.write(simplejson.dumps(res.to_str_dict()))
else:
request.write(simplejson.dumps(res))
request.finish()
is_get_op = otype_str == "get" or otype_str == "principal" or otype_str == "subgroup"
if group_info is None and (is_get_op or otype_str == "del"):
return webservice.notFound(request, "Group %s does not exist." % mangled_group)
# read operations finish here. this includes 'get','principal'
# and 'subgroup' otype_str
if is_get_op:
str_dict = group_info.to_str_dict()
if otype_str == "get":
request.write(simplejson.dumps(str_dict))
elif otype_str == "principal":
request.write(simplejson.dumps(str_dict["member_names"]))
elif otype_str == "subgroup":
request.write(simplejson.dumps(str_dict["subgroup_names"]))
request.finish()
return
# only otype_str == 'add' or 'del' continues to this point
ptype = groupname_to_type[ptype_str]
if otype_str == "add":
content = json_parse_message_body(request)
if content == None:
return webservice.badRequest(request, "Unable to parse message body.")
if group_info is None:
content["name"] = mangled_group
d = getattr(self.dm, "add_group")(ptype, GroupInfo.from_str_dict(content))
elif len(content) == 1 and content.has_key("name"):
d = getattr(self.dm, "rename_group")(ptype, mangled_group, content["name"], "", "")
else:
content["name"] = mangled_group
d = getattr(self.dm, "modify_group")(ptype, GroupInfo.from_str_dict(content))
else: # delete
d = getattr(self.dm, "del_group")(ptype, mangled_group)
d.addCallback(ok)
d.addErrback(
self.err,
request,
"%s %s group_op" % (otype_str, ptype_str),
"Could not perform %s group operation." % ptype_str,
)
return NOT_DONE_YET
except Exception, e:
return self.err(
Failure(),
request,
"%s %s group_op" % (otype_str, ptype_str),
"Could not perform %s group operation." % ptype_str,
)
def err_specific(res):
if isinstance(res.value, DirectoryException):
if res.value.code == DirectoryException.NONEXISTING_NAME:
lg.error("Not found: %s() %s %s does not exist: %s" % \
(method_name, type_str, mangled_name, str(res)))
return webservice.notFound(request, "%s %s not found." % \
(type_str.capitalize(), mangled_name))
return self.err(res, request, method_name, "Could not %s." % \
method_name)
def err_specific(res):
if isinstance(res.value, DirectoryException):
if res.value.code == DirectoryException.NONEXISTING_NAME:
lg.error("Not found: %s() %s %s does not exist: %s" % \
(method_name, type_str, mangled_name, str(res)))
return webservice.notFound(request, "%s %s not found." % \
(type_str.capitalize(), mangled_name))
return self.err(res, request, method_name, "Could not %s." % \
method_name)
def member_op(self, request, group_info, member, ptype_str, otype_str,
ctype_str):
try:
def ok(res):
def unicode_(s, encoding):
if isinstance(s, unicode): return s
return unicode(s, encoding)
members = []
for member in res[0]:
if not isinstance(member, basestring):
member = str(member)
members.append(unicode_(member, 'utf-8'))
subgroups = [
unicode_(subgroup, 'utf-8') for subgroup in res[1]
]
res_str = [members, subgroups]
request.write(simplejson.dumps(res_str))
request.finish()
if group_info is None:
return webservice.badRequest(request, "Group does not exist.")
exists = is_member(group_info, member, ctype_str)
if otype_str == "add" and exists:
return webservice.badRequest(request, "%s is already a %s in the group." \
% (member,ctype_str))
if otype_str != "add" and not exists:
return webservice.notFound(request, "%s %s not found in group." \
% (ctype_str.capitalize(),member))
if otype_str == "":
# special case, this is just a membership test
# if the request got this far, return success
request.finish()
return
ptype = groupname_to_type[ptype_str]
method_name = otype_str + "_group_members"
f = getattr(self.dm, method_name)
if ctype_str in ["principal", "address"]:
d = f(ptype, group_info.name, (member, ), ())
else: # 'subgroup' case
d = f(ptype, group_info.name, (), (member, ))
d.addCallback(ok)
d.addErrback(self.err, request, "%s member_op" % method_name,
"Could not %s." % method_name)
return NOT_DONE_YET
except Exception, e:
return self.err(Failure(), request, "member_op",
"Could not perform group operation.")
def _get_dir(self, request, arg):
try:
dirname = arg['<dir name>']
for instance in self._dm.get_directory_instances():
if dirname == instance._name:
item = self._convert_instance_to_dict(instance)
return simplejson.dumps(item)
return webservice.notFound(request, "Directory %s not found." % dirname)
except Exception, e:
return self.err(Failure(), request, "_get_dir",
"Could not retrieve directory.")
def _get_dir(self, request, arg):
try:
dirname = arg['<dir name>']
for instance in self._dm.get_directory_instances():
if dirname == instance._name:
item = self._convert_instance_to_dict(instance)
return simplejson.dumps(item)
return webservice.notFound(request,
"Directory %s not found." % dirname)
except Exception, e:
return self.err(Failure(), request, "_get_dir",
"Could not retrieve directory.")
def err_specific(res):
if isinstance(res.value, DirectoryException):
if res.value.code == DirectoryException.RECORD_ALREADY_EXISTS:
lg.error("Conflict error: _modify_principal %s %s already exists: %s" \
% (type_str, content['name'], str(res)))
return webservice.conflictError(request, "%s %s already exists." % (type_str.capitalize(),
content['name']))
elif res.value.code == DirectoryException.NONEXISTING_NAME:
lg.error("Bad request: _modify_principal %s %s does not exist: %s" \
% (type_str.capitalize(), mangled_name, str(res)))
return webservice.notFound(request, "%s %s does not exist." % (type_str.capitalize(), mangled_name))
return self.err(res, request, "_modify_principal",
"Could not modify principal.")
def set_port_name_config(self, request, arg, switch_info):
try:
dpid = switch_info.dpid.as_host()
if dpid not in self.switchstats.dp_stats:
return webservice.notFound(request, "Switch not active to set config.")
portname = arg['<port name>']
port = None
for p in self.switchstats.dp_stats[dpid]['ports']:
if p['name'] == portname:
port = p
break
if port is None:
return webservice.notFound(request, "Port not active to set config.")
content = json_parse_message_body(request)
if content == None:
return webservice.badRequest(request,"Unable to parse message body.")
port_no = port['port_no']
hw_addr = port['hw_addr'].replace('-',':')
config = 0
mask = 0
if 'flood' in content:
mask |= openflow.OFPPC_NO_FLOOD
if content['flood'] == False:
config |= openflow.OFPPC_NO_FLOOD
if 'enabled' in content:
mask |= openflow.OFPPC_PORT_DOWN
if content['enabled'] == False:
config |= openflow.OFPPC_PORT_DOWN
ret = self.switchstats.send_port_mod(dpid, port_no, hw_addr, mask, config)
request.write(simplejson.dumps(ret))
request.finish()
return NOT_DONE_YET
except Exception, e:
return self.err(Failure(), request, "set_port_name_config",
"Could not set port name config.")
def ok(res):
if res is None:
return webservice.notFound(request,"%s '%s' does not exist." \
% (type_str.capitalize(), mangled_name))
else:
if isinstance(res, list) or isinstance(res, tuple):
# result of search_*_group() is a list
ret = simplejson.dumps(res)
elif isinstance(res, PrincipalInfo):
# result of add_*(),get_*() or del_*() is a PrincipalInfo subclass
ret = simplejson.dumps(res.to_str_dict())
else:
raise Exception("Unexpected result in ok() for do_single_name_op " \
+ "method = " + method_name + ": " + str(res))
request.write(ret)
request.finish()
def ok(res):
if res is None:
return webservice.notFound(request,"%s '%s' does not exist." \
% (type_str.capitalize(), mangled_name))
else:
if isinstance(res,list) or isinstance(res,tuple):
# result of search_*_group() is a list
ret = simplejson.dumps(res)
elif isinstance(res,PrincipalInfo):
# result of add_*(),get_*() or del_*() is a PrincipalInfo subclass
ret = simplejson.dumps(res.to_str_dict())
else:
raise Exception("Unexpected result in ok() for do_single_name_op " \
+ "method = " + method_name + ": " + str(res))
request.write(ret)
request.finish()
def member_op(self, request, group_info, member, ptype_str, otype_str, ctype_str):
try:
def ok(res):
def unicode_(s, encoding):
if isinstance(s, unicode):
return s
return unicode(s, encoding)
members = []
for member in res[0]:
if not isinstance(member, basestring):
member = str(member)
members.append(unicode_(member, "utf-8"))
subgroups = [unicode_(subgroup, "utf-8") for subgroup in res[1]]
res_str = [members, subgroups]
request.write(simplejson.dumps(res_str))
request.finish()
if group_info is None:
return webservice.badRequest(request, "Group does not exist.")
exists = is_member(group_info, member, ctype_str)
if otype_str == "add" and exists:
return webservice.badRequest(request, "%s is already a %s in the group." % (member, ctype_str))
if otype_str != "add" and not exists:
return webservice.notFound(request, "%s %s not found in group." % (ctype_str.capitalize(), member))
if otype_str == "":
# special case, this is just a membership test
# if the request got this far, return success
request.finish()
return
ptype = groupname_to_type[ptype_str]
method_name = otype_str + "_group_members"
f = getattr(self.dm, method_name)
if ctype_str in ["principal", "address"]:
d = f(ptype, group_info.name, (member,), ())
else: # 'subgroup' case
d = f(ptype, group_info.name, (), (member,))
d.addCallback(ok)
d.addErrback(self.err, request, "%s member_op" % method_name, "Could not %s." % method_name)
return NOT_DONE_YET
except Exception, e:
return self.err(Failure(), request, "member_op", "Could not perform group operation.")
def err_specific(res):
if isinstance(res.value, DirectoryException):
if res.value.code == DirectoryException.RECORD_ALREADY_EXISTS:
lg.error("Conflict error: _modify_principal %s %s already exists: %s" \
% (type_str, content['name'], str(res)))
return webservice.conflictError(
request, "%s %s already exists." %
(type_str.capitalize(), content['name']))
elif res.value.code == DirectoryException.NONEXISTING_NAME:
lg.error("Bad request: _modify_principal %s %s does not exist: %s" \
% (type_str.capitalize(), mangled_name, str(res)))
return webservice.notFound(
request, "%s %s does not exist." %
(type_str.capitalize(), mangled_name))
return self.err(res, request, "_modify_principal",
"Could not modify principal.")
def get_port_name_stats(self, request, arg, switch_info):
try:
portname = arg['<port name>']
dpid = switch_info.dpid.as_host()
if dpid in self.switchstats.dp_port_stats:
ports = self.switchstats.dp_port_stats[dpid]
portno = self.switchstats.map_name_to_portno(dpid, portname)
for p in ports.values():
if p['port_no'] == portno:
pc = copy.deepcopy(p)
del pc['port_no']
request.write(simplejson.dumps(pc))
request.finish()
return NOT_DONE_YET
for loc in switch_info.locations:
if loc.port_name == portname:
stats = {}
stats['collisions'] = None
stats['delta_bytes'] = None
stats['tx_bytes'] = None
stats['tx_packets'] = None
stats['tx_dropped'] = None
stats['tx_errors'] = None
stats['rx_bytes'] = None
stats['rx_packets'] = None
stats['rx_dropped'] = None
stats['rx_errors'] = None
stats['rx_`crc_err'] = None
stats['rx_over_err'] = None
stats['rx_frame_err'] = None
request.write(simplejson.dumps(stats))
request.finish()
return NOT_DONE_YET
return webservice.notFound(request, "Port '%s' not on switch." % portname)
except Exception, e:
return self.err(Failure(), request, "get_port_name_stats",
"Could not retrieve switch port name stats.")
def group_op(self, request, group_info, mangled_group, ptype_str,
otype_str):
try:
def ok(res):
if isinstance(res, GroupInfo):
request.write(simplejson.dumps(res.to_str_dict()))
else:
request.write(simplejson.dumps(res))
request.finish()
is_get_op = otype_str == "get" or otype_str == "principal" \
or otype_str == "subgroup"
if group_info is None and (is_get_op or otype_str == "del"):
return webservice.notFound(
request, "Group %s does not exist." % mangled_group)
# read operations finish here. this includes 'get','principal'
# and 'subgroup' otype_str
if is_get_op:
str_dict = group_info.to_str_dict()
if otype_str == "get":
request.write(simplejson.dumps(str_dict))
elif otype_str == "principal":
request.write(simplejson.dumps(str_dict["member_names"]))
elif otype_str == "subgroup":
request.write(simplejson.dumps(str_dict["subgroup_names"]))
request.finish()
return
# only otype_str == 'add' or 'del' continues to this point
ptype = groupname_to_type[ptype_str]
if otype_str == "add":
content = json_parse_message_body(request)
if content == None:
return webservice.badRequest(
request, "Unable to parse message body.")
if group_info is None:
content["name"] = mangled_group
d = getattr(self.dm,
"add_group")(ptype,
GroupInfo.from_str_dict(content))
elif len(content) == 1 and content.has_key('name'):
d = getattr(self.dm,
"rename_group")(ptype, mangled_group,
content['name'], '', '')
else:
content["name"] = mangled_group
d = getattr(self.dm, "modify_group")(
ptype, GroupInfo.from_str_dict(content))
else: # delete
d = getattr(self.dm, "del_group")(ptype, mangled_group)
d.addCallback(ok)
d.addErrback(self.err, request,
"%s %s group_op" % (otype_str, ptype_str),
"Could not perform %s group operation." % ptype_str)
return NOT_DONE_YET
except Exception, e:
return self.err(
Failure(), request, "%s %s group_op" % (otype_str, ptype_str),
"Could not perform %s group operation." % ptype_str)
def find_cert(cert_dict):
if fp in cert_dict:
request.write(cert_dict[fp])
request.finish()
else:
webservice.notFound(request, "No approved cert with fingerprint = '%s'" % fp)
def start2(self, switch_info, handler, request, arg):
if switch_info == None:
return webservice.notFound(request, "Switch does not exist.")
return handler(request, arg, switch_info)
