importing Grid in the Demo Chat

don't see how it could work if you remove the servers from the application, to which server would the client connect to? Could you post the configuration file of the client as well?

Oh! I lost something in the file application_with_replication.xml (have changed) when I post my thread.

<server-instance template="SimpleServer" index="1"/>

is added in the node tab.

---

<icegrid>
<application name="Simple">
... ...
<node name="localhost">

<server-instance template="SimpleServer" index="1"/>
<!--
<server-instance template="SimpleServer" index="2"/>
-->
<server-instance template="Glacier2" client-endpoints="tcp -p 10005" server-endpoints="tcp"/>
</node>
</application>
</icegrid>

---

That is when i just delete a server-instance from application_with_replication.xml, it works well!

The configuration file of the client is the config.client which is in the glacier2 chat demo,I changed nothing.

config.client

---

Ice.Default.Router=Glacier2/router:tcp -p 10005 -h 192.168.1.104
Chat.Client.Router=Glacier2/router:tcp -p 10005 -h 192.168.1.104

---

The Ice::ObjectNotExistException indicates that the client setCallback request is rejected by Glacier2. This can happen if the client doesn't have an active session or is using another network connection than the one used to create the session.

What should I do.I am a beginner to ICE. I need your help so much.
Thank you!:)

Thanks,I appreciate your answers. Because my poor English, I post my whole code,actually the main code is supplyed by zeroc.I want to see my code acts as the simple demo in the IceGrid sample directory which is also supplyed by zeroc.

chat.ice

#ifndef CHAT_ICE
#define CHAT_ICE

#include <Glacier2/Session.ice>

module Demo
{

interface ChatCallback
{
    void message(string data);
};

interface ChatSession extends Glacier2::Session
{
    bool setCallback(ChatCallback* callback);
    void say(string data,string user);
};

};

#endif

ChatSessionI.h

#ifndef CHAT_SESSION_I_H
#define CHAT_SESSION_I_H

#include <Chat.h>

class ChatSessionI : public Demo::ChatSession, public IceUtil::Mutex
{
public:

    ChatSessionI(const std::string&);

    virtual bool setCallback(const Demo::ChatCallbackPrx&, const Ice::Current&);
	virtual void say(const std::string&, const std::string&,const Ice::Current&);
    virtual void destroy(const Ice::Current&);

private:

    const std::string _userId;
    Demo::ChatCallbackPrx _callback;
};

#endif

ChatSessionI.cpp

#include <Ice/Ice.h>
#include <ChatSessionI.h>
#include <list>

using namespace std;
using namespace Demo;

class ChatRoom;
typedef IceUtil::Handle<ChatRoom> ChatRoomPtr;

class ChatRoom : public IceUtil::Mutex, public IceUtil::Shared
{
public:

    static ChatRoomPtr& instance();

    void enter(const Demo::ChatCallbackPrx&);
    void leave(const Demo::ChatCallbackPrx&);
    void message(const string&) const;

private:
    
    list<Demo::ChatCallbackPrx> _members;

    static ChatRoomPtr _instance;
    static IceUtil::StaticMutex _instanceMutex;
};

ChatRoomPtr ChatRoom::_instance;
IceUtil::StaticMutex ChatRoom::_instanceMutex = ICE_STATIC_MUTEX_INITIALIZER;

ChatRoomPtr&
ChatRoom::instance()
{
... ...
}

void
ChatRoom::enter(const ChatCallbackPrx& callback)
{
... ...
}

void
ChatRoom::leave(const ChatCallbackPrx& callback)
{
... ...
}

void
ChatRoom::message(const string& data) const
{
... ...
}

ChatSessionI::ChatSessionI(const string& userId) :
    _userId(userId)
{
}

void
ChatSessionI::setCallback(const ChatCallbackPrx& callback, const Ice::Current& current)
{
... ...
}

void
ChatSessionI::say(const string& data, const Ice::Current&)
{
 ... ...
}

void
ChatSessionI::destroy(const Ice::Current& current)
{
 ... ...
}

Server.cpp

#include <Ice/Ice.h>
#include <Glacier2/PermissionsVerifier.h>
#include <ChatSessionI.h>

using namespace std;
using namespace Demo;

class ChatSessionManagerI : public Glacier2::SessionManager
{
public:

    virtual Glacier2::SessionPrx
    create(const string& userId, const Glacier2::SessionControlPrx&, const Ice::Current& current)
    {
        return Glacier2::SessionPrx::uncheckedCast(current.adapter->addWithUUID(new ChatSessionI(userId)));
    }
};

class ChatServer : public Ice::Application
{
public:

    virtual int
    run(int, char*[])
    {
        Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("ChatServer");
        
        adapter->add(new ChatSessionManagerI, communicator()->stringToIdentity("ChatSessionManager"));
        adapter->activate();
        communicator()->waitForShutdown();
        
        return EXIT_SUCCESS;
    }
};

int
main(int argc, char* argv[])
{
    ChatServer app;
    return app.main(argc, argv, "config.server");
}

Client.cpp

#include <IceUtil/IceUtil.h>
#include <Ice/Ice.h>
#include <Glacier2/Router.h>
#include <Chat.h>

using namespace std;
using namespace Demo;

class SessionPingThread : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
{
... ...
};
typedef IceUtil::Handle<SessionPingThread> SessionPingThreadPtr;

class ChatCallbackI : public ChatCallback
{
public:

    virtual void
    message(const string& data, const Ice::Current&)
    {
        cout << data << endl;
    }
};

class ChatClient : public Ice::Application
{
public:

    virtual int
    run(int argc, char* argv[])
    {

        callbackOnInterrupt();

        {
            IceUtil::Mutex::Lock sync(_mutex);
            Ice::RouterPrx defaultRouter = communicator()->getDefaultRouter();
            if(!defaultRouter)
            {
                cerr << argv[0] << ": no default router set" << endl;
                return EXIT_FAILURE;
            }
            
            _router = Glacier2::RouterPrx::checkedCast(defaultRouter);
            if(!_router)
            {
                cerr << argv[0] << ": configured router is not a Glacier2 router" << endl;
                return EXIT_FAILURE;
            }
        }

        ChatSessionPrx session;
        while(true)
        {
            cout << "This demo accepts any user-id / password combination.\n";

            string id;
            cout << "user id: " << flush;
            getline(cin, id);
            id = trim(id);

            string pw;
            cout << "password: " << flush;
            getline(cin, pw);
            pw = trim(pw);

            try
            {
                session = ChatSessionPrx::uncheckedCast(_router->createSession(id, pw));
                break;
            }
            catch(const Glacier2::PermissionDeniedException& ex)
            {
                cout << "permission denied:\n" << ex.reason << endl;
            }
        }

        {
            IceUtil::Mutex::Lock sync(_mutex);
            _ping = new SessionPingThread(session, (long)_router->getSessionTimeout() / 2);
            _ping->start();
        }

        Ice::Identity callbackReceiverIdent;
        callbackReceiverIdent.name = "callbackReceiver";
        callbackReceiverIdent.category = _router->getCategoryForClient();

        Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Chat.Client");
        ChatCallbackPrx callback = ChatCallbackPrx::uncheckedCast(
            adapter->add(new ChatCallbackI, callbackReceiverIdent));
        adapter->activate();

        session->setCallback(callback);

        menu();

        try
        {
            do
            {
                string s;
                cout << "==> ";
                getline(cin, s);
                s = trim(s);
                if(!s.empty())
                {
                    if(s[0] == '/')
                    {
                        if(s == "/quit")
                        {
                            break;
                        }
                        menu();
                    }
                    else
                    {
                        session->say(s);
                    }
                }
            }
            while(cin.good());

            cleanup();
        }
        catch(const Ice::Exception& ex)
        {
            cerr << ex << endl;
            cleanup();

            return EXIT_FAILURE;
        }
        return EXIT_SUCCESS;
    }

    virtual void
    interruptCallback(int)
    {
          ... ...
    }

private:

    void
    cleanup()
    {
           ... ...
    }

    void
    menu()
    {
        cout << "enter /quit to exit." << endl;
    }

    string
    trim(const string& s)
    {
         ... ...
    }

    IceUtil::Mutex _mutex;
    Glacier2::RouterPrx _router;
    SessionPingThreadPtr _ping;
};

int
main(int argc, char* argv[])
{
    ChatClient app;
    return app.main(argc, argv, "config.client");
}