alltests.cpp

ICE-3.2 一个开源的中间件

            test(adptObs1->adapters["DummyAdapter1"].replicaGroupId == "");

            locatorRegistry->setAdapterDirectProxy("DummyAdapter", 0);
            adptObs1->waitForUpdate(__FILE__, __LINE__);
            test(adptObs1->adapters.find("DummyAdapter") == adptObs1->adapters.end());
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

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

        cout << "ok" << endl;
    }

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

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

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

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

            admin->addObjectWithType(obj, "::Dummy");
            objectObs1->waitForUpdate(__FILE__, __LINE__);
            test(objectObs1->objects.find(communicator->stringToIdentity("dummy")) != objectObs1->objects.end());
            test(objectObs1->objects[communicator->stringToIdentity("dummy")].type == "::Dummy");
            test(objectObs1->objects[communicator->stringToIdentity("dummy")].proxy == obj);
            
            obj = communicator->stringToProxy("dummy:tcp -p 10000 -h host");
            admin->updateObject(obj);
            objectObs1->waitForUpdate(__FILE__, __LINE__);
            test(objectObs1->objects.find(communicator->stringToIdentity("dummy")) != objectObs1->objects.end());
            test(objectObs1->objects[communicator->stringToIdentity("dummy")].type == "::Dummy");
            test(objectObs1->objects[communicator->stringToIdentity("dummy")].proxy == obj);

            admin->removeObject(obj->ice_getIdentity());
            objectObs1->waitForUpdate(__FILE__, __LINE__);
            test(objectObs1->objects.find(communicator->stringToIdentity("dummy")) == objectObs1->objects.end());
        }
        catch(const Ice::UserException& ex)
        {
            cerr << ex << endl;
            test(false);
        }

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

        cout << "ok" << endl;
    }

    {
//      cout << "???" << endl;

//      //
//      // Setup a descriptor to deploy a node on the node.
//      //
//      ApplicationDescriptor nodeApp;
//      nodeApp.name = "NodeApp";
//      ServerDescriptorPtr server = new ServerDescriptor();
//      server->id = "node-1";
//      server->exe = properties->getProperty("IceDir") + "/bin/icegridnode";
//      server->options.push_back("--nowarn");
//      server->pwd = ".";
//      AdapterDescriptor adapter;
//      adapter.name = "IceGrid.Node";
//      adapter.id = "IceGrid.Node.node-1";
//      adapter.registerProcess = true;
//      adapter.waitForActivation = false;
//      server->adapters.push_back(adapter);
//      addProperty(server, "IceGrid.Node.Name", "node-1");
//      addProperty(server, "IceGrid.Node.Data", properties->getProperty("TestDir") + "/db/node-1");
//      addProperty(server, "IceGrid.Node.Endpoints", "default");
//      NodeDescriptor node;
//      node.servers.push_back(server);
//      nodeApp.nodes["localnode"] = node;
        
//      try
//      {
//          int s = session1->startUpdate();
//          test(s == serial);
//          admin1->addApplication(nodeApp);
//          appObs1->waitForUpdate(__FILE__, __LINE__); // application added
//          test(appObs1->applications.find("NodeApp") != appObs1->applications.end());
//          test(++serial == appObs1->serial);
//      }
//      catch(const DeploymentException& ex)
//      {
//          cerr << ex.reason << endl;
//          test(false);
//      }
//      catch(const Ice::UserException& ex)
//      {
//          cerr << ex << endl;
//          test(false);
//      }

//      try
//      {
//          admin->startServer("node-1");
//      }
//      catch(const NodeUnreachableException& ex)
//      {
//          cerr << ex << ":\n";
//          cerr << "node = " << ex.name << endl;
//          cerr << "reason = " << ex.reason << endl;
//      }
//      appObs1->waitForUpdate(__FILE__, __LINE__); // object added (for node well-known proxy)
//      test(++serial == appObs1->serial);

//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // updateServer
//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // updateServer
//      do
//      {
//          nodeObs1->waitForUpdate(__FILE__, __LINE__); // nodeUp
//      }
//      while(nodeObs1->nodes.find("node-1") == nodeObs1->nodes.end());

//      try
//      {
//          admin->stopServer("node-1");
//      }
//      catch(const NodeUnreachableException& ex)
//      {
//          cerr << ex << ":\n";
//          cerr << "node = " << ex.name << endl;
//          cerr << "reason = " << ex.reason << endl;
//      }
//      appObs1->waitForUpdate(__FILE__, __LINE__); // object removed (for node well-known proxy)
//      test(++serial == appObs1->serial);

//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // updateServer
//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // updateServer
//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // nodeDown
//      test(nodeObs1->nodes.find("node-1") == nodeObs1->nodes.end());

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

//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Destroying)
//      nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Destroyed)

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

//      cout << "ok" << endl;
    }

    {
        cout << "testing node observer... " << flush;
        AdminSessionPrx session1 = registry->createAdminSession("admin1", "test1");
        
        keepAlive->add(session1);
        
        Ice::ObjectAdapterPtr adpt1 = communicator->createObjectAdapter("");
        ApplicationObserverIPtr appObs1 = new ApplicationObserverI("appObs1.3");
        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());
        
        appObs1->waitForUpdate(__FILE__, __LINE__);
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // init

        test(nodeObs1->nodes.find("localnode") != nodeObs1->nodes.end());
        test(appObs1->applications.empty());

        ApplicationDescriptor nodeApp;
        nodeApp.name = "NodeApp";
        ServerDescriptorPtr server = new ServerDescriptor();
        server->id = "node-1";
        server->exe = properties->getProperty("IceDir") + "/bin/icegridnode";
        server->options.push_back("--nowarn");
        server->pwd = ".";
        AdapterDescriptor adapter;
        adapter.name = "IceGrid.Node";
        adapter.id = "IceGrid.Node.node-1";
        adapter.registerProcess = true;
        adapter.serverLifetime = false;
        server->adapters.push_back(adapter);
        addProperty(server, "IceGrid.Node.Name", "node-1");
        addProperty(server, "IceGrid.Node.Data", properties->getProperty("TestDir") + "/db/node-1");
        addProperty(server, "IceGrid.Node.Endpoints", "default");
        NodeDescriptor node;
        node.servers.push_back(server);
        nodeApp.nodes["localnode"] = node;

        session->startUpdate();
        admin->addApplication(nodeApp);
        session->finishUpdate();
        appObs1->waitForUpdate(__FILE__, __LINE__);

        admin->startServer("node-1");

        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        do
        {
            nodeObs1->waitForUpdate(__FILE__, __LINE__); // nodeUp
        }
        while(nodeObs1->nodes.find("node-1") == nodeObs1->nodes.end());

        test(nodeObs1->nodes["localnode"].servers.size() == 1);
        test(nodeObs1->nodes["localnode"].servers[0].state == Active);
        admin->stopServer("node-1");

        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Deactivating)
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Inactive)
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // nodeDown
        test(nodeObs1->nodes["localnode"].servers[0].state == Inactive);

        session->startUpdate();
        admin->removeApplication("NodeApp");
        session->finishUpdate();
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Destroying)
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Destroyed)

        appObs1->waitForUpdate(__FILE__, __LINE__);
        test(nodeObs1->nodes.find("node-1") == nodeObs1->nodes.end());

        ApplicationDescriptor testApp;
        testApp.name = "TestApp";
        
        server = new ServerDescriptor();
        server->id = "Server";
        server->exe = properties->getProperty("TestDir") + "/server";
        server->pwd = ".";
        adapter.name = "Server";
        adapter.id = "ServerAdapter";
        adapter.registerProcess = true;
        adapter.serverLifetime = true;
        server->adapters.push_back(adapter);
        addProperty(server, "Server.Endpoints", "default");
        node = NodeDescriptor();
        node.servers.push_back(server);
        testApp.nodes["localnode"] = node;

        session->startUpdate();
        admin->addApplication(testApp);
        session->finishUpdate();
        appObs1->waitForUpdate(__FILE__, __LINE__);


        session->startUpdate();
        admin->startServer("Server");
        session->finishUpdate();

        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // adapterUpdate

        test(nodeObs1->nodes.find("localnode") != nodeObs1->nodes.end());
        test(nodeObs1->nodes["localnode"].servers.size() == 1);
        test(nodeObs1->nodes["localnode"].servers[0].state == Active);
        test(nodeObs1->nodes["localnode"].adapters.size() == 1);
        test(nodeObs1->nodes["localnode"].adapters[0].proxy);
        
        test(nodeObs1->nodes["localnode"].servers[0].enabled);
        admin->enableServer("Server", false);
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        test(!nodeObs1->nodes["localnode"].servers[0].enabled);
        admin->enableServer("Server", true);
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        test(nodeObs1->nodes["localnode"].servers[0].enabled);

        admin->stopServer("Server");

        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // adapterUpdate

        test(nodeObs1->nodes.find("localnode") != nodeObs1->nodes.end());
        test(nodeObs1->nodes["localnode"].servers.size() == 1);
        test(nodeObs1->nodes["localnode"].servers[0].state == Inactive);
        test(nodeObs1->nodes["localnode"].adapters.empty());

        session->startUpdate();
        admin->removeApplication("TestApp");    
        session->finishUpdate();

        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Destroying)
        nodeObs1->waitForUpdate(__FILE__, __LINE__); // serverUpdate(Destroyed)
        test(nodeObs1->nodes["localnode"].servers.empty());

        appObs1->waitForUpdate(__FILE__, __LINE__);

        cout << "ok" << endl;
    }

    {
        cout << "testing registry observer... " << flush;
        AdminSessionPrx session1 = registry->createAdminSession("admin1", "test1");
        
        keepAlive->add(session1);
        
        Ice::ObjectAdapterPtr adpt1 = communicator->createObjectAdapter("");
        ApplicationObserverIPtr appObs1 = new ApplicationObserverI("appObs1.4");
        Ice::ObjectPrx app1 = adpt1->addWithUUID(appObs1);
        RegistryObserverIPtr registryObs1 = new RegistryObserverI("registryObs1");
        Ice::ObjectPrx ro1 = adpt1->addWithUUID(registryObs1);
        adpt1->activate();
        registry->ice_getConnection()->setAdapter(adpt1);       
        session1->setObserversByIdentity(ro1->ice_getIdentity(), 
                                         Ice::Identity(),
                                         app1->ice_getIdentity(), 
                                         Ice::Identity(),
                                         Ice::Identity());
        
        appObs1->waitForUpdate(__FILE__, __LINE__);
        registryObs1->waitForUpdate(__FILE__, __LINE__); // init

        test(registryObs1->registries.find("Master") != registryObs1->registries.end());
        test(appObs1->applications.empty());

        QueryPrx query = QueryPrx::uncheckedCast(communicator->stringToProxy("IceGrid/Query"));
        Ice::ObjectProxySeq registries = query->findAllObjectsByType("::IceGrid::Registry");
        const string prefix("Registry-");
        for(Ice::ObjectProxySeq::const_iterator p = registries.begin(); p != registries.end(); ++p)
        {
            string name = (*p)->ice_getIdentity().name;
            string::size_type pos = name.find(prefix);
            if(pos != string::npos)
            {
                name = name.substr(prefix.size());
                test(registryObs1->registries.find(name) != registryObs1->registries.end());
            }
        }
        cout << "ok" << endl;
    }


    admin->stopServer("PermissionsVerifierServer");

    cout << "shutting down admin router... " << flush;
    admin->stopServer("Glacier2Admin");
    cout << "ok" << endl;

    cout << "shutting down router... " << flush;
    admin->stopServer("Glacier2");
    cout << "ok" << endl;

    keepAlive->terminate();
    keepAlive->getThreadControl().join();
    keepAlive = 0;

    session->destroy();
}