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 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 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 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)