def add_group_members(self,
group_type,
group_name,
member_names=[],
subgroup_names=[]):
group_dict = self.groups.get(group_type)
parent_group_dict = self.parent_groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type %s" %
group_type))
# TODO: check member
# TODO: check subgroups
if not group_dict.has_key(group_name):
return defer.fail(
DirectoryException('Cannot modify group - does not exist.',
DirectoryException.NONEXISTING_NAME))
group = group_dict[group_name]
added_names = []
added_subgroups = []
for name in member_names:
if name not in group.member_names:
group.member_names.append(name)
added_names.append(name)
if group_type == Directory.NWADDR_GROUP:
self.cidr_cache.add_cidr(group_name, name)
for subgroup in subgroup_names:
if subgroup not in group.subgroup_names:
group.subgroup_names.append(subgroup)
added_subgroups.append(subgroup)
#add parent_group pointer to subgroup
parent_group_set = parent_group_dict.get(subgroup) or set()
parent_group_set.add(group_name)
parent_group_dict[subgroup] = parent_group_set
return defer.succeed((added_names, added_subgroups))
def modify_switch(self, switch_info):
if switch_info.dpid == None:
return defer.fail(
DirectoryException('Cannot modify switch - dpid must be set.'))
if not self.switches.has_key(switch_info.name):
return defer.fail(
DirectoryException('Cannot modify switch - does not exist.',
DirectoryException.RECORD_ALREADY_EXISTS))
if switch_info.name in self.restricted_names:
return defer.fail(
DirectoryException(
'Cannot modify switch %s.' % switch_info.name,
DirectoryException.OPERATION_NOT_PERMITTED))
dpid = switch_info.dpid.as_host()
old_info = self.switches[switch_info.name]
if switch_info.dpid != old_info.dpid:
if self.switch_bindings.has_key(dpid):
return defer.fail(
DirectoryException(
'Cannot modify switch - dpid already bound.',
DirectoryException.RECORD_ALREADY_EXISTS))
del self.switch_bindings[old_info.dpid.as_host()]
if hasattr(old_info, '_fp_credentials') and \
not hasattr(switch_info,'_fp_credentials'):
switch_info._fp_credentials = old_info._fp_credentials
self.switches[switch_info.name] = switch_info
self.switch_bindings[dpid] = switch_info
return defer.succeed(copy.deepcopy(switch_info))
def del_switch(self, switch_name):
if not self.switches.has_key(switch_name):
return defer.fail(
DirectoryException('Cannot delete switch - does not exist.',
DirectoryException.NONEXISTING_NAME))
if switch_name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot delete switch %s.' % switch_name,
DirectoryException.OPERATION_NOT_PERMITTED))
ret = self.switches[switch_name]
del self.switches[switch_name]
del self.switch_bindings[ret.dpid.as_host()]
#delete the associated locations
locations = self.locations.values()
filter_list(locations, lambda location: location.dpid != ret.dpid)
ret.locations = locations
for loc in locations:
key = loc.dpid.as_host() + (loc.port << 48)
del self.locations[loc.name]
del self.location_bindings[key]
#delete location from groups - ignore deferred result as the
#call is actually synchronous
self._del_member_from_groups(ret, Directory.LOCATION_PRINCIPAL,
mangle_name(self.name, loc))
return self._del_member_from_groups(
ret, Directory.SWITCH_PRINCIPAL,
mangle_name(self.name, switch_name))
def rename_group(self, group_type, old_name, new_name):
if not group_type in self.groups:
raise DirectoryException("Unsupported group type '%s' in "
"rename_group" % group_type)
grouptbl = self.groups[group_type]
groupparenttbl = self.parent_groups[group_type]
if grouptbl.has_key(new_name):
raise DirectoryException("Record with name '%s' already exists" %
new_name)
if not old_name in grouptbl:
raise DirectoryException("No record found with name '%s'" %
old_name)
#update our group
info = grouptbl[old_name]
info.name = new_name
del grouptbl[old_name]
grouptbl[new_name] = info
if group_type == Directory.NWADDR_GROUP:
self.cidr_cache.ren_cidr(old_name, new_name)
#update our parent group set
if groupparenttbl.has_key(old_name):
pgs = groupparenttbl[old_name]
del groupparenttbl[old_name]
groupparenttbl[new_name] = pgs
#update groups referencing us as parent groups
for subgroup_name in info.subgroup_names:
groupparenttbl[subgroup_name].discard(old_name)
groupparenttbl[subgroup_name].add(new_name)
return defer.succeed(copy.copy(info))
def add_switch(self, switch_info):
if switch_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot add switch - '
'invalid name.',
DirectoryException.OPERATION_NOT_PERMITTED))
elif switch_info.dpid == None:
return defer.fail(
DirectoryException('Cannot add switch - dpid must be set.'))
elif self.switches.has_key(switch_info.name):
return defer.fail(
DirectoryException(
'Cannot add switch - switch already exists.',
DirectoryException.RECORD_ALREADY_EXISTS))
dpid = switch_info.dpid.as_host()
if self.switch_bindings.has_key(dpid):
return defer.fail(
DirectoryException('Cannot add switch - dpid already bound.',
DirectoryException.RECORD_ALREADY_EXISTS))
si = copy.deepcopy(switch_info)
si.locations = []
si._fp_credentials = []
self.switches[si.name] = si
self.switch_bindings[dpid] = si
if hasattr(switch_info, 'locations'):
for loc in switch_info.locations:
self.add_location(loc)
return defer.succeed(copy.deepcopy(switch_info))
def del_host(self, host_name):
if not self.hosts.has_key(host_name):
return defer.fail(
DirectoryException('Cannot delete host - does not exist.',
DirectoryException.NONEXISTING_NAME))
if host_name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot delete host %s.' % host_name,
DirectoryException.OPERATION_NOT_PERMITTED))
ret = self.hosts[host_name]
del self.hosts[host_name]
for info in ret.netinfos:
if info.dpid != None:
del self.host_loc_bindings[info.dpid.as_host() +
(info.port << 48)]
elif info.dladdr != None:
dl = info.dladdr.hb_long()
del self.host_dl_bindings[dl]
del self.routers[dl]
del self.gateways[dl]
elif info.nwaddr != None:
del self.host_nw_bindings[info.nwaddr]
for alias in ret.aliases:
self._del_member_from_groups(ret, Directory.HOST_PRINCIPAL,
mangle_name(self.name, alias))
return self._del_member_from_groups(ret, Directory.HOST_PRINCIPAL,
mangle_name(self.name, host_name))
def add_host(self, host_info):
if host_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot add host - invalid name.',
DirectoryException.OPERATION_NOT_PERMITTED))
if self.hosts.has_key(host_info.name):
return defer.fail(
DirectoryException('Cannot add host - already exists.',
DirectoryException.RECORD_ALREADY_EXISTS))
locs = []
dls = []
nws = []
for info in host_info.netinfos:
if not self.__check_netinfo_key__(info, locs, dls, nws):
return defer.fail(
DirectoryException(
'Cannot add host - already bound.',
DirectoryException.RECORD_ALREADY_EXISTS))
hi = copy.deepcopy(host_info)
hi._fp_credentials = []
self.hosts[host_info.name] = hi
for loc in locs:
self.host_loc_bindings[loc] = hi
for dl, is_r, is_g in dls:
self.host_dl_bindings[dl] = hi
self.routers[dl] = is_r
self.gateways[dl] = is_g
for nw in nws:
self.host_nw_bindings[nw] = hi
return defer.succeed(copy.deepcopy(host_info))
def search_groups(self, group_type, query_dict):
group_dict = self.groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type '%s'" %
group_type))
if len(set(query_dict.keys()) - set(['name', 'name_glob'])):
raise DirectoryException("Unsupported query in search_groups")
groups = None
if query_dict.has_key('name'):
name = query_dict['name']
if group_dict.has_key(name):
groups = [name]
elif name in self.restricted_names and len(query_dict) == 1:
return defer.succeed([name])
else:
groups = []
if query_dict.has_key('name_glob'):
regex_str = glob_to_regex(query_dict['name_glob'])
regex = re.compile(regex_str)
if groups == None:
groups = group_dict.keys()
filter_list(groups, lambda group: not regex.search(group))
if groups == None:
return defer.succeed(group_dict.keys())
return defer.succeed(groups)
def add_group(self, group_type, group_info):
group_dict = self.groups.get(group_type)
parent_group_dict = self.parent_groups.get(group_type)
if group_dict is None or parent_group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type %s" %
group_type))
# TODO: check member
# TODO: check subgroups
if group_info.name == None or group_info.name == "":
return defer.fail(DirectoryException('Cannot add group None.'))
if group_dict.has_key(group_info.name):
return defer.fail(
DirectoryException('Cannot add group - already '
'exists.',
DirectoryException.RECORD_ALREADY_EXISTS))
group_dict[group_info.name] = group_info
for sg in group_info.subgroup_names:
parent_group_set = parent_group_dict.get(sg) or set()
parent_group_set.add(group_info.name)
parent_group_dict[sg] = parent_group_set
if group_type == Directory.NWADDR_GROUP:
for member in group_info.member_names:
self.cidr_cache.add_cidr(group_info.name, member)
return defer.succeed(copy.deepcopy(group_info))
def del_group_members(self,
group_type,
group_name,
member_names=[],
subgroup_names=[]):
group_dict = self.groups.get(group_type)
parent_group_dict = self.parent_groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type %s" %
group_type))
if not group_dict.has_key(group_name):
return defer.fail(
DirectoryException('Cannot modify group - does not exist.',
DirectoryException.NONEXISTING_NAME))
group = group_dict[group_name]
removed_names = []
removed_subgroups = []
for name in member_names:
if name in group.member_names:
group.member_names.remove(name)
removed_names.append(name)
if group_type == Directory.NWADDR_GROUP:
self.cidr_cache.del_cidr(group_name, name)
for subgroup in subgroup_names:
if subgroup in group.subgroup_names:
group.subgroup_names.remove(subgroup)
removed_subgroups.append(subgroup)
#remove parent_group pointer
parent_group_set = parent_group_dict.get(subgroup)
if parent_group_set:
parent_group_set.discard(group_name)
return defer.succeed((removed_names, removed_subgroups))
def modify_location(self, location_info):
if location_info.dpid == None or location_info.port == None:
return defer.fail(
DirectoryException(
'Cannot modify location - dpid and port must be set.'))
if not self.locations.has_key(location_info.name):
return defer.fail(
DirectoryException(
'Cannot modify location - location does not exist.',
DirectoryException.NONEXISTING_NAME))
if location_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot modify location %s.' %
location_info.name))
old_info = self.locations[location_info.name]
if hasattr(old_info, '_fp_credentials') and \
not hasattr(location_info,'_fp_credentials'):
location_info._fp_credentials = old_info._fp_credentials
key = location_info.dpid.as_host() + (location_info.port << 48)
old_key = old_info.dpid.as_host() + (old_info.port << 48)
if old_key != key:
if self.location_bindings.has_key(key):
return defer.fail(
DirectoryException(
'Cannot modify location - dpid/port already bound.',
DirectoryException.RECORD_ALREADY_EXISTS))
del self.location_bindings[old_key]
li = copy.deepcopy(location_info)
self.locations[location_info.name] = li
self.location_bindings[key] = li
return defer.succeed(location_info)
def del_group(self, group_type, group_name):
group_dict = self.groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type %s" %
group_type))
if not group_dict.has_key(group_name):
return defer.fail(
DirectoryException('Cannot delete group - does not exist.',
DirectoryException.NONEXISTING_NAME))
parent_group_dict = self.parent_groups.get(group_type)
mangled_gname = mangle_name(self.name, group_name)
#remove index to our parent groups
if parent_group_dict.has_key(mangled_gname):
for pg in parent_group_dict[mangled_gname]:
group_dict[pg].subgroup_names.remove(mangled_gname)
del parent_group_dict[mangled_gname]
ret = group_dict[group_name]
#remove subgroups parent group reference to us
for sg in ret.subgroup_names:
if sg in parent_group_dict:
parent_group_dict[sg].discard(group_name)
#remove the group from the cidr lookup cache
if group_type == Directory.NWADDR_GROUP:
for member in ret.member_names:
self.cidr_cache.del_cidr(group_info.name, member)
#remove the group
del group_dict[group_name]
return defer.succeed(ret)
def modify_group(self, group_type, group_info):
group_dict = self.groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type %s" %
group_type))
name = getattr(group_info, "name")
if not group_dict.has_key(name):
return defer.fail(
DirectoryException("No group named '%s' exists" % name,
DirectoryException.NONEXISTING_NAME))
gi = group_dict[name]
gi.description = group_info.description
return defer.succeed(copy.deepcopy(gi))
def del_user(self, user_name):
if not self.users.has_key(user_name):
return defer.fail(
DirectoryException('Cannot delete user - does '
'not exist.',
DirectoryException.NONEXISTING_NAME))
if user_name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot delete user %s.' % user_name,
DirectoryException.OPERATION_NOT_PERMITTED))
ret = self.users[user_name]
del self.users[user_name]
return self._del_member_from_groups(ret, Directory.USER_PRINCIPAL,
mangle_name(self.name, user_name))
def modify_host(self, host_info):
if not self.hosts.has_key(host_info.name):
return defer.fail(
DirectoryException('Cannot modify host - does not exist.',
DirectoryException.NONEXISTING_NAME))
if host_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot modify host %s.' % host_info.name,
DirectoryException.OPERATION_NOT_PERMITTED))
locs = []
dls = []
nws = []
old_info = self.hosts[host_info.name]
for info in host_info.netinfos:
if not self.__check_netinfo_key__(info, locs, dls, nws, old_info):
return defer.fail(
DirectoryException(
'Cannot modify host - already bound.',
DirectoryException.RECORD_ALREADY_EXISTS))
if hasattr(old_info, '_refcount') and \
not hasattr(host_info,'_refcount'):
host_info._refcount = old_info._refcount
if hasattr(old_info, '_fp_credentials') and \
not hasattr(host_info,'_fp_credentials'):
host_info._fp_credentials = old_info._fp_credentials
for info in old_info.netinfos:
if info.dpid != None:
del self.host_loc_bindings[info.dpid.as_host() +
(info.port << 48)]
elif info.dladdr != None:
dl = info.dladdr.hb_long()
del self.host_dl_bindings[dl]
del self.routers[dl]
del self.gateways[dl]
elif info.nwaddr != None:
del self.host_nw_bindings[info.nwaddr]
self.hosts[host_info.name] = host_info
for loc in locs:
self.host_loc_bindings[loc] = host_info
for dl, is_r, is_g in dls:
self.host_dl_bindings[dl] = host_info
self.routers[dl] = is_r
self.gateways[dl] = is_g
for nw in nws:
self.host_nw_bindings[nw] = host_info
return defer.succeed(copy.deepcopy(host_info))
def search_users(self, query):
checked = 0
users = None
if query.has_key('name'):
name = query['name']
if self.users.has_key(name):
users = [self.users[name]]
elif name in self.restricted_names and len(query) == 1:
return defer.succeed([name])
else:
users = []
checked = checked + 1
if query.has_key('name_glob'):
regex_str = glob_to_regex(query['name_glob'])
regex = re.compile(regex_str)
if users == None:
users = self.users.values()
filter_list(users, lambda user: not regex.search(user.name))
checked = checked + 1
if checked != len(query):
raise DirectoryException('Unsupported query parameters',
DirectoryException.INVALID_QUERY)
elif users == None:
return defer.succeed(self.users.keys())
return defer.succeed([user.name for user in users])
def add_user(self, user_info):
if user_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot add user - invalid '
'name.',
DirectoryException.RECORD_ALREADY_EXISTS))
if self.users.has_key(user_info.name):
return defer.fail(
DirectoryException('Cannot add user - already '
'exists.',
DirectoryException.RECORD_ALREADY_EXISTS))
ui = copy.deepcopy(user_info)
ui._fp_credentials = []
self.users[user_info.name] = ui
return defer.succeed(copy.deepcopy(user_info))
def _rename(pdict):
if pdict.has_key(new_name):
raise DirectoryException(
"Record with name '%s' already exists" % new_name,
DirectoryException.RECORD_ALREADY_EXISTS)
if not old_name in pdict:
raise DirectoryException(
"No record found with name '%s'" % old_name,
DirectoryException.NONEXISTING_NAME)
info = pdict[old_name]
del pdict[old_name]
info.name = new_name
pdict[new_name] = info
#update group membership
return self.rename_group_member(copy.copy(pdict[new_name]),
principal_type, old_name, new_name)
def get_group_membership(self,
group_type,
member_name=None,
local_groups=None):
group_dict = self.groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type '%s'" %
group_type))
if member_name is None \
or (isinstance(member_name, basestring) and member_name == ""):
return defer.succeed(group_dict.keys())
groups = set()
if is_mangled_name(member_name):
mangled_name = member_name
else:
mangled_name = mangle_name(self.name, member_name)
if isinstance(member_name, netinet.cidr_ipaddr):
groups.update(self.cidr_cache.get_groups(member_name))
else:
for group, gi in group_dict.iteritems():
if mangled_name in gi.member_names:
groups.add(group)
parentgroups = set()
for group in groups:
parentgroups.update(
set(
self._get_group_parents_s(group_type,
mangle_name(self.name, group))))
for lgroup in (local_groups or []):
parentgroups.update(
set(self._get_group_parents_s(group_type, lgroup)))
return defer.succeed(tuple(groups | parentgroups))
def del_location(self, location_name):
if not self.locations.has_key(location_name):
return defer.fail(
DirectoryException('Cannot delete location - does not exist.',
DirectoryException.NONEXISTING_NAME))
if location_name in self.restricted_names:
return defer.fail(
DirectoryException(
'Cannot delete location %s.' % location_name,
DirectoryException.OPERATION_NOT_PERMITTED))
ret = self.locations[location_name]
key = ret.dpid.as_host() + (ret.port << 48)
del self.locations[location_name]
del self.location_bindings[key]
return self._del_member_from_groups(
ret, Directory.LOCATION_PRINCIPAL,
mangle_name(self.name, location_name))
def _get_group_parents_s(self, group_type, group_name):
parent_group_dict = self.parent_groups.get(group_type)
if parent_group_dict is None:
raise DirectoryException("Invalid or unsupported group type '%s'" %
group_type)
if parent_group_dict.has_key(group_name):
return tuple(parent_group_dict[group_name])
return tuple()
def get_group(self, group_type, group_name):
group_dict = self.groups.get(group_type)
if group_dict is None:
return defer.fail(
DirectoryException("Invalid or unsupported group type '%s'" %
group_type))
if group_dict.has_key(group_name):
return defer.succeed(copy.deepcopy(group_dict[group_name]))
return defer.succeed(None)
def rename_principal(self, principal_type, old_name, new_name):
def _rename(pdict):
if pdict.has_key(new_name):
raise DirectoryException(
"Record with name '%s' already exists" % new_name,
DirectoryException.RECORD_ALREADY_EXISTS)
if not old_name in pdict:
raise DirectoryException(
"No record found with name '%s'" % old_name,
DirectoryException.NONEXISTING_NAME)
info = pdict[old_name]
del pdict[old_name]
info.name = new_name
pdict[new_name] = info
#update group membership
return self.rename_group_member(copy.copy(pdict[new_name]),
principal_type, old_name, new_name)
def _rename_switch_locations(switchinfo):
"""Rename locations with names beginning with old switch name"""
def ren_locs(loc_names):
switchname = switchinfo.name
switchinfo.locations = []
for loc_name in loc_names:
li = self.locations[loc_name]
def_name = get_default_loc_name(old_name, li.port_name)
if loc_name == def_name:
newname = get_default_loc_name(new_name, li.port_name)
self.locations.pop(loc_name)
li.name = newname
self.locations[newname] = li
li_copy = copy.deepcopy(li)
li_copy._old_name = loc_name
switchinfo.locations.append(li_copy)
else:
switchinfo.locations.append(
copy.deepcopy(self.locations[loc_name]))
return switchinfo
d = self.search_locations({'dpid': switchinfo.dpid})
d.addCallback(ren_locs)
return d
if principal_type == Directory.SWITCH_PRINCIPAL:
d = _rename(self.switches)
d.addCallback(_rename_switch_locations)
return d
elif principal_type == Directory.LOCATION_PRINCIPAL:
return _rename(self.locations)
elif principal_type == Directory.HOST_PRINCIPAL:
return _rename(self.hosts)
elif principal_type == Directory.USER_PRINCIPAL:
return _rename(self.users)
raise DirectoryException("Unsupported principal type '%s' in "
"rename_principal" % principal_type)
def search_locations(self, query):
checked = 0
locations = None
if query.has_key('name'):
name = query['name']
if self.locations.has_key(name):
locations = [self.locations[name]]
elif name in self.restricted_names and len(query) == 1:
return defer.succeed([name])
else:
locations = []
checked = checked + 1
if query.has_key('dpid'):
dpid = query['dpid']
if query.has_key('port'):
key = dpid.as_host() + (query['port'] << 48)
if self.location_bindings.has_key(key):
match = self.location_bindings[key]
if locations == None or match in locations:
locations = [match]
else:
locations = []
else:
locations = []
checked = checked + 1
else:
if locations == None:
locations = self.locations.values()
filter_list(locations, lambda location: location.dpid != dpid)
checked = checked + 1
elif query.has_key('port'):
port = query['port']
if locations == None:
locations = self.locations.values()
filter_list(locations, lambda location: location.port != port)
checked = checked + 1
if query.has_key('name_glob'):
regex_str = glob_to_regex(query['name_glob'])
regex = re.compile(regex_str)
if locations == None:
locations = self.locations.values()
filter_list(locations, lambda loc: not regex.search(loc.name))
checked = checked + 1
if checked != len(query):
raise DirectoryException('Unsupported query parameters',
DiretoryException.INVALID_QUERY)
elif locations == None:
return defer.succeed(self.locations.keys())
return defer.succeed([location.name for location in locations])
def add_location(self, location_info):
if location_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot add location - invalid name.',
DirectoryException.OPERATION_NOT_PERMITTED))
if location_info.dpid == None or location_info.port == None:
return defer.fail(
DirectoryException(
'Cannot add location - dpid and port must be set.'))
if self.locations.has_key(location_info.name):
return defer.fail(
DirectoryException(
'Cannot add location - location already exists.',
DirectoryException.RECORD_ALREADY_EXISTS))
key = location_info.dpid.as_host() + (location_info.port << 48)
if self.location_bindings.has_key(key):
return defer.fail(
DirectoryException(
'Cannot add location - dpid/port already bound.',
DirectoryException.RECORD_ALREADY_EXISTS))
if not self.switch_bindings.has_key(location_info.dpid.as_host()):
def readd_loc(res, linfo):
return self.add_location(linfo)
si = SwitchInfo(get_default_switch_name(location_info.dpid),
location_info.dpid)
d = self.add_switch(si)
d.addCallback(readd_loc, location_info)
li = copy.deepcopy(location_info)
li._fp_credentials = []
self.locations[location_info.name] = li
self.location_bindings[key] = li
return defer.succeed(copy.deepcopy(location_info))
def modify_user(self, user_info):
if not self.users.has_key(user_info.name):
return defer.fail(
DiretoryException('Cannot modify user - does '
'not exist.',
DiretoryException.NONEXISTING_NAME))
if user_info.name in self.restricted_names:
return defer.fail(
DirectoryException('Cannot modify user %s.' % user_info.name,
DirectoryException.OPERATION_NOT_PERMITTED))
old_info = self.users[user_info.name]
if hasattr(old_info, '_fp_credentials') and \
not hasattr(user_info,'_fp_credentials'):
user_info._fp_credentials = old_info._fp_credentials
self.users[user_info.name] = user_info
return defer.succeed(copy.deepcopy(user_info))
def search_switches(self, query):
checked = 0
switches = None
if query.has_key('name'):
name = query['name']
if self.switches.has_key(name):
switches = [self.switches[name]]
# FIXME
elif name in self.restricted_names and len(query) == 1:
return defer.succeed([name])
else:
switches = []
checked = checked + 1
if query.has_key('dpid'):
dpid = query['dpid']
if switches == None:
key = dpid.as_host()
if self.switch_bindings.has_key(key):
switches = [self.switch_bindings[key]]
else:
switches = []
else:
filter_list(switches, lambda switch: switch.dpid != dpid)
checked = checked + 1
if query.has_key('name_glob'):
regex_str = glob_to_regex(query['name_glob'])
regex = re.compile(regex_str)
if switches == None:
switches = self.switches.values()
filter_list(switches, lambda sw: not regex.search(sw.name))
checked = checked + 1
if checked != len(query):
raise DirectoryException('Unsupported query parameters',
DirectoryException.INVALID_QUERY)
elif switches == None:
return defer.succeed(self.switches.keys())
return defer.succeed([switch.name for switch in switches])
def put_credentials(self,
principal_type,
principal_name,
cred_list,
cred_type=None):
if cred_type == None:
cred_type = Directory_Factory.AUTHORIZED_CERT_FP
if cred_type != Directory_Factory.AUTHORIZED_CERT_FP:
raise DirectoryException(\
"simple_directory only supports '%s' credentials" \
% Directory_Factory.AUTHORIZED_CERT_FP)
def done(p_info):
return p_info._fp_credentials
def set_creds(p_info):
p_info._fp_credentials = cred_list
return self.modify_principal(principal_type, p_info)
d = self.get_principal(principal_type, principal_name)
d.addCallback(set_creds)
d.addCallback(done)
return d
def get_creds(p_info):
if p_info == None:
raise DirectoryException("get_credentials on unknown name: %s" \
% principal_name)
return p_info._fp_credentials
def search_hosts(self, query):
checked = 0
hosts = None
if query.has_key('name'):
name = query['name']
if self.hosts.has_key(name):
hosts = [self.hosts[name]]
elif name in self.restricted_names and len(query) == 1:
return defer.succeed([name])
else:
hosts = []
checked = checked + 1
if query.has_key('dpid'):
dpid = query['dpid']
if query.has_key('port'):
key = dpid.as_host() + (query['port'] << 48)
if self.host_loc_bindings.has_key(key):
match = self.host_loc_bindings[key]
if hosts == None or match in hosts:
hosts = [match]
else:
hosts = []
else:
hosts = []
checked = checked + 1
else:
if hosts == None:
hosts = self.hosts.values()
filter_list(
hosts,
self.host_netinfo_nomatch(lambda info: info.dpid == dpid))
checked = checked + 1
elif query.has_key('port'):
port = query['port']
if hosts == None:
hosts = self.hosts.values()
filter_list(
hosts,
self.host_netinfo_nomatch(lambda info: info.port == port))
checked = checked + 1
if query.has_key('dladdr'):
dladdr = query['dladdr'].hb_long()
if self.host_dl_bindings.has_key(dladdr):
match = self.host_dl_bindings[dladdr]
if hosts == None or match in hosts:
hosts = [match]
else:
hosts = []
else:
hosts = []
checked = checked + 1
if query.has_key('nwaddr'):
nwaddr = query['nwaddr']
if self.host_nw_bindings.has_key(nwaddr):
match = self.host_nw_bindings[nwaddr]
if hosts == None or match in hosts:
hosts = [match]
else:
hosts = []
else:
hosts = []
checked = checked + 1
if query.has_key('is_gateway'):
is_gway = query['is_gateway']
if hosts == None:
hosts = self.hosts.values()
filter_list(
hosts,
self.host_netinfo_nomatch(
lambda info: info.is_gateway == is_gway))
checked = checked + 1
if query.has_key('is_router'):
is_rter = query['is_router']
if hosts == None:
hosts = self.hosts.values()
filter_list(
hosts,
self.host_netinfo_nomatch(
lambda info: info.is_router == is_rter))
checked = checked + 1
if query.has_key('alias'):
alias = query['alias']
if hosts == None:
hosts = self.hosts.values()
filter_list(hosts, lambda host: alias not in host.aliases)
checked = checked + 1
if query.has_key('name_glob'):
regex_str = glob_to_regex(query['name_glob'])
regex = re.compile(regex_str)
if hosts == None:
hosts = self.hosts.values()
filter_list(hosts, lambda host: not regex.search(host.name))
checked = checked + 1
if checked != len(query):
raise DirectoryException('Unsupported query parameters',
DirectoryException.INVALID_QUERY)
elif hosts == None:
return defer.succeed(self.hosts.keys())
return defer.succeed([host.name for host in hosts])