C++博客-eXile 的专栏-随笔分类-网络开发

好玩的Go语言

eXile — Mon, 11 Jan 2010 11:48:00 GMT

     1.什么是Go语言

    Go语言是Google推出的新的一个致力于系统级的编程语言。很多人说它是 C + Python，既有c的灵活高效，又有Python的简单易用，它的原则是 Simple && Fast。它的语法规则很简单。其官方网站上有一个《三天学会Go语言》的教程，包括三部分：基本结构，面向对象，并发。一个周末的时间就差不多可以掌握其基本面貌。相对来说，第三部分“并发”似乎难接受一些。但是如果你对多线程，同步，消息队列这些东西很有经验的话，对它的概念也会容易理解。

     2.Go语言的面向对象

     Go语言在C语言语法的基础上，以最简洁的形式加入了面向对象。
    关于继承：Go语言没有继承。但是它支持嵌入，这个有点类似于其它语言的mixin，可以用来模拟继承。
    关于多态：Go 语言的最大特点是它的接口定义。所谓“接口”，就是一组方法的集合。任何一个类只要实现了一个接口的所有方法，则是该接口的实现者，不需要显式声明实现该接口。所以一个没有任何方法的空接口可以代表任何类型。

   3.Go语言的并发

     Go语言提出一个新的概念—Go例程，有点类似于线程，但是更加轻量，更省资源。Go例程之间的通信方式 ——信道，这是GO 语言的核心概念，有点类似于UNIX的Pipe。在Go语言中，不需要接触线程，锁这些低阶概念。

     4.Go语言可以用来做什么

     Go语言目前最强的是它的网络功能。它的package中已经实现了最常见的网络协议和编码处理。Go的官方网站使用的就是Go语言，实际上它就是Go的文档系统godoc。
      还没有官方对数据库支持，不过因为通过某种办法可以在Go语言中直接调用C函数，所以很容易的实现对MYSQL 或者 Sqlite 这些数据库的支持。
      至于GUI，这估计目前还不在设计者的考虑范围之内，因为他们连Windows都不舍得支持。不过可以通过它的http包和template包等等，已经构成了一个WEB框架，可以用来实现WEB GUI的开发，使用Go写一个带有路径分派的Http服务器也就几行代码的事。

eXile 2010-01-11 19:48 发表评论

[T] ICE实例学习：Let's Chat! (2) 实现服务器

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

服务器实现：

服务器使用C++。注意它的结构：类 ChatRoom 实现了大部分的应用逻辑。为了支持推模型与拉模型，服务器实现了类ChatSession 和类 PollingChatSession。 ChatRoom 调用 ChatRoomCallbackAdapter 对象的 send 函数来传递客户消息，该对象隐藏了两种模型之间的差异。

ChatRoom 实现：

ChatRoom是一个普通的C++对象，而不是一个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是一个字符串集合，它存储已经建立回话，但是还没有加入聊天室的客户名。_members存储当前聊天室的所有用户（已经调用过join函数的用户）。

成员函数 reserve 和 unreserve 维护 _reserved 集合。

// 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操作添加用户到聊天室。

// 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实现，同join实现非常类似：

// 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;
}

类 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 实现：

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的四个成员函数，当异步调用完成时，都使用类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;
};

当用户回调操作抛出异常，服务器立即销毁客户会话，即把该用户赶出聊天室。这是因为，一旦客户的回调对象出现了一次异常，它以后也就不可能再正常。

推模式会话创建：

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

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

       ChatSessionI类实现了ChatSession接口。

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;

         构造函数设置聊天室和用户名，并把_destroy设置为False.

        由于Glacier2::create操作不允许传递代理，必须把创建会话和设置回调分成两步。这是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);
}

      注意，在使用join传递代理之前，向客户代理添加了一个值为 "o" 的_fwd上下文。它提示Glacier使用单向调用来转发客户回调。这样比双向调用更加有效。因为所有的回调操作均为void返回值，所以可以单向调用。
     服务器的回调为普通的双向调用。这样当出错时可以通知服务器。当客户端出错时，这个对结束客户会话很有用。

     一旦客户调用了setCallback，就可以接收聊天室的各种行为通知。下为send实现：

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实例学习：Let's Chat! 节译 (1)

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

节译，原文地址：http://www.zeroc.com/articles/index.html

需求

      1）一个典型的聊天室应用，使用客户器/服务器架构，客户发送消息到中心服务器，然后，消息发送给其它客户。
      2）尽量减少服务器管理，甚至可以不需要。
      3）通信必须安全，通过公共网络时必须要保护个人隐私。
      4）当客户端和服务器有防火墙保护时也能正常运行，客户端不用修改它的网络或者防火墙设置。
      5）客户端可以在各种平台上利用多种语言实现，比如说利用Web浏览器作为客户端。
      6）客户端可能网络带宽有限，所以应该尽量减少网络流量。
      只支持单个聊天室。（多个聊天室只是代码多了点，并没有增加任何难度）。

设计

      在本文中，将会演示多种客户端的设计和实现。包括：
      1）C++命令行客户端；
      2）JAVA SWing GUI客户端；
      3）.NET WPF客户端；
      4）PHP网页客户端；
      5）Silverlight 网页客户端；

     注意，对于ICE3.3, PHP和Ruby只提供了客户端的Run Time。我们在考虑当连接的客户如何从服务器获得消息时，必须要想到这一点。对于消息发布，有两种通信模型：
     1）推模型：略
     2）拉模型：略
     推模型比较简单，容易实现，我们的Chat 客户端中，C++，Java, .Net, Silverlight(0.3)都使用该模型。PHP客户端使用拉模型。

推模型定义
     每个客户端中提供一个 ChatRoomCallback 类型的ICE对象到服务器。当发生事件时，服务器调用该对象的操作通知客户。SLICE定义如下：

// 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）当用户首次连接到聊天室时，服务器调用 init 操作.     users参数告诉用户目前连接到聊天室的所有用户信息。
     2）有用户连接到聊天室时，服务器调用 join 操作。
     3）有用户断开连接时，服务器调用 leave 操作。
     4）有用户发送消息时，服务器调用 send 操作。
     注意设计使用异步事件。元数据指令 ["ami"] 标明服务器异步调用回调操作。当客户端行为异常时，这对服务器是一个保护：客户端可能长时间阻塞，服务器调用期间不会因此失去对线程的控制。

与防火墙协作
      略......

      Glacer2是ICE针对这种情况的预建的解决方案，它扮演一个服务器前端。Glacer2具有以下特征：
      1）支持会话概念，API支持认证机制，可实现自定义的会话创建和认证。
      2）单个Glacer2可进行任意数量的服务器和客户端转发。服务器只要有一个端口接受外来连接，而不用管具体服务器个数。
     3）对于具有防火墙的客户端，服务器也可调用其提供的回调。

     因为 Glacer2会话概念是面向连接的，只有当客户端同Glacer2的连接打开时，更精确的说，同Glacer2保持一个激活的会话时，服务器才可以对客户进行回调。换句话说，当客户端同Glacer2失去连接，Glacer2自动销毁会话。为了阻止客户端到Glacer2的连接被意外关闭，客户端必须要禁用ACM（Automic Connection Management, 自动连接管理）。而且，Glacer2通常对长时间空闲的会话设置超时。当聊天室长时间没有动作时，为了防止Glacer2销毁会话，客户端必须周期性进行激活，比如，调用 ice_ping, 来对Glacer2的会话超时进行重置。

     Chat客户端通过服务器提供的 ChatSession接口来和服务器通信。 ChatSession 从Glacer2::Session派生。

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

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

这就是推模型，Chat客户端调用ChatSession的send来发送消息，服务器调用每一个客户的ChatRoomCallback的send操作进行分发。

拉模型定义

TODO

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

用ICE实现一个简单的聊天室

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

摘要: 聊天室是一种典型的网络应用，这个程序演示了ICE框架的基本结构。阅读全文

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

利用boost::asio实现一个简单的服务器框架

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

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

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

Reactor模式中网络事件分派探讨

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

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

　　对于使用线程池的Reactor模式，针对每一个SOCKET句柄的事件处理器handler可能被分派到不同的线程当中，这就要求handler的每一个操作都是线程安全的。
　　可以使用一种办法使一个handler的操作只能分派到一个线程中：为每一个handler设定一个线程所有者ＩＤ，一开始ＩＤ为空，则每个线程都可以分派，第一次分派之后，则设定为该线程ＩＤ，以后只分派到该线程中。这样，可以保证handler操作的单线程性，简化以后handler的具体实现。这个ＩＤ也可以灵活设置，以适应具体事务的要求。
　　但这样并不能保证handler彻底无锁，因为还会有两个线程会出现竟争，除了这个事件处理线程以外，还有事件分派线程（即事件侦听线程）。对于这个问题的解决办法如下：为每个handler设定一个原子计数，事件分派线程在分派事件前，首先设定该原子计数，若设置失败，表明此时正有其它线程在处理该handler，则并不分派该事件，而是将它置于一个pending队列中，等待以后分派。
　　还有一种简单的方法，就是将该handler直接挂起，处理完后才允许进行事件分派。

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

boost::asio示例HTTP Server类图

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

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

高性能服务器的多线程策略

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

摘要: （一）线程数量与线程池模型（二）多线程的内存池优化阅读全文

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