Python connectors.Registry类代码示例

 def test_duplicate_names(self):
     session = Registry().connect(sqlite3, ":memory:").session
     session.add_all([
         State(fsm="subscription", name="unchecked"),
         State(fsm="subscription", name="unchecked")])
     self.assertRaises(
         sqlalchemy.exc.IntegrityError, session.commit)

 def setUp(self):
     """ Populate test database"""
     session = Registry().connect(sqlite3, ":memory:").session
     session.add_all(
         State(fsm=RegistrationState.table, name=v)
         for v in RegistrationState.values)
     session.commit()

    def publish_user_membership(self):
        log = logging.getLogger(__name__ + ".publish_user_membership")
        session = Registry().connect(sqlite3, self.args.db).session
        initialise(session)
        while True:
            try:
                # Unwieldy, but left outer joins seem not to work with table
                # inheritance.
                unpublished = [
                    mship for mship in session.query(Membership).join(
                    Touch).join(State, State.name == "accepted").all()
                    if not any(isinstance(r, LDAPAttribute)
                        for c in mship.changes for r in c.resources)]

                for mship in unpublished:
                    user = mship.changes[1].actor
                    reg = next((
                        r for r in session.query(Registration).all()
                        if (r.changes[0].actor is user)), None)
                    if reg is None:
                        raise StopIteration("Failed finding registration.")

                    try:
                        uid = next(r for c in reversed(reg.changes)
                            for r in c.resources if isinstance(r, PosixUId))
                    except StopIteration:
                        continue

                    record = LDAPRecord(
                        dn={
                            ("cn={},ou=Groups,ou=jasmin2,"
                            "ou=People,o=hpc,dc=rl,dc=ac,dc=uk").format(
                            mship.organisation.name.lower() + "_vcloud-admins")
                        },
                        memberUId={uid.value},
                    )
                    msg = LDAPProxy.WriteLDAPAttribute(record, mship.uuid)
                    yield from self.ldapQ.put(msg)

                    record = LDAPRecord(
                        dn={("cn={},ou=jasmin2,"
                        "ou=People,o=hpc,dc=rl,dc=ac,dc=uk").format(uid.value)},
                        description={
                            "jvo:{}".format(mship.organisation.name.lower())
                        },
                    )
                    msg = LDAPProxy.WriteLDAPAttribute(record, mship.uuid)
                    yield from self.ldapQ.put(msg)

            except Exception as e:
                log.error(e)
            finally:
                session.close()
            
            log.debug("Waiting for {}s".format(self.args.interval))
            yield from asyncio.sleep(self.args.interval)

    def test_initialise_db(self):
        r = Registry()
        con = r.connect(sqlite3, ":memory:")
        self.assertEqual(0, con.session.query(State).count())

        n = initialise(con.session)
        self.assertNotEqual(0, n)
        self.assertGreaterEqual(n, con.session.query(State).count())

        self.assertEqual(0, initialise(con.session))

 def test_required_field(self):
     session = Registry().connect(sqlite3, ":memory:").session
     org = session.query(Organisation).one()
     mship = Membership(
         uuid=uuid.uuid4().hex,
         model=cloudhands.common.__version__,
         organisation=org)
     session.add(mship)
     self.assertRaises(
         sqlalchemy.exc.IntegrityError, session.commit)

 def test_shared_names(self):
     """ State names can be shared across FSMs """
     session = Registry().connect(sqlite3, ":memory:").session
     session.add_all([
         State(fsm="subscription", name="start"),
         State(fsm="host", name="start")])
     try:
         session.commit()
     except sqlalchemy.exc.IntegrityError as e:
         self.fail(e)

class RegistrationLifecycleTests(unittest.TestCase):

    def setUp(self):
        self.session = Registry().connect(sqlite3, ":memory:").session
        initialise(self.session)
        self.reg = Registration(
            uuid=uuid.uuid4().hex,
            model=cloudhands.common.__version__)
        self.session.add(self.reg)
        self.session.commit()

    def tearDown(self):
        Registry().disconnect(sqlite3, ":memory:")

    def test_name_unique_across_organisations(self):
        session = Registry().connect(sqlite3, ":memory:").session
        session.add(Organisation(
            name="BRANSTON", uuid=uuid.uuid4().hex))
        session.commit()
        orgs = session.query(Organisation).all()

        session.add_all((
            CatalogueItem(
                name="Blog Server",
                description="WordPress server VM",
                note=None,
                logo=None,
                organisation=orgs[0]
            ),
            CatalogueItem(
                name="Blog Server",
                description="Tumblr server VM",
                note=None,
                logo=None,
                organisation=orgs[1]
            )
        ))

        self.assertRaises(
            sqlalchemy.exc.IntegrityError, session.commit)

 def setUp(self):
     """ Populate test database"""
     session = Registry().connect(sqlite3, ":memory:").session
     session.add_all(
         State(fsm=MembershipState.table, name=v)
         for v in MembershipState.values)
     session.add(Organisation(
         uuid=uuid.uuid4().hex,
         name="TestOrg"))
     session.add(User(handle="newuser", uuid=uuid.uuid4().hex))
     session.commit()

 def setUp(self):
     self.session = Registry().connect(sqlite3, ":memory:").session
     initialise(self.session)
     self.org = Organisation(
         uuid=uuid.uuid4().hex,
         name="TestOrg")
     adminMp = Membership(
         uuid=uuid.uuid4().hex,
         model=cloudhands.common.__version__,
         organisation=self.org,
         role="admin")
     userMp = Membership(
         uuid=uuid.uuid4().hex,
         model=cloudhands.common.__version__,
         organisation=self.org,
         role="user")
     self.admin = User(handle="Administrator", uuid=uuid.uuid4().hex)
     self.user = User(handle="User", uuid=uuid.uuid4().hex)
     self.guestAddr = "[email protected]"
     active = self.session.query(MembershipState).filter(
         MembershipState.name == "active").one()
     adminMp.changes.append(
         Touch(
             artifact=adminMp, actor=self.admin, state=active,
             at=datetime.datetime.utcnow())
         )
     userMp.changes.append(
         Touch(
             artifact=userMp, actor=self.user, state=active,
             at=datetime.datetime.utcnow())
         )
     self.session.add_all(
         (self.admin, self.user, adminMp, userMp, self.org))
     self.session.commit()

 def setUp(self):
     self.session = Registry().connect(sqlite3, ":memory:").session
     initialise(self.session)
     self.reg = Registration(
         uuid=uuid.uuid4().hex,
         model=cloudhands.common.__version__)
     self.session.add(self.reg)
     self.session.commit()

    def publish_uidnumber(self):
        log = logging.getLogger(__name__ + ".uidnumber")
        session = Registry().connect(sqlite3, self.args.db).session
        initialise(session)
        actor = session.query(Component).filter(
            Component.handle=="identity.controller").one()
        while True:
            try:
                unpublished = [
                    r for r in session.query(Registration).all() if (
                    r.changes[-1].state.name ==
                    "user_posixaccount")]

                for reg in unpublished:
                    resources = [r for c in reversed(reg.changes)
                                 for r in c.resources]

                    emailAddr = next(i for i in resources
                                     if isinstance(i, EmailAddress))
                    uid = next(i for i in resources if isinstance(i, PosixUId))
                    uidNumber = next(i for i in resources
                                     if isinstance(i, PosixUIdNumber))
                    record = LDAPRecord(
                        dn={("cn={},ou=jasmin2,"
                        "ou=People,o=hpc,dc=rl,dc=ac,dc=uk").format(uid.value)},
                        objectclass={"posixAccount"},
                        uid={uid.value},
                        uidNumber={uidNumber.value},
                        gidNumber={uidNumber.value},
                        gecos={"{} <{}>".format(uid.value, emailAddr.value)},
                        homeDirectory={
                            self.config.get(
                                "mount", "home", fallback="/home/{}"
                            ).format(uid.value)
                        },
                        loginShell={"/bin/bash"},
                    )
                    log.debug(record)
                    msg = LDAPProxy.WriteUIdNumber(record, reg.uuid)
                    yield from self.ldapQ.put(msg)
                    session.expire(reg)
            except Exception as e:
                log.error(e)
            finally:
                log.debug("Waiting for {}s".format(self.args.interval))
                yield from asyncio.sleep(self.args.interval)

class SubscriptionLifecycleTests(unittest.TestCase):

    def setUp(self):
        self.session = Registry().connect(sqlite3, ":memory:").session
        initialise(self.session)
        self.org = Organisation(
            uuid=uuid.uuid4().hex,
            name="TestOrg")
        self.providers = [
            Provider(uuid=uuid.uuid4().hex, name="JASMIN private DC"),
            Provider(uuid=uuid.uuid4().hex, name="JASMIN burst partner"),
        ]
        self.session.add_all([self.org] + self.providers)
        self.session.commit()

    def tearDown(self):
        Registry().disconnect(sqlite3, ":memory:")

    def publish_uuid(self):
        log = logging.getLogger(__name__ + ".uuid")
        session = Registry().connect(sqlite3, self.args.db).session
        initialise(session)
        actor = session.query(Component).filter(
            Component.handle=="identity.controller").one()
        while True:
            try:
                unpublished = [
                    r for r in session.query(Registration).all() if (
                    r.changes[-1].state.name ==
                    "pre_user_inetorgperson_dn")]

                for reg in unpublished:
                    # TODO: Get latest PosixUId resource
                    try:
                        uid = next(r for c in reversed(reg.changes)
                            for r in c.resources if isinstance(r, PosixUId))
                    except StopIteration:
                        continue
                    log.debug(uid)
                    user = reg.changes[0].actor
                    surname = user.surname or "UNKNOWN"
                    record = LDAPRecord(
                        dn={("cn={},ou=jasmin2,"
                        "ou=People,o=hpc,dc=rl,dc=ac,dc=uk").format(reg.uuid)},
                        objectclass={"top", "person", "organizationalPerson",
                            "inetOrgPerson"},
                        description={"cluster:jasmin-login"},
                        cn={reg.uuid},
                        sn={surname},
                    )
                    resources = [
                        r for i in reg.changes for r in i.resources
                        if isinstance(r, EmailAddress)]
                    if resources:
                        record["mail"].add(resources[0].value)
                    msg = LDAPProxy.WriteCommonName(record, reg.uuid)
                    yield from self.ldapQ.put(msg)
                    session.expire(reg)
            except Exception as e:
                log.error(e)
            finally:
                log.debug("Waiting for {}s".format(self.args.interval))
                yield from asyncio.sleep(self.args.interval)

    def test_connect_and_disconnect(self):
        r = Registry()
        self.assertEqual(0, len(list(r.items)))
        con = r.connect(sqlite3, ":memory:")
        self.assertEqual(1, len(list(r.items)))

        dup = r.connect(sqlite3, ":memory:")
        self.assertIs(con.engine, dup.engine)
        self.assertEqual(1, len(list(r.items)))

        dis = r.disconnect(sqlite3, ":memory:")
        self.assertEqual(0, len(list(r.items)))
        self.assertIs(dup.engine, dis.engine)
        self.assertIs(None, dis.session)

        dup = r.connect(sqlite3, ":memory:")
        self.assertIsNot(con.engine, dup.engine)
        self.assertEqual(1, len(list(r.items)))