Produits Entr'ouvert » ldaptools

class eo_sdist(sdist):

    def run(self):

        if os.path.exists('VERSION'):

            os.remove('VERSION')

        version = get_version()

        version_file.write(version)

        version_file.close()

        sdist.run(self)

        if os.path.exists('VERSION'):

            os.remove('VERSION')

        else:

            result = '0.0.0-%s' % len(subprocess.check_output(

                ['git', 'rev-list', 'HEAD']).splitlines())

    return '0.0.0'

                continue

            entry = idict(entry)

            if 'objectclass' in entry:

            yield dn, entry

    def __iter__(self):

import argparse

import sys

    def f(value):

        try:

            return f1(value)

            try:

                return f2(value)

                raise argparse.ArgumentTypeError('%s and %s' % (e1.args[0], e2.args[0]))

    return f

def object_class_pivot(value):

    if len(value) != 2:

        raise argparse.ArgumentTypeError('%r is not a pair of an objectClass and an attribute name')

    return value

    attributes = list(attributes)

    if not attributes:

        parser.print_help()

    if options.verbose:

    if hasattr(options.source_uri, 'read'):

        if options.verbose:

        source = ldif_utils.ListLDIFParser(options.source_uri)

        source.parse()

    else:

        if options.verbose:

        conn = paged.PagedLDAPObject(options.source_uri)

        if options.source_uri.startswith('ldapi://'):

            conn.sasl_interactive_bind_s("", ldap.sasl.external())

                                       filterstr=options.source_filter)

    if options.verbose:

    target_conn = paged.PagedLDAPObject(options.target_uri)

    if options.target_uri.startswith('ldapi://'):

        target_conn.sasl_interactive_bind_s("", ldap.sasl.external())

    synchronize.build_actions()

    if options.verbose:

        for action in synchronize.actions:

        if not synchronize.actions:

    if not options.fake:

        synchronize.apply_actions()

    failed_actions = [action for action in synchronize.actions if action.errors]

    if failed_actions:

        for action in failed_actions:

            for error in action.errors:

        raise SystemExit(1)

import ldif

from ldap.dn import dn2str

class AddError(Exception):

    pass

        dn = str2dn(dn)

        dn = [[(part[0].lower(),) + part[1:] for part in rdn] for rdn in dn]

        dn = dn2str(dn)

    def add(self, conn):

        for dn, entry in self.entries:

            try:

                raise AddError('error when adding %s' % dn, e)

    def __iter__(self):

import time

import tempfile

import shutil

import ldap

import ldap.modlist

import ldap.sasl

import atexit

from ldaptools.ldif_utils import ListLDIFParser

    process = None

    schemas = ['core', 'cosine', 'inetorgperson', 'nis', 'eduorg-200210-openldap', 'eduperson',

               'supann-2009']

    checkpoints = None

    data_dirs = None

    db_index = 1

        if context:

            ldif = ldif.format(**context)

        slapadd = self.create_process([SLAPADD_PATH, '-v', '-n%d' % db, '-F', self.config_dir])

        assert slapadd.returncode == 0, 'slapadd failed: %s' % stderr

    def start(self):

        if context:

            ldif = ldif.format(**context)

        parser.parse()

        conn = self.get_connection_admin()

        parser.add(conn)

import ldap.dn

@functools.total_ordering

        for msgid in self.msgids:

            try:

                self.results.append(conn.result2(msgid))

                self.errors.append(e)

    def __str__(self):

    order = 3

    def do(self, conn):

class Rename(Action):

    def do(self, conn):

        modlist = []

            modlist.append((ldap.MOD_REPLACE, key, values))

        self.msgids.append(conn.modify(self.dn, modlist))

    def get_pivot_attribute(self, dn, entry):

        '''Find a pivot attribute value for an LDAP entry'''

        for objc, attr in self.pivot_attributes:

                try:

                    value = entry[attr]

                except KeyError:

                    raise Exception('entry %s missing pivot attribute %s: %s' % (dn, attr, entry))

                break

        else:

        if len(value) != 1:

            raise Exception('entry %s pivot attribute %s must have only one value' % (dn, attr))

        if attr in self.case_insensitive_attribute:

    def get_target_entries(self, filterstr=None, attributes=[]):

        '''Return all target entries'''

        try:

            # Check base DN exist

            self.target_conn.search_s(self.target_dn, ldap.SCOPE_BASE)

                                                    filterstr=filterstr or self.all_filter,

                                                    attrlist=attributes)

        except ldap.NO_SUCH_OBJECT:

            return []

                    seen_dn.add(out_dn)

                    self.rename(new_out_dn, target_dn)

                    renamed_dn[str2dn(new_out_dn)] = str2dn(target_dn)

                    new_entry = {}

                    for attribute in self.attributes:

                        if attribute in to_dict_of_set(entry):

        self.actions = []

        # Order source entries by DN depth

        entries = list(self.source)

        for dn, entry in entries:

            for key in entry.keys():

                    del entry[key]

        # First create, rename and update

        for batch in batch_generator(entries, self.BATCH_SIZE):

import ldap.dn

# Copied from http://code.activestate.com/recipes/194371-case-insensitive-strings/

    Performs like str except comparisons are case insensitive."""

    def __init__(self, strMe):

        self.__lowerCaseMe = strMe.lower()

    def __repr__(self):

    def findkey(self, item):

        """A caseless way of checking if a key exists or not.

        It returns None or the correct key."""

            raise TypeError('Keywords for this object must be strings. You supplied %s' % type(item))

        key = item.lower()

        try:

    def has_key(self, item):

        """A case insensitive test for keys."""

            return False               # should never have a non-string key

        return item.lower() in self._keydict           # does the key exist

    def __contains__(self, item):

        """A case insensitive __contains__."""

            return False               # should never have a non-string key

        return item.lower() in self._keydict           # does the key exist

        return True

    def __ne__(self, other):

def batch_generator(gen, *batch_size):

def to_dict_of_set(d):

    if 'objectclass' in r:

        r['objectclass'] = set(istr(v) for v in r['objectclass'])

    return r

def str2dn(s):

    return tuple(map(tuple, ldap.dn.str2dn(s)))

import pytest

import tempfile

import os

    handle, path = tempfile.mkstemp()

    with open(path, 'w') as f:

        for attribute in attributes:

        f.flush()

    def finalize():

        os.unlink(path)

from ldaptools.ldif_utils import ListLDIFParser

def test_ldifparser():

objectClass: organization

'''))

import ldap

    conn = slapd.get_connection_admin()

    def syn_ldif(ldif):

        parser.parse()

        synchronize = Synchronize(parser, 'o=orga', conn, 'o=orga',

                                  pivot_attributes=pivot_attributes,

    conn = slapd.get_connection_admin()

    def syn_ldif(ldif):

        parser.parse()

        synchronize = Synchronize(parser, 'o=orga', conn, 'o=orga',

                                  pivot_attributes=pivot_attributes,

[tox]

toxworkdir = {env:TMPDIR:/tmp}/tox-{env:USER}/ldaptools/

[testenv]

usedevelop = true

	pytest

	pytest-cov

	pytest-random

commands =

	py.test {env:COVERAGE:} {posargs:--random tests}