コード例 #1
0
    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())
コード例 #2
0
ファイル: local_configws.py プロジェクト: bigswitch/snac
    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.")
コード例 #3
0
ファイル: local_configws.py プロジェクト: bigswitch/snac
 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)
コード例 #4
0
    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.")
コード例 #5
0
ファイル: test.py プロジェクト: marcosmamorim/snac-nox
 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.")
コード例 #6
0
 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.")
コード例 #7
0
 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.")
コード例 #8
0
ファイル: policyws.py プロジェクト: bigswitch/snac
 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.")
コード例 #9
0
ファイル: policyws.py プロジェクト: bigswitch/snac
 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.")
コード例 #10
0
 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
コード例 #11
0
 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
コード例 #12
0
 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.")
コード例 #13
0
ファイル: protocolsws.py プロジェクト: bigswitch/snac
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.")
コード例 #14
0
ファイル: policyws.py プロジェクト: bigswitch/snac
 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.")
コード例 #15
0
 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.")
コード例 #16
0
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.")
コード例 #17
0
 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.")
コード例 #18
0
 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")
コード例 #19
0
    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.")
コード例 #20
0
ファイル: eventws.py プロジェクト: bigswitch/snac
    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)) 
コード例 #21
0
    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.")
コード例 #22
0
    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))
コード例 #23
0
 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
コード例 #24
0
 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)
コード例 #25
0
 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
コード例 #26
0
    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())
コード例 #27
0
    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())
コード例 #28
0
    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())