BlogJava-庄周梦蝶-随笔分类-unix网络编程

Unix domain socket和memcached

dennis — Wed, 14 Oct 2009 22:12:00 GMT

    unix域协议并不是一个实际的协议族，而是在单个主机上执行客户／服务器通信的一种方法，是IPC的方法之一，特定于*nix平台。使用unix domain socket有三个好处：
1）在同一主机上，unix domain socket比一般的tcp socket快上一倍，性能因素这是一个主要原因。
2）unix domain socket可以在同一主机的不同进程之间传递文件描述符
3）较新的unix domain socket实现把客户的ID和组ID提供给服务器，可以让服务器作安全检查。

   memcached的FAQ中也提到为了安全验证，可以考虑让memcached监听unix domain socket。Memcached支持这一点，可以通过-s选项指定unix domain socket的路径名，注意，为了可移植性，尽量使用绝对路径，因为Posix标准声称给unix domain socket绑定相对路径将导致不可预计的后果，我在linux的测试是可以使用相对路径。假设我将memcached绑定到/home/dennis/memcached，可以这样启动memcached:

memcached -s /home/dennis/memcached

端口呢？没有端口了，/home/dennis/memcached这个文件你可以理解成FIFO的管道，unix domain socket的server/client通过这个管道通讯。

   libmemcached支持通过unix domain socket来访问memcached，基于libmemcached实现的client应该都可以使用这一功能。目前来看，java平台由于不支持平台相关的unix domain socket，因此无法享受memcached的这一特性。

   不过有一个开源项目通过jni支持实现了unix domain socket，这个项目称为juds。核心类就三个，使用非常简单。下载文件后，解压缩，make & make install即可。注意，Makefile中写死了JAVA_HOME，手工修改即可。看一个例子，经典的Time server:

package com.google.code.juds.test;

import java.io.IOException;

import com.google.code.juds.*;
import java.io.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TimeServer {
    public static void main(String[] args) {
        try {
            UnixDomainSocketServer server = new UnixDomainSocketServer(
                    "/home/dennis/time", UnixDomainSocket.SOCK_STREAM);
            OutputStream output = server.getOutputStream();
             Date date = new Date();
             DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            output.write(dateFormat.format(date).getBytes());
        } catch (IOException e) {
                    e.printStackTrace();
        }

    }

}

通过UnixDomainSocketServer创建server，指定类型为SOCK_STREAM，juds也支持UDP类型。client的使用如下:

        byte[] b = new byte[128];
        UnixDomainSocketClient socket = new UnixDomainSocketClient("/home/dennis/time",
                UnixDomainSocket.SOCK_STREAM);
        InputStream in = socket.getInputStream();
        in.read(b);
        System.out.println("Text received: \"" + new String(b) + "\"");
        socket.close();

显然，juds还只支持阻塞IO，考虑可进一步使用select、poll来扩展实现非阻塞IO。

最后一个例子，通过juds访问memcached的unix domain socket，简单的version协议调用：

byte[] b = new byte[128];
        UnixDomainSocketClient socket = new UnixDomainSocketClient("/home/dennis/memcached",
                UnixDomainSocket.SOCK_STREAM);
        OutputStream out = socket.getOutputStream();
        String text = "version\r\n";
        out.write(text.getBytes());
        InputStream in = socket.getInputStream();
        in.read(b);
        System.out.println("Text received: \"" + new String(b) + "\"");
        socket.close();

输出
Text received: "VERSION 1.4.1"

dennis 2009-10-15 06:12 发表评论

ACE_Select_Reactor在win32上编译的小问题

dennis — Tue, 03 Feb 2009 07:40:00 GMT

ACE_Reactor在windows上默认不是使用ACE_Select_Reactor，而是ACE_WFMO_Reactor（封装了WaitForMultipleObjects和WSAEventSelect）。如果想选择ACE_Select_Reactor，如：

ACE_Select_Reactor select_reactor;
ACE_Reactor reactor (&select_reactor);

那么VC需要启用/GR编译选项，具体做法就是在项目属性c/c++的语言一栏中启用RTTI信息即可。在选择了ACE_Select_Reactor之后，启动进程后在ProcessExplorer果然可以看到进程的TCP属性中建立了两个互连的TCP连接，用以notify的实现。

dennis 2009-02-03 15:40 发表评论

ACE Reactor的Echo Server

dennis — Tue, 03 Feb 2009 03:59:00 GMT

相对完整的修改版本

  1 /************************************************************************
  2 * @file: echo.cpp
  3 * @author: dennis
  4 * @revise: dennis  http://www.blogjava.net/killme2008
  5 *          相对完整的echo server，可以接受多个客户端连接，并且可以通过键入quit正常关闭
  6
  7 ************************************************************************/
  8
  9 #ifdef _DEBUG
10 #pragma comment (lib,"aced.lib")
11 #else
12 #pragma comment (lib,"ace.lib")
13 #endif
14
15 #include "ace/Reactor.h"
16 #include "ace/SOCK_Acceptor.h"
17 #include "ace/os.h"
18 #include "ace/Log_Msg.h"
19 #include "ace/inet_addr.h"
20 #include "ace/Thread_Manager.h"
21 #include<iostream>
22 #include<string>
23
24 #define PORT_NO 8080
25 typedef ACE_SOCK_Acceptor Acceptor;
26 //forward declaration
27 class Echo_Handler;
28
29 class Echo_Handler:public ACE_Event_Handler
30 {
31 public:
32     //construcor
33     Echo_Handler()
34     {
35     }
36     virtual ~Echo_Handler()
37     {
38     }
39     //Called back to handle any input received
40     int handle_input(ACE_HANDLE)
41     {
42         //receive the data
43         ssize_t recvBytes = peer().recv(data,12);
44         if(recvBytes <= 0)
45         {
46             ACE_DEBUG((LM_DEBUG,"%s\n","客户端断开连接"));
47             return -1;
48         }
49         data[recvBytes] = 0;
50
51         ACE_DEBUG((LM_DEBUG,"%s\n",data));
52
53
54         if(ACE_OS::strcmp(data,"q") == 0)
55         {
56             ACE_DEBUG((LM_DEBUG,"%s\n","客户端退出"));
57             peer().close();
58             return -1;
59         }
60         peer().send_n(data,recvBytes);
61         // do something with the input received.
62         //
63         // keep yourself registerd with the reator
64         return 0;
65     }
66
67     int handle_close(ACE_HANDLE h,ACE_Reactor_Mask m)
68     {
69         delete this;
70         return  0;
71     }
72
73     //Used by the reactor to determine the underlying handle
74     ACE_HANDLE get_handle()  const
75     {
76         return this->peer_.get_handle();
77     }
78
79     //Returns a reference to the underlying stream.
80     ACE_SOCK_Stream& peer()
81     {
82         return this->peer_;
83     }
84
85 private:
86     ACE_SOCK_Stream peer_;
87     char data [12];
88 };
89
90 class Echo_Accept_Handler:public ACE_Event_Handler
91 {
92 public:
93     //Constructor
94     Echo_Accept_Handler(ACE_Addr &addr)
95     {
96         this->open(addr);
97     }
98     virtual ~Echo_Accept_Handler(){}
99     //Open the peer_acceptor so it starts to "listen"
100     //for incoming clients
101     int open(ACE_Addr &addr)
102     {
103         if(peer_acceptor.open(addr)==-1)
104             ACE_ERROR_RETURN((LM_ERROR,"启动服务器错误\n"),1);
105         return 0;
106     }
107
108     //Overload the handle input method
109     int handle_input(ACE_HANDLE handle)
110     {
111         //Client has requested connection to server.
112         //Create a handler to handle the connection
113         Echo_Handler *eh;
114         ACE_NEW_RETURN(eh,Echo_Handler,-1);
115         ACE_INET_Addr cliaddr;
116         //Accept the connection "into" the Event Handler
117         if(this->peer_acceptor.accept(eh->peer(),//stream
118             &cliaddr,//remote address
119             0,//timeout
120             1) == -1)//restart if interrupted
121             ACE_DEBUG((LM_ERROR,"Error in connection \n"));
122
123         ACE_DEBUG((LM_DEBUG,"连接已经建立,来自%s\n",cliaddr.get_host_addr()));
124
125         //Register the input event handler for reading
126         ACE_Reactor::instance()->register_handler(eh,ACE_Event_Handler::READ_MASK);
127         const char* msg = "按q键使服务安全退出\r\n";
128         eh->peer().send_n(msg,strlen(msg)+1);
129         return 0;
130     }
131
132     //Used by the reactor to determine the underlying handle
133     ACE_HANDLE get_handle(void) const
134     {
135         return this->peer_acceptor.get_handle();
136     }
137     int handle_close(ACE_HANDLE h,ACE_Reactor_Mask m){
138         peer_acceptor.close();
139         delete this;
140         return 0;
141     }
142
143 private:
144     Acceptor peer_acceptor;
145 };
146 class Quit_Handler:public ACE_Event_Handler
147 {
148 public:
149     Quit_Handler(ACE_Reactor* r):ACE_Event_Handler(r){}
150     virtual int handle_exception(ACE_HANDLE)
151     {
152         ACE_DEBUG((LM_DEBUG,"停止服务器中\n"));
153         reactor()->end_reactor_event_loop();
154         return -1;
155     }
156     int handle_close(ACE_HANDLE h,ACE_Reactor_Mask m)
157     {
158         delete this;
159         return 0;
160     }
161     virtual ~Quit_Handler(){}
162 };
163 static ACE_THR_FUNC_RETURN run_events (void *arg);
164 static ACE_THR_FUNC_RETURN controller (void *arg);
165 int ACE_TMAIN(int argc,char *argv[])
166 {
167
168     ACE_Reactor* reactor=ACE_Reactor::instance();
169     if(ACE_Thread_Manager::instance()->spawn(run_events,reactor,THR_DETACHED | THR_SCOPE_SYSTEM)==-1)
170         return 1;
171     if(ACE_Thread_Manager::instance()->spawn(controller,reactor,THR_DETACHED | THR_SCOPE_SYSTEM)==-1)
172         return 1;
173     return ACE_Thread_Manager::instance()->wait();
174 }
175
176 static ACE_THR_FUNC_RETURN run_events (void *arg)
177 {
178     ACE_Reactor* reactor=ACE_static_cast(ACE_Reactor*,arg);
179     ACE_INET_Addr addr(PORT_NO);
180
181     Echo_Accept_Handler *eh=0;
182     ACE_NEW_RETURN(eh,Echo_Accept_Handler(addr),1);
183
184     ACE_Reactor::instance()->owner(ACE_OS::thr_self());
185     reactor->register_handler(eh,ACE_Event_Handler::ACCEPT_MASK);
186     ACE_Reactor::instance()->run_reactor_event_loop();
187     return 0;
188 }
189 static ACE_THR_FUNC_RETURN controller (void *arg)
190 {
191     ACE_Reactor* reactor=ACE_static_cast(ACE_Reactor*,arg);
192     Quit_Handler *quit_handler=0;
193     ACE_NEW_RETURN(quit_handler,Quit_Handler(reactor),1);
194     for(;;)
195     {
196         std::string line;
197         std::getline(std::cin,line,'\n');
198         if(line=="quit"){
199             ACE_DEBUG((LM_DEBUG,"请求停止服务器\n"));
200             reactor->notify(quit_handler);
201             break;
202         }
203     }
204     return 0;
205 }
206

dennis 2009-02-03 11:59 发表评论