久久se精品一区二区影院,AAA级久久久精品无码片,国内精品久久久久影院亚洲

eXile — Wed, 25 Mar 2009 16:54:00 GMT

服务器实玎ͼ�

服务器��用C++。注意它的结构：�c?ChatRoom 实现了大部分的应用逻辑。�ؓ了支持推模型与拉模型�Q�服务器实现了类ChatSession 和类 PollingChatSession�?ChatRoom 调用 ChatRoomCallbackAdapter 对象�?send 函数来传递客��h��息，该对象隐藏了两种模型之间的差异�?br>
ChatRoom 实现�Q?br>
ChatRoom是一个普通的C++对象�Q�而不是一个Servant.

// C++
class ChatRoomCallbackAdapter { /*  */ };
typedef IceUtil::Handle<ChatRoomCallbackAdapter> ChatRoomCallbackAdapterPtr;

class ChatRoom : public IceUtil::Shared
{
public:
    void reserve(const string&);
    void unreserve(const string&);
    void join(const string&, const ChatRoomCallbackAdapterPtr&);
    void leave(const string&);
    Ice::Long send(const string&, const string&);

private:
    typedef map<string, ChatRoomCallbackAdapterPtr> ChatRoomCallbackMap;

    ChatRoomCallbackMap _members;
    set<string> _reserved;
    IceUtil::Mutex _mutex;
};
typedef IceUtil::Handle<ChatRoom> ChatRoomPtr;

成员_reserverd是一个字�W�串集合�Q�它存储已经建立回话�Q�但是还没有加入聊天室的客户名。_members存储当前聊天室的所有用��P��已经调用�q�join函数的用��P��?br>
成员函数 reserve �?unreserve �l�护 _reserved 集合�?/p>

// C++
void
ChatRoom::reserve(const string& name)
{
    IceUtil::Mutex::Lock sync(_mutex);
    if(_reserved.find(name) != _reserved.end() || _members.find(name) != _members.end())
    {
        throw string("The name " + name + " is already in use.");
    }
    _reserved.insert(name);
}

void
ChatRoom::unreserve(const string& name)
{
    IceUtil::Mutex::Lock sync(_mutex);
    _reserved.erase(name);
}

join操作��d��用户到聊天室�?/p>

// C++
void
ChatRoom::join(const string& name, const ChatRoomCallbackAdapterPtr& callback)
{
    IceUtil::Mutex::Lock sync(_mutex);
    IceUtil::Int64 timestamp = IceUtil::Time::now().toMilliSeconds();
    _reserved.erase(name);

    Ice::StringSeq names;
    ChatRoomCallbackMap::const_iterator q;
    for(q = _members.begin(); q != _members.end(); ++q)
    {
        names.push_back((*q).first);
    }

    callback->init(names);

    _members[name] = callback;

    UserJoinedEventPtr e = new UserJoinedEvent(timestamp, name);
    for(q = _members.begin(); q != _members.end(); ++q)
    {
        q->second->join(e);
    }
}

send实现�Q�同join实现非常�c�M��Q?/p>

// C++
Ice::Long
ChatRoom::send(const string& name, const string& message)
{
    IceUtil::Mutex::Lock sync(_mutex);
    IceUtil::Int64 timestamp = IceUtil::Time::now().toMilliSeconds();

    MessageEventPtr e = new MessageEvent(timestamp, name, message);
    for(ChatRoomCallbackMap::iterator q = _members.begin(); q != _members.end(); ++q)
    {
        q->second->send(e);
    }
    return timestamp;
}

�c?ChatRoomCallbackAdapter

// C++
class ChatRoomCallbackAdapter : public IceUtil::Shared
{
public:
    virtual void init(const Ice::StringSeq&) = 0;
    virtual void join(const UserJoinedEventPtr&) = 0;
    virtual void leave(const UserLeftEventPtr&) = 0;
    virtual void send(const MessageEventPtr&) = 0;
};

推模�?CallbackAdapter 实现�Q?

class SessionCallbackAdapter : public ChatRoomCallbackAdapter
{
public:
    SessionCallbackAdapter(const ChatRoomCallbackPrx& callback, const ChatSessionPrx& session)    : _callback(callback), _session(session)
    {
    }

    void init(const Ice::StringSeq& users)
    {
        _callback->init_async(new AMICallback<AMI_ChatRoomCallback_init>(_session), users);
    }

    void join(const UserJoinedEventPtr& e)
    {
        _callback->join_async(new AMICallback<AMI_ChatRoomCallback_join>(_session),
                              e->timestamp,
                              e->name);
    }

    void leave(const UserLeftEventPtr& e)
    {
        _callback->leave_async(new AMICallback<AMI_ChatRoomCallback_leave>(_session),
                               e->timestamp,
                               e->name);
    }

    void send(const MessageEventPtr& e)
    {
        _callback->send_async(new AMICallback<AMI_ChatRoomCallback_send>(_session),
                              e->timestamp,
                              e->name,
                              e->message);
    }

private:
    const ChatRoomCallbackPrx _callback;
    const ChatSessionPrx _session;
};

看一下SessionCallbackAdapter的四个成员函敎ͼ�当异步调用完成时�Q�都使用�c�AMICallback来接攉��知。它的定义如下：

template<class T> class AMICallback : public T
{
public:
    AMICallback(const ChatSessionPrx& session) : _session(session)
    {
    }
    virtual void ice_response()
    {
    }

    virtual void ice_exception(const Ice::Exception&)
    {
        try
        {
            _session->destroy(); // Collocated
        }
        catch(const Ice::LocalException&)
        {
        }
    }

private:
    const ChatSessionPrx _session;
};

当用户回调操作抛出异常，服务器立即销毁客户会话，��x��该用戯��天室。这是因为，一旦客��L��回调对象出现了一�ơ异常，它以后也��׃��可能再正常�?br>

推模式会话创�?/span>�Q?br>
现在来看一下会话创建。推模式的客户��用Glacier2�Q�所以要使用Glacier2的会话创建机制。Glacier2 允许用户通过提供一个Glacier2::SessionManager对象的代理来自定义会话创建机制。通过讄��Glacier2.SessionManager属性来配置Gloacier2�Q�就可以使用自己的会话管理器。会话管理器除了一个trivial构造函敎ͼ�讄��聊天室指针）�Q�只有一个操作，create�Q�Glacier2调用它来代理应用的会话创建�?create 操作必须�q�回一个会话代理（�c�d��为Glacier2::Session*�Q�。实现如下：

Glacier2::SessionPrx
ChatSessionManagerI::create(const string& name,
                            const Glacier2::SessionControlPrx&,
                            const Ice::Current& c)
{
    string vname;
    try
    {
        vname = validateName(name);
        _chatRoom->reserve(vname);
    }
    catch(const string& reason)
    {
       throw CannotCreateSessionException(reason);
    }

    Glacier2::SessionPrx proxy;
    try
    {
        ChatSessionIPtr session = new ChatSessionI(_chatRoom, vname);
        proxy = SessionPrx::uncheckedCast(c.adapter->addWithUUID(session));

        Ice::IdentitySeq ids;
        ids.push_back(proxy->ice_getIdentity());
        sessionControl->identities()->add(ids);
    }
    catch(const Ice::LocalException&)
    {
        if(proxy)
        {
            proxy->destroy();
        }
        throw CannotCreateSessionException("Internal server error");
    }
    return proxy;
}

首先调用一个简单的帮助函数 validateName, 来检查传递的用户名是否包含非法字�W�，�q�把它�{为大写，然后调用 reserver函数把它加到聊天室的_reserved集合中。我们要监视�q�些操作抛出的消息，�q�把它�{化�ؓGlacide2::CannotCreateSessionException异常�Q�即在create操作的异常规范声明的异常�?br> 接着实例化一个ChatSessionI对象�Q�见下面�Q�来创徏会话。注意这个会话��用UUID作�ؓ对象标识�Q�所以保证标识符唯一�?br> 最后，��d��q�个新创建的会话标识�Q�Gllacier2只通过它来转发�l�过�q�个会话的请求。实际上�Q?#8220;只�{发经�q�这个会话的�q�且只到�q�个会话的请�?#8221;�Q�这是一�U�安全的办法�Q�如果有恶意客户能猜出另一个客户会话的标识�Q�它也不能向别的对象发送请求（可能在除了聊天服务器之外的服务器上）。如果出错，��销毁刚创徏的会话对象，�q�样避免了资源泄霌Ӏ?br> �q�就是利用Glacier2创徏会话的全部。如果你希望使用Glacier2的认证机�Ӟ��可以讄��属性Glacier2.PermissionsVerifier为执行认证的对象代理。（Glacier2提供一个内�|�的权限验证器，NullPermissionsVerifier�Q�可以检查用户名和密码）�?br> 图：会话创徏交互图（略）

ChatSessionI�c�d��C��ChatSession接口�?br>

class ChatSessionI : public ChatSession
{
public:
    ChatSessionI(const ChatRoomPtr&, const string&);

    virtual void setCallback(const ChatRoomCallbackPrx&, const Ice::Current&);
    virtual Ice::Long send(const string&, const Ice::Current&);
    virtual void destroy(const Ice::Current&);

private:
    const ChatRoomPtr _chatRoom;
    const string _name;
    ChatRoomCallbackAdapterPtr _callback;
    bool _destroy;
    IceUtil::Mutex _mutex;
};
typedef IceUtil::Handle<ChatSessionI> ChatSessionIPtr;

         构造函数设�|�聊天室和用户名�Q��ƈ把_destroy讄��为False.

        �׃��Glacier2::create操作不允�怼�递代理，必须把创��Z��话和讄��回调分成两步。这是setCallback的实玎ͼ�

void
ChatSessionI::setCallback(const ChatRoomCallbackPrx& callback, const Ice::Current& c)
{
    IceUtil::Mutex::Lock sync(_mutex);
    if(_destroy)
    {
        throw Ice::ObjectNotExistException(__FILE__, __LINE__);
    }

    if(_callback || !callback)
    {
        return;
    }

    Ice::Context ctx;
    ctx["_fwd"] = "o";
    _callback = new SessionCallbackAdapter(callback->ice_context(ctx),
                                           ChatSessionPrx::uncheckedCast(
                                               c.adapter->createProxy(c.id)));
    _chatRoom->join(_name, _callback);
}

注意�Q�在使用join传递代理之前，向客户代理添加了一个��gؓ "o" 的_fwd上下文。它提示Glacier使用单向调用来�{发客户回调。这��h��双向调用更加有效。因为所有的回调操作均�ؓvoid�q�回��|��所以可以单向调用�?br> 服务器的回调为普通的双向调用。这样当出错时可以通知服务器。当客户端出错时�Q�这个对�l�束客户会话很有用�?br>
一旦客戯��用了setCallback�Q�就可以接收聊天室的各种行�ؓ通知。下为send实现�Q?/p>

Ice::Long
ChatSessionI::send(const string& message, const Ice::Current&)
{
    IceUtil::Mutex::Lock sync(_mutex);
    if(_destroy)
    {
        throw Ice::ObjectNotExistException(__FILE__, __LINE__);
    }
    if(!_callback)
    {
        throw InvalidMessageException("You cannot send messages until you joined the chat.");
    }
    string;
    try
    {
        msg = validateMessage(message);
    }
    catch(const string& reason)
    {
        throw InvalidMessageException(reason);
    }
    return _chatRoom->send(_name, msg);
}

客户要离开聊天室，只要调用 destory.

void
ChatSessionI::destroy(const Ice::Current& c)
{
    IceUtil::Mutex::Lock sync(_mutex);
    if(_destroy)
    {
        throw Ice::ObjectNotExistException(__FILE__, __LINE__);
    }
    try
    {
        c.adapter->remove(c.id);
        if(_callback == 0)
        {
            _chatRoom->unreserve(_name);
        }
        else
        {
            _chatRoom->leave(_name);
        }
    }
    catch(const Ice::ObjectAdapterDeactivatedException&)
    {
        // No need to clean up, the server is shutting down.
    }
    _destroy = true;
}

eXile 2009-03-26 00:54 发表评论

[T] ICE实例学习�Q�Let's Chat! 节译 (1)

eXile — Wed, 25 Mar 2009 15:52:00 GMT

节译�Q�原文地址�Q?a >http://www.zeroc.com/articles/index.html

需�?br>
      1�Q�一个典型的聊天室应用，使用客户�?服务器架构，客户发送消息到中心服务器，然后�Q�消息发送给其它客户�?br>      2�Q�尽量减��服务器��理�Q�甚臛_��以不需要�?br>      3�Q�通信必须安全�Q�通过公共�|�络时必��要保护个�h隐私�?br>      4�Q�当客户端和服务器有防火墙保护时也能正常�q�行�Q�客��L��不用修改它的�|�络或者防火墙讄��?br>      5�Q�客��L��可以在各�U��^��C��利用多种语言实现�Q�比如说利用Web��览器作为客��L��?br>      6�Q�客��L��可能�|�络带宽有限�Q�所以应该尽量减��网�l�流量�?br>      只支持单个聊天室。（多个聊天室只是代码多了点�Q��ƈ没有增加��M��隑ֺ��Q��?br>
设计

      在本文中�Q�将会演�C�多�U�客��L��的设计和实现。包括：
      1�Q�C++命��o行客��L��Q?br>      2�Q�JAVA SWing GUI客户端；
      3�Q?NET WPF客户端；
      4�Q�PHP�|�页客户端；
      5�Q�Silverlight �|�页客户端；

     注意�Q�对于ICE3.3, PHP和Ruby只提供了客户端的Run Time。我们在考虑当连接的客户如何从服务器获得消息�Ӟ��必须要想到这一炏V��对于消息发布，有两�U�通信模型�Q?br>     1�Q�推模型�Q�略
     2�Q�拉模型�Q�略
     推模型比较简单，�Ҏ��实现�Q�我们的Chat 客户端中�Q�C++�Q�Java, .Net, Silverlight(0.3)都��用该模型。PHP客户端��用拉模型�?br>
推模型定�?br>     每个客户端中提供一�?ChatRoomCallback �c�d��的ICE对象到服务器。当发生事�g�Ӟ��服务器调用该对象的操作通知客户。SLICE定义如下�Q?br>

// Slice
module Chat
{
// Implemented by clients
interface ChatRoomCallback
{
    ["ami"] void init(Ice::StringSeq users);
    ["ami"] void join(long timestamp, string name);
    ["ami"] void leave(long timestamp, string name);
    ["ami"] void send(long timestamp, string name, string message);
};
};

     1�Q�当用户首次�q�接到聊天室�Ӟ��服务器调�?init 操作.     users参数告诉用户目前�q�接到聊天室的所有用户信息�?br>     2�Q�有用户�q�接到聊天室�Ӟ��服务器调�?join 操作�?br>     3�Q�有用户断开�q�接�Ӟ��服务器调�?nbsp;leave 操作�?br>     4�Q�有用户发送消息时�Q�服务器调用 send 操作�?br>     注意设计使用异步事�g。元数据指��o ["ami"] 标明服务器异步调用回调操作。当客户端行为异常时�Q�这�Ҏ��务器是一个保护：客户端可能长旉��d��Q�服务器调用期间不会因此失去对线�E�的控制�?br>
与防火墙协作
      �?.....

      Glacer2是ICE针对�q�种情况的预建的解决�Ҏ��Q�它扮演一个服务器前端。Glacer2��h��以下特征�Q?br>      1�Q�支持会话概念，API支持认证机制�Q�可实现自定义的会话创徏和认证�?br>      2�Q�单个Glacer2可进行�Q意数量的服务器和客户端�{发。服务器只要有一个端口接受外来连接，而不用管具体服务器个数�?br>     3�Q�对于具有防火墙的客��L��Q�服务器也可调用其提供的回调�?br>
     因�ؓ Glacer2会话概念是面向连接的�Q�只有当客户端同Glacer2的连接打开�Ӟ��更精��的��_��同Glacer2保持一个激�zȝ��会话�Ӟ��服务器才可以对客戯��行回调。换句话��_��当客��L��同Glacer2失去�q�接�Q�Glacer2自动销毁会话。�ؓ了阻止客��L��到Glacer2的连接被意外关闭�Q�客��L��必须要禁用ACM�Q�Automic Connection Management, 自动�q�接��理�Q�。而且�Q�Glacer2通常寚w��旉��I�闲的会话设�|�超时。当聊天室长旉��没有动作�Ӟ��Z��防止Glacer2销毁会话，客户端必��d��期性进行激�z�，比如�Q�调�?ice_ping, 来对Glacer2的会话超时进行重�|��?br>
     Chat客户端通过服务器提供的 ChatSession接口来和服务器通信�?ChatSession 从Glacer2::Session�z��?br>

// Slice
module Chat
{
exception InvalidMessageException
{
    string reason;
};

interface ChatSession extends Glacier2::Session
{
    void setCallback(ChatRoomCallback* cb);
    ["ami"] long send(string message) throws InvalidMessageException;
};
};

�q�就是推模型�Q�Chat客户端调用ChatSession的send来发送消息，服务器调用每一个客��L��ChatRoomCallback的send操作�q�行分发�?br>
拉模型定�?br>
TODO

eXile 2009-03-25 23:52 发表评论

eXile — Sat, 03 Jan 2009 17:32:00 GMT

摘要: 聊天室是一�U�典型的�|�络应用�Q�这个程序演�C�Z��ICE框架的基本结构�?nbsp; 阅读全文

eXile 2009-01-04 01:32 发表评论

eXile — Wed, 28 May 2008 13:00:00 GMT

摘要: 利用boost::asio实现一个简单的服务器框�?nbsp; 阅读全文

eXile 2008-05-28 21:00 发表评论

eXile — Thu, 22 May 2008 07:27:00 GMT

原文地址:　http://www.shnenglu.com/eXile

　　对于使用�U�程池的Reactor模式�Q�针�Ҏ��一个SOCKET句柄的事件处理器handler可能被分�z�ֈ�不同的线�E�当中，�q�就要求handler的每一个操作都是线�E�安全的�?br>　　可以使用一�U�办法��一个handler的操作只能分�z�ֈ�一个线�E�中�Q��ؓ每一个handler讑֮�一个线�E�所有者ﾃ�Q�，一开始ﾃ�Q��ؓ�I�，则每个线�E�都可以分派�Q�第一�ơ分�z�之后，则设定�ؓ该线�E�ﾃ�Q�，以后只分�z�ֈ�该线�E�中。这��P��可以保证handler操作的单�U�程性，��化以后handler的具体实现。这个ﾃ�Q�也可以灉|��讄��Q�以适应具体事务的要求�?br>　　但这样�ƈ不能保证handler��d��无锁�Q�因��会有两个�U�程会出现竟争，除了�q�个事�g处理�U�程以外�Q�还有事件分�z��E�（即事件侦听线�E�）。对于这个问题的解决办法如下�Q��ؓ每个handler讑֮�一个原子计敎ͼ�事�g分派�U�程在分�z�事件前�Q�首先设定该原子计数�Q�若讄��p�|�Q�表明此时正有其它线�E�在处理该handler�Q�则�q�不分派该事�Ӟ��而是��它�|�于一个pending队列中，�{�待以后分派�?br> 　　�q�有一�U�简单的�Ҏ��Q�就是将该handler直接挂�v�Q�处理完后才允许�q�行事�g分派�?

eXile 2008-05-22 15:27 发表评论

boost::asio�C�Z��HTTP Server�c�d��

eXile — Tue, 06 May 2008 16:50:00 GMT

eXile 2008-05-07 00:50 发表评论

eXile — Wed, 05 Mar 2008 16:09:00 GMT

摘要: �Q�一�Q�线�E�数量与�U�程池模�?�Q�二�Q�多�U�程的内存池优化阅读全文

eXile 2008-03-06 00:09 发表评论