alltests.cpp

ICE-3.2 一个开源的中间件

        cout << "ok" << endl;
    }

    {
        cout << "testing updates with admin sessions... " << flush;
        AdminSessionPrx session1 = registry->createAdminSession("admin1", "test1");
        AdminSessionPrx session2 = registry->createAdminSession("admin2", "test2");
        
        keepAlive->add(session1);
        keepAlive->add(session2);       

        AdminPrx admin1 = session1->getAdmin();
        AdminPrx admin2 = session2->getAdmin();
        
        Ice::ObjectAdapterPtr adpt1 = communicator->createObjectAdapter("");
        ApplicationObserverIPtr appObs1 = new ApplicationObserverI("appObs1.1");
        Ice::ObjectPrx app1 = adpt1->addWithUUID(appObs1);
        NodeObserverIPtr nodeObs1 = new NodeObserverI("nodeObs1");
        Ice::ObjectPrx no1 = adpt1->addWithUUID(nodeObs1);
        adpt1->activate();
        registry->ice_getConnection()->setAdapter(adpt1);       
        session1->setObserversByIdentity(Ice::Identity(), 
                                         no1->ice_getIdentity(), 
                                         app1->ice_getIdentity(), 
                                         Ice::Identity(),
                                         Ice::Identity());
        
        Ice::ObjectAdapterPtr adpt2 = communicator->createObjectAdapterWithEndpoints("Observer2", "default");
        ApplicationObserverIPtr appObs2 = new ApplicationObserverI("appObs2");
        Ice::ObjectPrx app2 = adpt2->addWithUUID(appObs2);
        NodeObserverIPtr nodeObs2 = new NodeObserverI("nodeObs1");
        Ice::ObjectPrx no2 = adpt2->addWithUUID(nodeObs2);
        adpt2->activate();
        session2->setObservers(0,
                               NodeObserverPrx::uncheckedCast(no2), 
                               ApplicationObserverPrx::uncheckedCast(app2),
                               0,
                               0);
        
        appObs1->waitForUpdate(__FILE__, __LINE__);
        appObs2->waitForUpdate(__FILE__, __LINE__);

        int serial = appObs1->serial;
        test(serial == appObs2->serial);

        try
        {
            session1->getAdmin()->ice_ping();
        }
        catch(const Ice::LocalException&)
        {
            test(false);
        }

        try
        {
            int s = session1->startUpdate();
            test(s != serial + 1);
        }
        catch(const AccessDeniedException&)
        {
            test(false);
        }

        try
        {
            int s = session1->startUpdate();
            test(s == serial);
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }

        try
        {
            session2->startUpdate();
            test(false);
        }
        catch(const AccessDeniedException& ex)
        {
            test(ex.lockUserId == "admin1");
        }

        try
        {
            session1->finishUpdate();   
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }

        try
        {
            int s = session2->startUpdate();
            test(s == appObs2->serial);
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }

        try
        {
            ApplicationDescriptor app;
            app.name = "Application";
            admin2->addApplication(app);
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }

        try
        {
            admin1->addApplication(ApplicationDescriptor());
            test(false);
        }
        catch(const AccessDeniedException&)
        {
        }

        try
        {
            session2->finishUpdate();   
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }

        appObs1->waitForUpdate(__FILE__, __LINE__);
        appObs2->waitForUpdate(__FILE__, __LINE__);

        test(serial + 1 == appObs1->serial);
        test(serial + 1 == appObs2->serial);
        ++serial;

        try
        {
            int s = session1->startUpdate();
            test(s == serial);
            ApplicationUpdateDescriptor update;
            update.name = "Application";
            update.variables.insert(make_pair(string("test"), string("test")));
            admin1->updateApplication(update);
            session1->finishUpdate();
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

        appObs1->waitForUpdate(__FILE__, __LINE__);
        appObs2->waitForUpdate(__FILE__, __LINE__);

        test(serial + 1 == appObs1->serial);
        test(serial + 1 == appObs2->serial);
        ++serial;

        //
        // We now allow modifying the database without holding the
        // exclusive lock.
        //
//      try
//      {
//          ApplicationUpdateDescriptor update;
//          update.name = "Application";
//          admin1->updateApplication(update);
//          test(false);
//      }
//      catch(const AccessDeniedException&)
//      {
//      }

        try
        {
            int s = session2->startUpdate();
            test(s == serial);
            admin2->removeApplication("Application");
            session2->finishUpdate();
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }

        appObs1->waitForUpdate(__FILE__, __LINE__);
        appObs2->waitForUpdate(__FILE__, __LINE__);

        test(serial + 1 == appObs1->serial);
        test(serial + 1 == appObs2->serial);
        ++serial;
        
        try
        {
            int s = session1->startUpdate();
            test(s == serial);
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }
        session1->destroy();

        try
        {
            int s = session2->startUpdate();
            test(s == serial);
            session2->finishUpdate();
        }
        catch(const Ice::UserException&)
        {
            test(false);
        }
        session2->destroy();

        adpt1->destroy();
        adpt2->destroy();

        //
        // TODO: test session reaping?
        //

        cout << "ok" << endl;
    }

    {
        cout << "testing application observer... " << flush;
        AdminSessionPrx session1 = registry->createAdminSession("admin1", "test1");
        AdminPrx admin1 = session1->getAdmin();

        keepAlive->add(session1);
        
        Ice::ObjectAdapterPtr adpt1 = communicator->createObjectAdapter("");
        ApplicationObserverIPtr appObs1 = new ApplicationObserverI("appObs1.2");
        Ice::ObjectPrx app1 = adpt1->addWithUUID(appObs1);
        adpt1->activate();
        registry->ice_getConnection()->setAdapter(adpt1);       
        session1->setObserversByIdentity(Ice::Identity(), 
                                         Ice::Identity(), 
                                         app1->ice_getIdentity(),
                                         Ice::Identity(),
                                         Ice::Identity());
        
        appObs1->waitForUpdate(__FILE__, __LINE__);

        int serial = appObs1->serial;
        test(appObs1->applications.empty());

        try
        {
            ApplicationDescriptor app;
            app.name = "Application";
            int s = session1->startUpdate();
            test(s == serial);
            admin1->addApplication(app);
            appObs1->waitForUpdate(__FILE__, __LINE__);
            test(appObs1->applications.find("Application") != appObs1->applications.end());
            test(++serial == appObs1->serial);
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

        try
        {
            ApplicationUpdateDescriptor update;
            update.name = "Application";
            update.variables.insert(make_pair(string("test"), string("test")));
            admin1->updateApplication(update);
            appObs1->waitForUpdate(__FILE__, __LINE__);
            test(appObs1->applications.find("Application") != appObs1->applications.end());
            test(appObs1->applications["Application"].descriptor.variables["test"] == "test");
            test(++serial == appObs1->serial);
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

        try
        {
            ApplicationDescriptor app; 
            app = appObs1->applications["Application"].descriptor;
            app.variables.clear();
            app.variables["test1"] = "test";
            admin1->syncApplication(app);
            appObs1->waitForUpdate(__FILE__, __LINE__);
            test(appObs1->applications.find("Application") != appObs1->applications.end());
            test(appObs1->applications["Application"].descriptor.variables.size() == 1);
            test(appObs1->applications["Application"].descriptor.variables["test1"] == "test");
            test(++serial == appObs1->serial);
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

        try
        {
            admin1->removeApplication("Application");
            appObs1->waitForUpdate(__FILE__, __LINE__);
            test(appObs1->applications.empty());
            test(++serial == appObs1->serial);
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

        session1->destroy();
        adpt1->destroy();

        cout << "ok" << endl;
    }

    {
        cout << "testing adapter observer... " << flush;

        AdminSessionPrx session1 = AdminSessionPrx::uncheckedCast(registry->createAdminSession("admin1", "test1"));
        AdminPrx admin1 = session1->getAdmin();

        keepAlive->add(session1);
        
        Ice::ObjectAdapterPtr adpt1 = communicator->createObjectAdapter("");
        AdapterObserverIPtr adptObs1 = new AdapterObserverI("adptObs1");
        Ice::ObjectPrx adapter1 = adpt1->addWithUUID(adptObs1);
        adpt1->activate();
        registry->ice_getConnection()->setAdapter(adpt1);       
        session1->setObserversByIdentity(Ice::Identity(), 
                                         Ice::Identity(), 
                                         Ice::Identity(), 
                                         adapter1->ice_getIdentity(), 
                                         Ice::Identity());
        
        adptObs1->waitForUpdate(__FILE__, __LINE__); // init

        try
        {
            Ice::ObjectPrx obj = communicator->stringToProxy("dummy:tcp -p 10000");

            Ice::LocatorRegistryPrx locatorRegistry = communicator->getDefaultLocator()->getRegistry();
            locatorRegistry->setAdapterDirectProxy("DummyAdapter", obj);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter") != adptObs1->adapters.end());
            test(adptObs1->adapters["DummyAdapter"].proxy == obj);
            
            obj = communicator->stringToProxy("dummy:tcp -p 10000 -h host");
            locatorRegistry->setAdapterDirectProxy("DummyAdapter", obj);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter") != adptObs1->adapters.end());
            test(adptObs1->adapters["DummyAdapter"].proxy == obj);

            obj = communicator->stringToProxy("dummy:tcp -p 10000 -h host");
            locatorRegistry->setReplicatedAdapterDirectProxy("DummyAdapter", "DummyReplicaGroup", obj);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter") != adptObs1->adapters.end());
            test(adptObs1->adapters["DummyAdapter"].proxy == obj);
            test(adptObs1->adapters["DummyAdapter"].replicaGroupId == "DummyReplicaGroup");

            obj = communicator->stringToProxy("dummy:tcp -p 10000 -h host");
            locatorRegistry->setReplicatedAdapterDirectProxy("DummyAdapter1", "DummyReplicaGroup", obj);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter1") != adptObs1->adapters.end());
            test(adptObs1->adapters["DummyAdapter1"].proxy == obj);
            test(adptObs1->adapters["DummyAdapter1"].replicaGroupId == "DummyReplicaGroup");

            obj = communicator->stringToProxy("dummy:tcp -p 10000 -h host");
            locatorRegistry->setReplicatedAdapterDirectProxy("DummyAdapter2", "DummyReplicaGroup", obj);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter2") != adptObs1->adapters.end());
            test(adptObs1->adapters["DummyAdapter2"].proxy == obj);
            test(adptObs1->adapters["DummyAdapter2"].replicaGroupId == "DummyReplicaGroup");

            admin->removeAdapter("DummyAdapter2");
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter2") == adptObs1->adapters.end());

            admin->removeAdapter("DummyReplicaGroup");
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters["DummyAdapter"].replicaGroupId == "");