def _change_search_order(self, request, arg): def err_specific(res): if isinstance(res.value, DirectoryException) \ and res.value.code == DirectoryException.NONEXISTING_NAME: lg.error( "Bad request: _change_search_order received nonexisting_name: %s" % str(res)) return webservice.badRequest(request, res.value.message) return self.err(res, request, "_change_search_order", "Could not change search order.") try: content = json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") def ok(res): request.write(simplejson.dumps(res)) request.finish() d = self._dm.set_search_order(content) d.addCallback(ok) d.addErrback(err_specific) return NOT_DONE_YET except Exception, e: err_specific(Failure())
def shutdown(self, request, arg): try: content = json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") if not content in self.shutdown_scripts: return webservice.badRequest(request, "Cannot shutdown '%s'." % content) d = defer.Deferred() args = self.shutdown_scripts[content] env = dict(os.environ) process = reactor.spawnProcess(OutputGrabber(d), self.shutdown_scripts[content][0], args=args, env=env) def success(output): lg.debug("Shutdown completed:\n%s" % output) def error(failure): lg.error("Shutdown did not complete:\n%s" % str(failure)) d.addCallback(success).\ addErrback(error) return simplejson.dumps(True) except Exception, e: return self.err(Failure(), request, "shutdown", "Could not shutdown the system/process.")
def put_interface(self, request, arg): try: intf = cfg_interface() content = json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") try: if not 'name' in content: return webservice.badRequest(request, "Cannot configure interface: Name parameter not present.") intf.name = str(content['name']) if 'hwaddr' in content: intf.hwaddr = str(content['hwaddr']) if 'ip4addr' in content: intf.ip4addr = str(content['ip4addr']) if 'ip4mask' in content: intf.ip4mask = str(content['ip4mask']) if 'ip4bcast' in content: intf.ip4bcast = str(content['ip4bcast']) if 'ip4gw' in content: intf.ip4gw = str(content['ip4gw']) if 'ip4dns' in content: intf.ip4dns = str(content['ip4dns']) if 'dhcp' in content: intf.dhcp = content['dhcp'] except Exception, e: f = Failure() lg.error("put_interface_config: error reading interface information from request:" + str(f)) return webservice.badRequest(request,"Cannot configure interface: invalid content parameters.") self.cfg.set_interface(intf) return simplejson.dumps(True)
def _test_flow_fetcher(self, request, arg): try: flow_stats_request = json_parse_message_body(request) dpid = datapathid.from_host(long(flow_stats_request['dpid'], 16)) ff = self.ffa.fetch(dpid, flow_stats_request, lambda: report_results(ff)) except Exception, e: return self.err(Failure(), request, "_test_flow_fetcher", "Could not request flows.")
def put_config_from_request(self,request, arg): try: section_id = arg['<section>'] content = webservice.json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") return self.set_config_common(request,section_id,content) except Exception, e: return self.err(Failure(), request, "put_config_from_request", "Could not set config.")
def put_record_rule_senders(self, request, data): try: content = webservice.json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") elif not self.policy.set_record_rule_senders(data['<rule id>'], content['record_senders']): return webservice.badRequest(request, "Could not set record senders for rule ID %u." % data['<rule id>']) return "Success" except Exception, e: return self.err(Failure(), request, "put_record_rule_senders", "Could not set record rule senders field.")
def put_rule(self, request, data): try: content = webservice.json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") d = self.policy.lock_policy() d.addCallback(self.__put_rule__, request, data, content) d.addBoth(self.unlock_policy) d.addErrback(self.err, request, "put_rule", "Could not modify rule.") except Exception, e: return self.err(Failure(), request, "put_rule", "Could not modify rule.")
def _add_table_row(self, request, arg): schema = arg[self.dbschema.dbname] table_name = arg["<db table name>"] row = webservice.json_parse_message_body(request) if row == None: return webservice.NOT_DONE_YET e = base_storagews._errors_in_row(schema, table_name, row, noGUID=True) if len(e) != 0: errmsg = "Errors in message body:" + "\n - ".join(e) return webservice.badRequest(request, errmsg) p = self.op_cls(self.db, schema, request) p.doPut(table_name, row) return webservice.NOT_DONE_YET
def modify_protocol(request, data): try: content = webservice.json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") d = to_protocol_tup(request, content) d.addCallback(__modify_protocol2__, request, data) d.addErrback(err, request, "modify_protocol", "Could not modify protocol.") return webservice.NOT_DONE_YET except Exception, e: return err(Failure(), request, "modify_protocol", "Could not modify protocol.")
def put_analysis(self, request, data): try: content = webservice.json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") d = self.policy.lock_policy() d.addCallback(self.__put_analysis__, request, data, content) d.addBoth(self.unlock_policy) d.addErrback(self.err, request, "put_analysis", "Could not analyze rules.") return webservice.NOT_DONE_YET except Exception, e: return self.err(Failure(), request, "put_analysis", "Could not analyze rules.")
def put_record_rule_senders(self, request, data): try: content = webservice.json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") elif not self.policy.set_record_rule_senders( data['<rule id>'], content['record_senders']): return webservice.badRequest( request, "Could not set record senders for rule ID %u." % data['<rule id>']) return "Success" except Exception, e: return self.err(Failure(), request, "put_record_rule_senders", "Could not set record rule senders field.")
def handle_add(self,request,data): try: content = json_parse_message_body(request) if content == None: content = {} app = "via-netevent-webservice" if "app" in content: app = str(content["app"]) msg = "default webservice message" if "msg" in content: msg = str(content["msg"]) self.uel.log(app,LogEntry.INFO, msg) except Exception, e: err(Failure(), request, "handle_add", "Could not add log message")
def _modify_dir(self, request, arg): try: def _config_set(res): ep = convert_map_name_to_type(content["enabled_principals"]) d = di.set_enabled_principals(ep) d.addCallback(_enabled_principals_set) return d def _enabled_principals_set(res): d = di.set_enabled_auth_types(content["enabled_auth_types"]) d.addCallback(_enabled_auth_set) return d def _enabled_auth_set(res): if content["name"] != dname: lg.error("TODO: implement renaming directories") item = self._convert_instance_to_dict(instance) ret = simplejson.dumps(item) request.write(ret) request.finish() dname = arg['<dir name>'] content = json_parse_message_body(request) if content is None: return webservice.badRequest(request, "Unable to parse message body.") if request.args.get('add', ['false'])[0].lower() == 'true': return self._add_dir(request, dname, content) instance = self._dm.get_directory_instance(dname) if instance is None: return webservice.badRequest( request, "Could not modify " "directory: directory named '%s' does not exist" % dname) # otherwise, proceed with normal modify di = instance._instance d = di.set_config_params(content["config_params"]) d.addCallback(_config_set) d.addErrback(self.err, request, "_modify_dir", "Could not modify directory.") return NOT_DONE_YET except Exception, e: return self.err(Failure(), request, "_modify_dir", "Could not add/modify directory.")
def _do_auth_event(self, request, arg): content = json_parse_message_body(request) try : type = Auth_event.AUTHENTICATE if "type" in content and content["type"] == "deauthenticate": type = Auth_event.DEAUTHENTICATE ni = NetInfo.from_str_dict(content) hostname =str(content.get("hostname",Authenticator.get_unknown_name())) username =str(content.get("username", Authenticator.get_unknown_name())) ae = Auth_event(type, ni.dpid, ni.port, ni.dladdr,ni.nwaddr,False, hostname, username, 0, 0) self.post(ae) return "[]" except Exception , e : traceback.print_exc() return webservice.badRequest(request, str(e))
def _modify_dir(self,request,arg): try: def _config_set(res): ep = convert_map_name_to_type(content["enabled_principals"]) d = di.set_enabled_principals(ep) d.addCallback(_enabled_principals_set) return d def _enabled_principals_set(res): d = di.set_enabled_auth_types(content["enabled_auth_types"]) d.addCallback(_enabled_auth_set) return d def _enabled_auth_set(res): if content["name"] != dname: lg.error("TODO: implement renaming directories") item = self._convert_instance_to_dict(instance) ret = simplejson.dumps(item) request.write(ret) request.finish() dname = arg['<dir name>'] content = json_parse_message_body(request) if content is None: return webservice.badRequest(request, "Unable to parse message body.") if request.args.get('add', ['false'])[0].lower() == 'true': return self._add_dir(request, dname, content) instance = self._dm.get_directory_instance(dname) if instance is None: return webservice.badRequest(request,"Could not modify " "directory: directory named '%s' does not exist" %dname) # otherwise, proceed with normal modify di = instance._instance d = di.set_config_params(content["config_params"]) d.addCallback(_config_set) d.addErrback(self.err, request, "_modify_dir", "Could not modify directory.") return NOT_DONE_YET except Exception, e: return self.err(Failure(), request, "_modify_dir", "Could not add/modify directory.")
def _do_auth_event(self, request, arg): content = json_parse_message_body(request) try: type = Auth_event.AUTHENTICATE if "type" in content and content["type"] == "deauthenticate": type = Auth_event.DEAUTHENTICATE ni = NetInfo.from_str_dict(content) hostname = str( content.get("hostname", Authenticator.get_unknown_name())) username = str( content.get("username", Authenticator.get_unknown_name())) ae = Auth_event(type, ni.dpid, ni.port, ni.dladdr, ni.nwaddr, False, hostname, username, 0, 0) self.post(ae) return "[]" except Exception, e: traceback.print_exc() return webservice.badRequest(request, str(e))
def _update_table_row(self, request, arg): schema = arg[self.dbschema.dbname] table_name = arg["<db table name>"] guid = arg["<db row guid>"] row = webservice.json_parse_message_body(request) if row == None: return webservice.NOT_DONE_YET e = base_storagews._errors_in_row(schema, table_name, row, noGUID=False) if guid != row["GUID"]: e.append("GUID in message body must match GUID in URI.") if len(e) != 0: errmsg = "The following error(s) were found:\n\n - " errmsg += "\n - ".join(e) return webservice.badRequest(request, errmsg) # TBD: remove this hack when storage API supports python # TBD: unicode strings. base_storagews._strip_unicode_in_dict(row) p = self.op_cls(self.db, schema, request) p.doModifyRow(table_name, row) return webservice.NOT_DONE_YET
def put_interface(self, request, arg): try: intf = cfg_interface() content = json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") try: if not 'name' in content: return webservice.badRequest( request, "Cannot configure interface: Name parameter not present." ) intf.name = str(content['name']) if 'hwaddr' in content: intf.hwaddr = str(content['hwaddr']) if 'ip4addr' in content: intf.ip4addr = str(content['ip4addr']) if 'ip4mask' in content: intf.ip4mask = str(content['ip4mask']) if 'ip4bcast' in content: intf.ip4bcast = str(content['ip4bcast']) if 'ip4gw' in content: intf.ip4gw = str(content['ip4gw']) if 'ip4dns' in content: intf.ip4dns = str(content['ip4dns']) if 'dhcp' in content: intf.dhcp = content['dhcp'] except Exception, e: f = Failure() lg.error( "put_interface_config: error reading interface information from request:" + str(f)) return webservice.badRequest( request, "Cannot configure interface: invalid content parameters.") self.cfg.set_interface(intf) return simplejson.dumps(True)
def _change_search_order(self, request, arg): def err_specific(res): if isinstance(res.value, DirectoryException) \ and res.value.code == DirectoryException.NONEXISTING_NAME: lg.error("Bad request: _change_search_order received nonexisting_name: %s" % str(res)) return webservice.badRequest(request, res.value.message) return self.err(res, request, "_change_search_order", "Could not change search order.") try: content = json_parse_message_body(request) if content == None: return webservice.badRequest(request,"Unable to parse message body.") def ok(res): request.write(simplejson.dumps(res)) request.finish() d = self._dm.set_search_order(content) d.addCallback(ok) d.addErrback(err_specific) return NOT_DONE_YET except Exception, e: err_specific(Failure())
def _modify_principal(self, request, arg): 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.") try: type_str = get_principal_type_from_args(arg) dirname = arg['<dir name>'] # must specify a dir-name name = arg['<principal name>'] mangled_name = mangle_name(dirname, name) def ok(res): ret = simplejson.dumps(res.to_str_dict()) request.write(ret) request.finish() content = json_parse_message_body(request) if content == None: return webservice.badRequest(request,"Unable to parse message body.") info = None if type_str == "location": info = LocationInfo.from_str_dict(content) elif type_str == "switch": info = SwitchInfo.from_str_dict(content) elif type_str == "user": info = UserInfo.from_str_dict(content) elif type_str == "host": info = HostInfo.from_str_dict(content) else: raise Exception("Invalid principal type %s" % type_str) ptype = name_to_type_map[type_str] if hasattr(info, 'name') and info.name != None: if len(content) == 1: #rename newdir = demangle_name(info.name)[0] d = self._dm.rename_principal(ptype, name, info.name, dirname, newdir) else: #modify if info.name != mangled_name: # renaming and updating info simultaneously can cause # duplicate key problems when moving entities between # directories - for now, we simply disallow this behavior # The UI should never even give the user a chance to # create this error condition, so this is really dev check msg = "Cannot rename and modify '%s' at the same time." \ % mangled_name lg.error("Bad request: %s" % msg) return webservice.badRequest(request, msg) d = self._dm.add_or_modify_principal(ptype, info, dirname) else: info.name = name d = self._dm.add_or_modify_principal(ptype, info, dirname) if d == None: raise Exception("Directorymanager returned a null deferred.") d.addCallback(ok) d.addErrback(err_specific) return NOT_DONE_YET except Exception, e: return err_specific(Failure())
def _modify_principal(self, request, arg): 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.") try: type_str = get_principal_type_from_args(arg) dirname = arg['<dir name>'] # must specify a dir-name name = arg['<principal name>'] mangled_name = mangle_name(dirname, name) def ok(res): ret = simplejson.dumps(res.to_str_dict()) request.write(ret) request.finish() content = json_parse_message_body(request) if content == None: return webservice.badRequest(request, "Unable to parse message body.") info = None if type_str == "location": info = LocationInfo.from_str_dict(content) elif type_str == "switch": info = SwitchInfo.from_str_dict(content) elif type_str == "user": info = UserInfo.from_str_dict(content) elif type_str == "host": info = HostInfo.from_str_dict(content) else: raise Exception("Invalid principal type %s" % type_str) ptype = name_to_type_map[type_str] if hasattr(info, 'name') and info.name != None: if len(content) == 1: #rename newdir = demangle_name(info.name)[0] d = self._dm.rename_principal(ptype, name, info.name, dirname, newdir) else: #modify if info.name != mangled_name: # renaming and updating info simultaneously can cause # duplicate key problems when moving entities between # directories - for now, we simply disallow this behavior # The UI should never even give the user a chance to # create this error condition, so this is really dev check msg = "Cannot rename and modify '%s' at the same time." \ % mangled_name lg.error("Bad request: %s" % msg) return webservice.badRequest(request, msg) d = self._dm.add_or_modify_principal(ptype, info, dirname) else: info.name = name d = self._dm.add_or_modify_principal(ptype, info, dirname) if d == None: raise Exception("Directorymanager returned a null deferred.") d.addCallback(ok) d.addErrback(err_specific) return NOT_DONE_YET except Exception, e: return err_specific(Failure())