def __del__(self):

        self.client.unbind()

    def get_groups(self):

        """Get all the groups in form of dict {group_name: group_info,...}."""

        searchFilter = "objectClass=groupOfUniqueNames"

        result = self.client.search_s(self.base_dn, ldap.SCOPE_SUBTREE,

                                      searchFilter)

        groups = {}

        for group in result:

            groups[group[1]['cn'][0]] = group[1]

        return groups

    def get_group_users(self, groups, group):

        """Returns all the users belonging to a single group.

        Based on the list of groups and memberships, returns all the

        users belonging to a single group, searching recursively.

        """

        users = []

        for member in groups[group]["uniqueMember"]:

            member = self.parse_member_string(member)

            if member[0] == "uid":

                users.append(member[1])

            elif member[0] == "cn":

                users += self.get_group_users(groups, member[1])

        return users

    def parse_member_string(self, member):

        """Parses the member string and returns a touple of type and name.

        Unique member can be either user or group. Users will have 'uid' as

        prefix while groups will have 'cn'.

        """

        member = member.split(",")[0]

        return member.split('=')

class LdapSync(object):

    def __init__(self):

        self.ldap_client = LdapClient(config.get("default", "ldap_uri"),

                                      config.get("default", "ldap_user"),

                                      config.get("default", "ldap_key"),

                                      config.get("default", "base_dn"))

    def update_groups_from_ldap(self):

        """Add all the groups from LDAP to Kallithea."""

        added = existing = 0

        groups = self.ldap_client.get_groups()

        for group in groups:

            try:

                self.kallithea_api.create_repo_group(group)

                added += 1

            except Exception:

                existing += 1

        return added, existing

    def update_memberships_from_ldap(self, group):

        """Update memberships based on the LDAP groups."""

        groups = self.ldap_client.get_groups()

        group_users = self.ldap_client.get_group_users(groups, group)

        # Delete memberships first from each group which are not part

        # of the group any more.

        members = self.kallithea_api.get_group_members(group)

        for member in members:

            if member not in group_users:

                try:

                                                         member)

                except UserNotInGroupError:

                    pass

        # Add memberships.

        for member in group_users:

            try:

                self.kallithea_api.add_membership(group, member)

            except UserAlreadyInGroupError:

                # TODO: handle somehow maybe..

                pass

if __name__ == '__main__':

    sync = LdapSync()

    print sync.update_groups_from_ldap()

    for gr in sync.ldap_client.get_groups():

        # TODO: exception when user does not exist during add membership...

        # How should we handle this.. Either sync users as well at this step,

        # or just ignore those who don't exist. If we want the second case,

        # we need to find a way to recognize the right exception (we always get

        # ResponseError with no error code so maybe by return msg (?)

        sync.update_memberships_from_ldap(gr)