Merge pull request #135 from cloudwu/dev

release v0.4.2

.gitignore

@@ -1,9 +1,10 @@
 *.o
 *.a
-skynet
+/skynet
+/skynet.pid
 3rd/lua/lua
 3rd/lua/luac
-cservice
+/cservice
-luaclib
+/luaclib
 *.so
 *.dSYM

HISTORY.md

@@ -0,0 +1,91 @@
+v0.4.2 (2014-7-14)
+-----------
+* Bugfix : invalid negative socket id 
+* Add optional TCP_NODELAY support
+* Add worker thread weight
+* Add skynet.queue
+* Bugfix: socketchannel
+* cluster can throw error
+* Add readline and writeline to clientsocket lib
+* Add cluster.reload to reload config file
+* Add datacenter.wait
+
+v0.4.1 (2014-7-7)
+-----------
+* Add SERVICE_NAME in loader
+* Throw error back when skynet.error
+* Add skynet.task
+* Bugfix for last version (harbor service bugs)
+
+v0.4.0 (2014-6-30)
+-----------
+* Optimize redis driver `compose_message`.
+* Add module skynet.harbor for monitor harbor connect/disconnect, see test/testharborlink.lua .
+* cluster.open support cluster name.
+* Add new api skynet.packstring , and skynet.unpack support lua string
+* socket.listen support put port into address. (address:port)
+* Redesign harbor/master/dummy, remove lots of C code and rewite in lua.
+* Remove block connect api, queue sending message during connecting now.
+* Add skynet.time()
+
+v0.3.2 (2014-6-23)
+----------
+* Bugfix : cluster (double free).
+* Add socket.header() to decode big-endian package header (and fix the bug in cluster).
+
+v0.3.1 (2014-6-16)
+-----------
+* Bugfix: lua mongo driver . Hold reply string before decode bson data.
+* More check in bson decoding.
+* Use big-endian for encoding bson objectid.
+
+v0.3.0 (2014-6-2)
+-----------
+* Add cluster support
+* Add single node mode
+* Add daemon mode
+* Bugfix: update lua-bson (signed 32bit int bug / check string length)
+* Optimize timer
+* Simplify message queue and optimize message dispatch
+* Use jemalloc release 3.6.0
+
+v0.2.1 (2014-5-19)
+-----------
+* Bugfix: check all the events already read after socket close
+* Bugfix: socket data in gate service 
+* Bugfix: boundary problem in harbor service
+* Bugfix: stdin handle is 0
+
+v0.2.0 (2014-5-12)
+-----------
+
+* Rewrite malloc hook , use `pthread_getspecific` instead of `__thread` to get current service handle.
+* Optimize global unique service query, rewrite `service_mgr` .
+* Add some snax api, snax.uniqueservice (etc.) , use independent protocol `PTYPE_SNAX` .
+* Add bootstrap lua script , remove some code in C .
+* Use a lua loader to load lua service code (and set the lua environment), remove some code in C.
+* Support preload a file before each lua serivce start.
+* Add datacenter serivce.
+* Add multicast api.
+* Remove skynet.blockcall , simplify the implement of message queue.
+* When dropping message queue (at service exit) , dispatcher will post an error back to the source of each message.
+* Remove skynet.watch , monitor is not necessary for watching skynet.call . so simplemonitor.lua is move to examples.
+* Remove the limit of global queue size (64K actived service limit before).
+* Refactoring `skynet_command`.
+
+v0.1.1 (2014-4-28)
+------------------
+
+* Socket channel should clear request queue when reconnect.
+* Fix the issue that socket close may block the coroutine.
+* Fix the issue that jemalloc api may crash on macosx (disable jemalloc on macosx).
+
+v0.1.0 (2014-4-23)
+------------------
+
+* First release version.
+
+First public version (2012-8-1)
+------------------
+
+* Make skynet from a private project to public.

Makefile

@@ -22,8 +22,11 @@ JEMALLOC_STATICLIB := 3rd/jemalloc/lib/libjemalloc_pic.a
 JEMALLOC_INC := 3rd/jemalloc/include/jemalloc
 
 all : jemalloc
+	
 .PHONY : jemalloc
 
+MALLOC_STATICLIB := $(JEMALLOC_STATICLIB)
+
 $(JEMALLOC_STATICLIB) : 3rd/jemalloc/Makefile
 	cd 3rd/jemalloc && $(MAKE) CC=$(CC) 
 
@@ -33,25 +36,27 @@ $(JEMALLOC_STATICLIB) : 3rd/jemalloc/Makefile
 3rd/jemalloc/Makefile : | 3rd/jemalloc/autogen.sh
 	cd 3rd/jemalloc && ./autogen.sh --with-jemalloc-prefix=je_ --disable-valgrind
 
-jemalloc : $(JEMALLOC_STATICLIB)
+jemalloc : $(MALLOC_STATICLIB)
 
 # skynet
 
-CSERVICE = snlua logger gate master harbor
+CSERVICE = snlua logger gate harbor
-LUA_CLIB = skynet socketdriver int64 bson mongo md5 netpack cjson clientsocket memory profile
+LUA_CLIB = skynet socketdriver int64 bson mongo md5 netpack \
+  cjson clientsocket memory profile multicast \
+  cluster
 
 SKYNET_SRC = skynet_main.c skynet_handle.c skynet_module.c skynet_mq.c \
   skynet_server.c skynet_start.c skynet_timer.c skynet_error.c \
   skynet_harbor.c skynet_env.c skynet_monitor.c skynet_socket.c socket_server.c \
-  malloc_hook.c
+  malloc_hook.c skynet_daemon.c
 
 all : \
   $(SKYNET_BUILD_PATH)/skynet \
   $(foreach v, $(CSERVICE), $(CSERVICE_PATH)/$(v).so) \
   $(foreach v, $(LUA_CLIB), $(LUA_CLIB_PATH)/$(v).so) 
 
-$(SKYNET_BUILD_PATH)/skynet : $(foreach v, $(SKYNET_SRC), skynet-src/$(v)) $(LUA_LIB) $(JEMALLOC_STATICLIB)
+$(SKYNET_BUILD_PATH)/skynet : $(foreach v, $(SKYNET_SRC), skynet-src/$(v)) $(LUA_LIB) $(MALLOC_STATICLIB)
-	$(CC) $(CFLAGS) -o $@ $^ -Iskynet-src -I$(JEMALLOC_INC) $(LDFLAGS) $(EXPORT) $(LIBS)
+	$(CC) $(CFLAGS) -o $@ $^ -Iskynet-src -I$(JEMALLOC_INC) $(LDFLAGS) $(EXPORT) $(SKYNET_LIBS) $(SKYNET_DEFINES)
 
 $(LUA_CLIB_PATH) :
 	mkdir $(LUA_CLIB_PATH)
@@ -61,7 +66,7 @@ $(CSERVICE_PATH) :
 
 define CSERVICE_TEMP
   $$(CSERVICE_PATH)/$(1).so : service-src/service_$(1).c | $$(CSERVICE_PATH)
-	$(CC) $$(CFLAGS) $$(SHARED) $$< -o $$@ -Iskynet-src
+	$$(CC) $$(CFLAGS) $$(SHARED) $$< -o $$@ -Iskynet-src
 endef
 
 $(foreach v, $(CSERVICE), $(eval $(call CSERVICE_TEMP,$(v))))
@@ -88,7 +93,7 @@ $(LUA_CLIB_PATH)/netpack.so : lualib-src/lua-netpack.c | $(LUA_CLIB_PATH)
 	$(CC) $(CFLAGS) $(SHARED) $^ -Iskynet-src -o $@ 
 
 $(LUA_CLIB_PATH)/cjson.so : | $(LUA_CLIB_PATH)
-	cd 3rd/lua-cjson && $(MAKE) LUA_INCLUDE_DIR=../../$(LUA_INC) CC=$(CC) CJSON_LDFLAGS="$(SHARED)" && cp cjson.so ../../$@
+	cd 3rd/lua-cjson && $(MAKE) LUA_INCLUDE_DIR=../../$(LUA_INC) CC=$(CC) CJSON_LDFLAGS="$(SHARED)" && cd ../.. && cp 3rd/lua-cjson/cjson.so $@
 
 $(LUA_CLIB_PATH)/clientsocket.so : lualib-src/lua-clientsocket.c | $(LUA_CLIB_PATH)
 	$(CC) $(CFLAGS) $(SHARED) $^ -o $@ -lpthread
@@ -99,6 +104,12 @@ $(LUA_CLIB_PATH)/memory.so : lualib-src/lua-memory.c | $(LUA_CLIB_PATH)
 $(LUA_CLIB_PATH)/profile.so : lualib-src/lua-profile.c | $(LUA_CLIB_PATH)
 	$(CC) $(CFLAGS) $(SHARED) $^ -o $@ 
 
+$(LUA_CLIB_PATH)/multicast.so : lualib-src/lua-multicast.c | $(LUA_CLIB_PATH)
+	$(CC) $(CFLAGS) $(SHARED) -Iskynet-src $^ -o $@ 
+
+$(LUA_CLIB_PATH)/cluster.so : lualib-src/lua-cluster.c | $(LUA_CLIB_PATH)
+	$(CC) $(CFLAGS) $(SHARED) -Iskynet-src $^ -o $@ 
+
 clean :
 	rm -f $(SKYNET_BUILD_PATH)/skynet $(CSERVICE_PATH)/*.so $(LUA_CLIB_PATH)/*.so
 

README.md

@@ -1,9 +1,9 @@
 ## Build
 
-Install autoconf first for jemalloc
+For linux, install autoconf first for jemalloc
 
 ```
-git clone git@github.com:cloudwu/skynet.git
+git clone https://github.com/cloudwu/skynet.git
 cd skynet
 make 'PLATFORM'  # PLATFORM can be linux, macosx, freebsd now
 ```
@@ -15,6 +15,8 @@ export PLAT=linux
 make
 ```
 
+For freeBSD , use gmake instead of make .
+
 ## Test
 
 Run these in different console
@@ -36,5 +38,4 @@ You can also use the offical lua version , edit the makefile by yourself .
 
 * http://blog.codingnow.com/2012/09/the_design_of_skynet.html
 * http://blog.codingnow.com/2012/08/skynet.html
-* http://blog.codingnow.com/2012/08/skynet_harbor_rpc.html
 * http://blog.codingnow.com/eo/skynet/

examples/agent.lua

@@ -8,7 +8,7 @@ local CMD = {}
 local client_fd
 
 local function send_client(v)
-	socket.write(client_fd, netpack.pack(jsonpack.pack(0,v)))
+	socket.write(client_fd, netpack.pack(jsonpack.pack(0, {true, v})))
 end
 
 local function response_client(session,v)

examples/client.lua

@@ -39,7 +39,7 @@ end
 
 while true do
 	dispatch()
-	local cmd = socket.readline()
+	local cmd = socket.readstdin()
 	if cmd then
 		local args = {}
 		string.gsub(cmd, '[^ ]+', function(v) table.insert(args, v) end )

examples/cluster1.lua

@@ -0,0 +1,9 @@
+local skynet = require "skynet"
+local cluster = require "cluster"
+
+skynet.start(function()
+	skynet.newservice("simpledb")
+	print(skynet.call("SIMPLEDB", "lua", "SET", "a", "foobar"))
+	print(skynet.call("SIMPLEDB", "lua", "GET", "a"))
+	cluster.open "db"
+end)

examples/cluster2.lua

@@ -0,0 +1,6 @@
+local skynet = require "skynet"
+local cluster = require "cluster"
+
+skynet.start(function()
+	print(cluster.call("db", "SIMPLEDB", "GET", "a"))
+end)

examples/clustername.lua

@@ -0,0 +1 @@
+db = "127.0.0.1:2528"

examples/config

@@ -4,8 +4,12 @@ logger = nil
 harbor = 1
 address = "127.0.0.1:2526"
 master = "127.0.0.1:2013"
-start = "main"
+start = "main"	-- main script
+bootstrap = "snlua bootstrap"	-- The service for bootstrap
 standalone = "0.0.0.0:2013"
 luaservice = root.."service/?.lua;"..root.."test/?.lua;"..root.."examples/?.lua"
+lualoader = "lualib/loader.lua"
+-- preload = "./examples/preload.lua"	-- run preload.lua before every lua service run
 snax = root.."examples/?.lua;"..root.."test/?.lua"
 cpath = root.."cservice/?.so"
+-- daemon = "./skynet.pid"

examples/config.c1

@@ -0,0 +1,9 @@
+thread = 8
+logger = nil
+harbor = 0
+start = "cluster1"
+bootstrap = "snlua bootstrap"	-- The service for bootstrap
+luaservice = "./service/?.lua;./test/?.lua;./examples/?.lua"
+lualoader = "lualib/loader.lua"
+cpath = "./cservice/?.so"
+cluster = "./examples/clustername.lua"

examples/config.c2

@@ -0,0 +1,9 @@
+thread = 8
+logger = nil
+harbor = 0
+start = "cluster2"
+bootstrap = "snlua bootstrap"	-- The service for bootstrap
+luaservice = "./service/?.lua;./test/?.lua;./examples/?.lua"
+lualoader = "lualib/loader.lua"
+cpath = "./cservice/?.so"
+cluster = "./examples/clustername.lua"

examples/config.mc

@@ -0,0 +1,14 @@
+root = "./"
+thread = 8
+logger = nil
+harbor = 2
+address = "127.0.0.1:2527"
+master = "127.0.0.1:2013"
+start = "testmulticast2"	-- main script
+bootstrap = "snlua bootstrap"	-- The service for bootstrap
+--standalone = "0.0.0.0:2013"
+luaservice = root.."service/?.lua;"..root.."test/?.lua;"..root.."examples/?.lua"
+lualoader = "lualib/loader.lua"
+-- preload = "./examples/preload.lua"	-- run preload.lua before every lua service run
+snax = root.."examples/?.lua;"..root.."test/?.lua"
+cpath = root.."cservice/?.so"

examples/config_log

@@ -7,3 +7,4 @@ address = "127.0.0.1:2527"
 master = "127.0.0.1:2013"
 start = "main_log"
 luaservice ="./service/?.lua;./test/?.lua;./examples/?.lua"
+snax = "./examples/?.lua;./test/?.lua"

examples/globallog.lua

@@ -1,8 +1,8 @@
 local skynet = require "skynet"
 
 skynet.start(function()
-	skynet.dispatch("text", function(session, address, text)
+	skynet.dispatch("lua", function(session, address, ...)
-		print("[GLOBALLOG]", skynet.address(address),text)
+		print("[GLOBALLOG]", skynet.address(address), ...)
 	end)
 	skynet.register "LOG"
 end)

examples/main.lua

@@ -4,16 +4,15 @@ local max_client = 64
 
 skynet.start(function()
 	print("Server start")
-	local service = skynet.newservice("service_mgr")
-	skynet.monitor "simplemonitor"
 	local console = skynet.newservice("console")
---	skynet.newservice("debug_console",8000)
+	skynet.newservice("debug_console",8000)
 	skynet.newservice("simpledb")
 	local watchdog = skynet.newservice("watchdog")
 	skynet.call(watchdog, "lua", "start", {
 		port = 8888,
 		maxclient = max_client,
 	})
+	print("Watchdog listen on ", 8888)
 
 	skynet.exit()
 end)

examples/main_log.lua

@@ -2,7 +2,6 @@ local skynet = require "skynet"
 
 skynet.start(function()
 	print("Log server start")
-	local service = skynet.newservice("service_mgr")
 	skynet.monitor "simplemonitor"
 	local log = skynet.newservice("globallog")
 	skynet.exit()

examples/preload.lua

@@ -0,0 +1,5 @@
+-- This file will execute before every lua service start
+-- See config
+
+print("PRELOAD", ...)
+

examples/simplemonitor.lua

@@ -12,11 +12,10 @@ skynet.register_protocol {
 		local w = service_map[address]
 		if w then
 			for watcher in pairs(w) do
-				skynet.send(watcher, "error", address)
+				skynet.redirect(watcher, address, "error", 0, "")
 			end
 			service_map[address] = false
 		end
-		print(string.format("[:%x] exit", address))
 	end
 }
 

examples/watchdog.lua

@@ -33,6 +33,7 @@ function SOCKET.data(fd, msg)
 end
 
 function CMD.start(conf)
+	skynet.call(gate, "lua", "nodelay", true)
 	skynet.call(gate, "lua", "open" , conf)
 end
 

lualib-src/lua-bson.c

@@ -1,5 +1,3 @@
-#include "skynet_malloc.h"
-
 #include <lua.h>
 #include <lauxlib.h>
 
@@ -70,10 +68,17 @@ struct bson_reader {
 	int size;
 };
 
+static inline int32_t
+get_length(const uint8_t * data) {
+	const uint8_t * b = (const uint8_t *)data;
+	int32_t len = b[0] | b[1]<<8 | b[2]<<16 | b[3]<<24;
+	return len;
+}
+
 static inline void
 bson_destroy(struct bson *b) {
 	if (b->ptr != b->buffer) {
-		skynet_free(b->ptr);
+		free(b->ptr);
 	}
 }
 
@@ -93,10 +98,10 @@ bson_reserve(struct bson *b, int sz) {
 	} while (b->cap <= b->size + sz);
 
 	if (b->ptr == b->buffer) {
-		b->ptr = skynet_malloc(b->cap);
+		b->ptr = malloc(b->cap);
 		memcpy(b->ptr, b->buffer, b->size);
 	} else {
-		b->ptr = skynet_realloc(b->ptr, b->cap);
+		b->ptr = realloc(b->ptr, b->cap);
 	}
 }
 
@@ -258,13 +263,13 @@ append_key(struct bson *bs, int type, const char *key, size_t sz) {
 
 static void
 append_number(struct bson *bs, lua_State *L, const char *key, size_t sz) {
-	lua_Integer i = lua_tointeger(L, -1);
+	int64_t i = lua_tointeger(L, -1);
 	lua_Number d = lua_tonumber(L,-1);
 	if (i != d) {
 		append_key(bs, BSON_REAL, key, sz);
 		write_double(bs, d);
 	} else {
-		int si = (int64_t)i >> 32;
+		int si = i >> 31;
 		if (si == 0 || si == -1) {
 			append_key(bs, BSON_INT32, key, sz);
 			write_int32(bs, i);
@@ -459,7 +464,7 @@ pack_dict(lua_State *L, struct bson *b, bool isarray) {
 }
 
 static void
-pack_sorted_dict(lua_State *L, struct bson *b, int n) {
+pack_ordered_dict(lua_State *L, struct bson *b, int n) {
 	int length = reserve_length(b);
 	int i;
 	for (i=0;i<n;i+=2) {
@@ -534,6 +539,9 @@ unpack_dict(lua_State *L, struct bson_reader *br, bool array) {
 			break;
 		case BSON_STRING: {
 			int sz = read_int32(L, &t);
+			if (sz <= 0) {
+				luaL_error(L, "Invalid bson string , length = %d", sz);
+			}
 			lua_pushlstring(L, read_bytes(L, &t, sz), sz-1);
 			break;
 		}
@@ -643,7 +651,7 @@ static int
 lmakeindex(lua_State *L) {
 	int32_t *bson = luaL_checkudata(L,1,"bson");
 	const uint8_t * start = (const uint8_t *)bson;
-	struct bson_reader br = { start+4, *bson - 5 };
+	struct bson_reader br = { start+4, get_length(start) - 5 };
 	lua_newtable(L);
 
 	for (;;) {
@@ -806,6 +814,9 @@ lreplace(lua_State *L) {
 		write_int64(&b, i);
 		break;
 	}
+	default:
+		luaL_error(L, "Can't replace type %d", type);
+		break;
 	}
 	return 0;
 }
@@ -816,7 +827,9 @@ ldecode(lua_State *L) {
 	if (data == NULL) {
 		return 0;
 	}
-	struct bson_reader br = { (const uint8_t *)data , *data };
+	const uint8_t * b = (const uint8_t *)data;
+	int32_t len = get_length(b);
+	struct bson_reader br = { b , len };
 
 	unpack_dict(L, &br, false);
 
@@ -865,7 +878,7 @@ lencode_order(lua_State *L) {
 	if (n%2 != 0) {
 		return luaL_error(L, "Invalid ordered dict");
 	}
-	pack_sorted_dict(L, &b, n);
+	pack_ordered_dict(L, &b, n);
 	lua_settop(L,1);
 	void * ud = lua_newuserdata(L, b.size);
 	memcpy(ud, b.ptr, b.size);
@@ -1136,14 +1149,14 @@ lobjectid(lua_State *L) {
 		}
 	} else {
 		time_t ti = time(NULL);
-		oid[2] = ti & 0xff;
+		oid[2] = (ti>>24) & 0xff;
-		oid[3] = (ti>>8) & 0xff;
+		oid[3] = (ti>>16) & 0xff;
-		oid[4] = (ti>>16) & 0xff;
+		oid[4] = (ti>>8) & 0xff;
-		oid[5] = (ti>>24) & 0xff;
+		oid[5] = ti & 0xff;
 		memcpy(oid+6 , oid_header, 5);
-		oid[11] = oid_counter & 0xff; 
+		oid[11] = (oid_counter>>16) & 0xff; 
 		oid[12] = (oid_counter>>8) & 0xff; 
-		oid[13] = (oid_counter>>16) & 0xff; 
+		oid[13] = oid_counter & 0xff; 
 		++oid_counter;
 	}
 	lua_pushlstring( L, (const char *)oid, 14);
@@ -1190,3 +1203,4 @@ luaopen_bson(lua_State *L) {
 
 	return 1;
 }
+

lualib-src/lua-clientsocket.c

@@ -125,14 +125,19 @@ _block:
 		boolean (true: data, false: block, nil: close)
 		string last
  */
+
+struct socket_buffer {
+	void * buffer;
+	int sz;
+};
+
 static int
-lrecv(lua_State *L) {
+recv_socket(lua_State *L, char *tmp, struct socket_buffer *result) {
 	int fd = luaL_checkinteger(L,1);
 	size_t sz = 0;
 	const char * last = lua_tolstring(L,2,&sz);
 	luaL_checktype(L, 3, LUA_TTABLE);
 
-	char tmp[CACHE_SIZE];
 	char * buffer;
 	int r = recv(fd, tmp, CACHE_SIZE, 0);
 	if (r == 0) {
@@ -163,10 +168,64 @@ lrecv(lua_State *L) {
 		lua_pushnil(L);
 		lua_rawseti(L, 3, i);
 	}
-
+	result->buffer = buffer;
-	return unpack(L, (uint8_t *)buffer, r+sz, 0);
+	result->sz = r + sz;
+	return -1;
 }
 
+static int
+lrecv(lua_State *L) {
+	struct socket_buffer sb;
+	char tmp[CACHE_SIZE];
+	int ret = recv_socket(L, tmp, &sb);
+	if (ret < 0) {
+		return unpack(L, sb.buffer, sb.sz, 0);
+	} else {
+		return ret;
+	}
+}
+
+static int
+unpack_line(lua_State *L, uint8_t *buffer, int sz, int n) {
+	if (sz == 0) 
+		goto _block;
+	if (buffer[0] == '\n') {
+		return unpack_line(L, buffer+1, sz-1, n);
+	}
+	int i;
+	for (i=1;i<sz;i++) {
+		if (buffer[i] == '\n') {
+			++n;
+			lua_pushlstring(L, (const char *)buffer, i);
+			lua_rawseti(L, 3, n);
+			buffer += i + 1;
+			sz -= i + 1;
+			return unpack_line(L, buffer, sz, n);
+		}
+	}
+_block:
+	lua_pushboolean(L, n==0 ? 0:1);
+	if (sz == 0) {
+		lua_pushnil(L);
+	} else {
+		lua_pushlstring(L, (const char *)buffer, sz);
+	}
+	return 2;
+}
+
+static int
+lreadline(lua_State *L) {
+	struct socket_buffer sb;
+	char tmp[CACHE_SIZE];
+	int ret = recv_socket(L, tmp, &sb);
+	if (ret < 0) {
+		return unpack_line(L, sb.buffer, sb.sz, 0);
+	} else {
+		return ret;
+	}
+}
+
+
 static int
 lusleep(lua_State *L) {
 	int n = luaL_checknumber(L, 1);
@@ -219,7 +278,7 @@ readline_stdin(void * arg) {
 }
 
 static int
-lreadline(lua_State *L) {
+lreadstdin(lua_State *L) {
 	struct queue *q = lua_touserdata(L, lua_upvalueindex(1));
 	LOCK(q);
 	if (q->head == q->tail) {
@@ -236,6 +295,18 @@ lreadline(lua_State *L) {
 	return 1;
 }
 
+static int
+lwriteline(lua_State *L) {
+	size_t sz = 0;
+	int fd = luaL_checkinteger(L,1);
+	const char * msg = luaL_checklstring(L, 2, &sz);
+	block_send(L, fd, msg, sz);
+	char nl[1] = { '\n' };
+	block_send(L, fd, nl, 1);
+	
+	return 0;
+}
+
 int
 luaopen_clientsocket(lua_State *L) {
 	luaL_checkversion(L);
@@ -245,14 +316,16 @@ luaopen_clientsocket(lua_State *L) {
 		{ "send", lsend },
 		{ "close", lclose },
 		{ "usleep", lusleep },
+		{ "readline", lreadline },
+		{ "writeline", lwriteline },
 		{ NULL, NULL },
 	};
 	luaL_newlib(L, l);
 
 	struct queue * q = lua_newuserdata(L, sizeof(*q));
 	memset(q, 0, sizeof(*q));
-	lua_pushcclosure(L, lreadline, 1);
+	lua_pushcclosure(L, lreadstdin, 1);
-	lua_setfield(L, -2, "readline");
+	lua_setfield(L, -2, "readstdin");
 
 	pthread_t pid ;
 	pthread_create(&pid, NULL, readline_stdin, q);

lualib-src/lua-cluster.c

@@ -0,0 +1,218 @@
+#include <lua.h>
+#include <lauxlib.h>
+#include <string.h>
+
+#include "skynet.h"
+
+/*
+	uint32_t/string addr 
+	uint32_t/session session
+	lightuserdata msg
+	uint32_t sz
+
+	return 
+		string request
+		uint32_t next_session
+ */
+
+#define TEMP_LENGTH 0x10007
+
+static void
+fill_uint32(uint8_t * buf, uint32_t n) {
+	buf[0] = n & 0xff;
+	buf[1] = (n >> 8) & 0xff;
+	buf[2] = (n >> 16) & 0xff;
+	buf[3] = (n >> 24) & 0xff;
+}
+
+static void
+fill_header(lua_State *L, uint8_t *buf, int sz, void *msg) {
+	if (sz >= 0x10000) {
+		skynet_free(msg);
+		luaL_error(L, "request message is too long %d", sz);
+	}
+	buf[0] = (sz >> 8) & 0xff;
+	buf[1] = sz & 0xff;
+}
+
+static void
+packreq_number(lua_State *L, int session, void * msg, size_t sz) {
+	uint32_t addr = lua_tounsigned(L,1);
+	uint8_t buf[TEMP_LENGTH];
+	fill_header(L, buf, sz+9, msg);
+	buf[2] = 0;
+	fill_uint32(buf+3, addr);
+	fill_uint32(buf+7, (uint32_t)session);
+	memcpy(buf+11,msg,sz);
+
+	lua_pushlstring(L, (const char *)buf, sz+11);
+}
+
+static void
+packreq_string(lua_State *L, int session, void * msg, size_t sz) {
+	size_t namelen = 0;
+	const char *name = lua_tolstring(L, 1, &namelen);
+	if (name == NULL || namelen < 1 || namelen > 255) {
+		skynet_free(msg);
+		luaL_error(L, "name is too long %s", name);
+	}
+
+	uint8_t buf[TEMP_LENGTH];
+	fill_header(L, buf, sz+5+namelen, msg);
+	buf[2] = (uint8_t)namelen;
+	memcpy(buf+3, name, namelen);
+	fill_uint32(buf+3+namelen, (uint32_t)session);
+	memcpy(buf+7+namelen,msg,sz);
+
+	lua_pushlstring(L, (const char *)buf, sz+7+namelen);
+}
+
+static int
+lpackrequest(lua_State *L) {
+	void *msg = lua_touserdata(L,3);
+	if (msg == NULL) {
+		return luaL_error(L, "Invalid request message");
+	}
+	size_t sz = luaL_checkunsigned(L,4);
+	int session = luaL_checkinteger(L,2);
+	if (session <= 0) {
+		return luaL_error(L, "Invalid request session %d", session);
+	}
+	int addr_type = lua_type(L,1);
+	if (addr_type == LUA_TNUMBER) {
+		packreq_number(L, session, msg, sz);
+	} else {
+		packreq_string(L, session, msg, sz);
+	}
+	if (++session < 0) {
+		session = 1;
+	}
+	skynet_free(msg);
+	lua_pushinteger(L, session);
+	return 2;
+}
+
+/*
+	string packed message
+	return 	
+		uint32_t or string addr
+		int session
+		string msg
+ */
+
+static inline uint32_t
+unpack_uint32(const uint8_t * buf) {
+	return buf[0] | buf[1]<<8 | buf[2]<<16 | buf[3]<<24;
+}
+
+static int
+unpackreq_number(lua_State *L, const uint8_t * buf, size_t sz) {
+	if (sz < 9) {
+		return luaL_error(L, "Invalid cluster message");
+	}
+	uint32_t address = unpack_uint32(buf+1);
+	uint32_t session = unpack_uint32(buf+5);
+	lua_pushunsigned(L, address);
+	lua_pushunsigned(L, session);
+	lua_pushlstring(L, (const char *)buf+9, sz-9);
+
+	return 3;
+}
+
+static int
+unpackreq_string(lua_State *L, const uint8_t * buf, size_t sz) {
+	size_t namesz = buf[0];
+	if (sz < namesz + 5) {
+		return luaL_error(L, "Invalid cluster message");
+	}
+	lua_pushlstring(L, (const char *)buf+1, namesz);
+	uint32_t session = unpack_uint32(buf + namesz + 1);
+	lua_pushunsigned(L, session);
+	lua_pushlstring(L, (const char *)buf+1+namesz+4, sz - namesz - 5);
+
+	return 3;
+}
+
+static int
+lunpackrequest(lua_State *L) {
+	size_t sz;
+	const char *msg = luaL_checklstring(L,1,&sz);
+	if (msg[0] == 0) {
+		return unpackreq_number(L, (const uint8_t *)msg, sz);
+	} else {
+		return unpackreq_string(L, (const uint8_t *)msg, sz);
+	}
+}
+
+/*
+	int session
+	boolean ok
+	lightuserdata msg
+	int sz
+	return string response
+ */
+static int
+lpackresponse(lua_State *L) {
+	uint32_t session = luaL_checkunsigned(L,1);
+	// clusterd.lua:command.socket call lpackresponse,
+	// and the msg/sz is return by skynet.rawcall , so don't free(msg)
+	int ok = lua_toboolean(L,2);
+	void * msg;
+	size_t sz;
+	
+	if (lua_type(L,3) == LUA_TSTRING) {
+		msg = (void *)lua_tolstring(L, 3, &sz);
+		if (sz > 0x1000) {
+			sz = 0x1000;
+		}
+	} else {
+		msg = lua_touserdata(L,3);
+		sz = luaL_checkunsigned(L, 4);
+	}
+
+	uint8_t buf[TEMP_LENGTH];
+	fill_header(L, buf, sz+5, msg);
+	fill_uint32(buf+2, session);
+	buf[6] = ok;
+	memcpy(buf+7,msg,sz);
+
+	lua_pushlstring(L, (const char *)buf, sz+7);
+
+	return 1;
+}
+
+/*
+	string packed response
+	return integer session
+		boolean ok
+		string msg
+ */
+static int
+lunpackresponse(lua_State *L) {
+	size_t sz;
+	const char * buf = luaL_checklstring(L, 1, &sz);
+	if (sz < 5) {
+		return 0;
+	}
+	uint32_t session = unpack_uint32((const uint8_t *)buf);
+	lua_pushunsigned(L, session);
+	lua_pushboolean(L, buf[4]);
+	lua_pushlstring(L, buf+5, sz-5);
+
+	return 3;
+}
+
+int
+luaopen_cluster_c(lua_State *L) {
+	luaL_Reg l[] = {
+		{ "packrequest", lpackrequest },
+		{ "unpackrequest", lunpackrequest },
+		{ "packresponse", lpackresponse },
+		{ "unpackresponse", lunpackresponse },
+		{ NULL, NULL },
+	};
+	luaL_checkversion(L);
+	luaL_newlib(L,l);
+
+	return 1;
+}

lualib-src/lua-mongo.c

@@ -55,7 +55,7 @@ little_endian(uint32_t v) {
 typedef void * document;
 
 static inline uint32_t
-get_length(const document buffer) {
+get_length(document buffer) {
 	union {
 		uint32_t v;
 		uint8_t b[4];
@@ -243,7 +243,7 @@ op_reply(lua_State *L) {
 			lua_pushlightuserdata(L, (void *)doc);
 			lua_rawseti(L, 2, i);
 
-			int32_t doc_len = get_length((const document)doc);
+			int32_t doc_len = get_length((document)doc);
 
 			doc += doc_len;
 			sz -= doc_len;
@@ -260,6 +260,13 @@ op_reply(lua_State *L) {
 			lua_pushnil(L);
 			lua_rawseti(L, 2, i);
 		}
+	} else {
+		if (sz >= 4) {
+			sz -= get_length((document)doc);
+		}
+	}
+	if (sz != 0) {
+		return luaL_error(L, "Invalid result bson document");
 	}
 	lua_pushboolean(L,1);
 	lua_pushinteger(L, id);
@@ -499,7 +506,7 @@ op_insert(lua_State *L) {
 		int i;
 		for (i=1;i<=s;i++) {
 			lua_rawgeti(L,3,i);
-			document doc = lua_touserdata(L,3);
+			document doc = lua_touserdata(L,-1);
 			luaL_addlstring(&b, (const char *)doc, get_length(doc));
 			lua_pop(L,1);
 		}

lualib-src/lua-multicast.c

@@ -0,0 +1,167 @@
+#include "skynet.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <stdint.h>
+#include <string.h>
+
+struct mc_package {
+	int reference;
+	uint32_t size;
+	void *data;
+};
+
+static int
+pack(lua_State *L, void *data, size_t size) {
+	struct mc_package * pack = skynet_malloc(sizeof(struct mc_package));
+	pack->reference = 0;
+	pack->size = (uint32_t)size;
+	pack->data = data;
+	struct mc_package ** ret = skynet_malloc(sizeof(*ret));
+	*ret = pack;
+	lua_pushlightuserdata(L, ret);
+	lua_pushinteger(L, sizeof(ret));
+	return 2;
+}
+
+/*
+	lightuserdata
+	integer size
+
+	return lightuserdata, sizeof(struct mc_package *)
+ */
+static int
+mc_packlocal(lua_State *L) {
+	void * data = lua_touserdata(L, 1);
+	size_t size = luaL_checkunsigned(L, 2);
+	if (size != (uint32_t)size) {
+		return luaL_error(L, "Size should be 32bit integer");
+	}
+	return pack(L, data, size);
+}
+
+/*
+	lightuserdata
+	integer size
+
+	return lightuserdata, sizeof(struct mc_package *)
+ */
+static int
+mc_packremote(lua_State *L) {
+	void * data = lua_touserdata(L, 1);
+	size_t size = luaL_checkunsigned(L, 2);
+	if (size != (uint32_t)size) {
+		return luaL_error(L, "Size should be 32bit integer");
+	}
+	void * msg = skynet_malloc(size);
+	memcpy(msg, data, size);
+	return pack(L, msg, size);
+}
+
+static int
+mc_packstring(lua_State *L) {
+	size_t size;
+	const char * msg = luaL_checklstring(L, 1, &size);
+	if (size != (uint32_t)size) {
+		return luaL_error(L, "string is too long");
+	}
+	void * data = skynet_malloc(size);
+	memcpy(data, msg, size);
+	return pack(L, data, size);
+}
+
+/*
+	lightuserdata struct mc_package **
+	integer size (must be sizeof(struct mc_package *)
+
+	return package, lightuserdata, size
+ */
+static int
+mc_unpacklocal(lua_State *L) {
+	struct mc_package ** pack = lua_touserdata(L,1);
+	int sz = luaL_checkinteger(L,2);
+	if (sz != sizeof(*pack)) {
+		return luaL_error(L, "Invalid multicast package size %d", sz);
+	}
+	lua_settop(L, 1);
+	lua_pushlightuserdata(L, (*pack)->data);
+	lua_pushunsigned(L, (*pack)->size);
+	return 3;
+}
+
+/*
+	lightuserdata struct mc_package **
+	integer reference
+ */
+static int
+mc_bindrefer(lua_State *L) {
+	struct mc_package ** pack = lua_touserdata(L,1);
+	int ref = luaL_checkinteger(L,2);
+	if ((*pack)->reference != 0) {
+		return luaL_error(L, "Can't bind a multicast package more than once");
+	}
+	(*pack)->reference = ref;
+
+	return 0;
+}
+
+/*
+	lightuserdata struct mc_package **
+ */
+static int
+mc_closelocal(lua_State *L) {
+	struct mc_package **ptr = lua_touserdata(L,1);
+	struct mc_package *pack = *ptr;
+
+	int ref = __sync_sub_and_fetch(&pack->reference, 1);
+	if (ref <= 0) {
+		skynet_free(pack->data);
+		skynet_free(pack);
+		if (ref < 0) {
+			return luaL_error(L, "Invalid multicast package reference %d", ref);
+		}
+	}
+
+	return 0;
+}
+
+/*
+	lightuserdata struct mc_package **
+	return lightuserdata/size
+ */
+static int
+mc_remote(lua_State *L) {
+	struct mc_package **ptr = lua_touserdata(L,1);
+	struct mc_package *pack = *ptr;
+	lua_pushlightuserdata(L, pack->data);
+	lua_pushunsigned(L, pack->size);
+	skynet_free(pack);
+	return 2;
+}
+
+static int
+mc_nextid(lua_State *L) {
+	uint32_t id = luaL_checkunsigned(L, 1);
+	id += 256;
+	lua_pushunsigned(L, id);
+
+	return 1;
+}
+
+int
+luaopen_multicast_c(lua_State *L) {
+	luaL_Reg l[] = {
+		{ "pack", mc_packlocal },
+		{ "unpack", mc_unpacklocal },
+		{ "bind", mc_bindrefer },
+		{ "close", mc_closelocal },
+		{ "remote", mc_remote },
+		{ "packstring", mc_packstring },
+		{ "packremote", mc_packremote },
+		{ "nextid", mc_nextid },
+		{ NULL, NULL },
+	};
+	luaL_checkversion(L);
+	luaL_newlib(L,l);
+	return 1;
+}

lualib-src/lua-seri.c

@@ -581,8 +581,16 @@ _luaseri_unpack(lua_State *L) {
 	if (lua_isnoneornil(L,1)) {
 		return 0;
 	}
-	void * buffer = lua_touserdata(L,1);
+	void * buffer;
-	int len = luaL_checkinteger(L,2);
+	int len;
+	if (lua_type(L,1) == LUA_TSTRING) {
+		size_t sz;
+		 buffer = (void *)lua_tolstring(L,1,&sz);
+		len = (int)sz;
+	} else {
+		buffer = lua_touserdata(L,1);
+		len = luaL_checkinteger(L,2);
+	}
 	if (len == 0) {
 		return 0;
 	}

lualib-src/lua-skynet.c

@@ -1,6 +1,5 @@
 #include "skynet.h"
 #include "lua-seri.h"
-#include "service_lua.h"
 
 #define KNRM  "\x1B[0m"
 #define KRED  "\x1B[31m"
@@ -11,18 +10,36 @@
 #include <string.h>
 #include <assert.h>
 
+struct snlua {
+	lua_State * L;
+	struct skynet_context * ctx;
+	const char * preload;
+};
+
+static int 
+traceback (lua_State *L) {
+	const char *msg = lua_tostring(L, 1);
+	if (msg)
+		luaL_traceback(L, L, msg, 1);
+	else {
+		lua_pushliteral(L, "(no error message)");
+	}
+	return 1;
+}
+
 static int
 _cb(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
 	lua_State *L = ud;
 	int trace = 1;
 	int r;
 	int top = lua_gettop(L);
-	if (top == 1) {
+	if (top == 0) {
+		lua_pushcfunction(L, traceback);
 		lua_rawgetp(L, LUA_REGISTRYINDEX, _cb);
 	} else {
 		assert(top == 2);
-		lua_pushvalue(L,2);
 	}
+	lua_pushvalue(L,2);
 
 	lua_pushinteger(L, type);
 	lua_pushlightuserdata(L, (void *)msg);
@@ -132,7 +149,7 @@ _sendname(lua_State *L, struct skynet_context * context, const char * dest) {
 		luaL_error(L, "skynet.send invalid param %s", lua_typename(L,lua_type(L,4)));
 	}
 	if (session < 0) {
-		luaL_error(L, "skynet.send session (%d) < 0", session);
+		return 0;
 	}
 	lua_pushinteger(L,session);
 	return 1;
@@ -204,7 +221,7 @@ _send(lua_State *L) {
 	}
 	if (session < 0) {
 		// send to invalid address
-		// todo: maybe throw error is better
+		// todo: maybe throw error whould be better
 		return 0;
 	}
 	lua_pushinteger(L,session);
@@ -272,6 +289,16 @@ _harbor(lua_State *L) {
 	return 2;
 }
 
+static int
+lpackstring(lua_State *L) {
+	_luaseri_pack(L);
+	char * str = (char *)lua_touserdata(L, -2);
+	int sz = lua_tointeger(L, -1);
+	lua_pushlstring(L, str, sz);
+	skynet_free(str);
+	return 1;
+}
+
 int
 luaopen_skynet_c(lua_State *L) {
 	luaL_checkversion(L);
@@ -286,19 +313,19 @@ luaopen_skynet_c(lua_State *L) {
 		{ "harbor", _harbor },
 		{ "pack", _luaseri_pack },
 		{ "unpack", _luaseri_unpack },
+		{ "packstring", lpackstring },
 		{ "callback", _callback },
 		{ NULL, NULL },
 	};
 
-	lua_getfield(L, LUA_REGISTRYINDEX, "skynet_lua");
+	luaL_newlibtable(L, l);
-	struct snlua *lua = lua_touserdata(L,-1);
+
-	if (lua == NULL || lua->ctx == NULL) {
+	lua_getfield(L, LUA_REGISTRYINDEX, "skynet_context");
+	struct skynet_context *ctx = lua_touserdata(L,-1);
+	if (ctx == NULL) {
 		return luaL_error(L, "Init skynet context first");
 	}
-	assert(lua->L == L);
 
-	luaL_newlibtable(L, l);
-	lua_pushlightuserdata(L, lua->ctx);
 	luaL_setfuncs(L,l,1);
 
 	return 1;

lualib-src/lua-socket.c

@@ -10,11 +10,11 @@
 #include <lauxlib.h>
 
 #include "skynet_socket.h"
-#include "service_lua.h"
 
 #define BACKLOG 32
 // 2 ** 12 == 4096
 #define LARGE_PAGE_NODE 12
+#define BUFFER_LIMIT (256 * 1024)
 
 struct buffer_node {
 	char * msg;
@@ -23,6 +23,7 @@ struct buffer_node {
 };
 
 struct socket_buffer {
+	int limit;
 	int size;
 	int offset;
 	struct buffer_node *head;
@@ -65,6 +66,7 @@ lnewpool(lua_State *L, int sz) {
 static int
 lnewbuffer(lua_State *L) {
 	struct socket_buffer * sb = lua_newuserdata(L, sizeof(*sb));	
+	sb->limit = luaL_optint(L,1,BUFFER_LIMIT);
 	sb->size = 0;
 	sb->offset = 0;
 	sb->head = NULL;
@@ -127,6 +129,9 @@ lpushbuffer(lua_State *L) {
 	sb->size += sz;
 
 	lua_pushinteger(L, sb->size);
+	if (sb->limit > 0 && sb->size > sb->limit) {
+		return luaL_error(L, "buffer overflow (limit = %d, size = %d)", sb->limit, sb->size);
+	}
 
 	return 1;
 }
@@ -189,6 +194,25 @@ pop_lstring(lua_State *L, struct socket_buffer *sb, int sz, int skip) {
 	luaL_pushresult(&b);
 }
 
+static int
+lheader(lua_State *L) {
+	size_t len;
+	const uint8_t * s = (const uint8_t *)luaL_checklstring(L, 1, &len);
+	if (len > 4 || len < 1) {
+		return luaL_error(L, "Invalid read %s", s);
+	}
+	int i;
+	size_t sz = 0;
+	for (i=0;i<(int)len;i++) {
+		sz <<= 8;
+		sz |= s[i];
+	}
+
+	lua_pushunsigned(L, sz);
+
+	return 1;
+}
+
 /*
 	userdata send_buffer
 	table pool
@@ -458,6 +482,14 @@ lstart(lua_State *L) {
 	return 0;
 }
 
+static int
+lnodelay(lua_State *L) {
+	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
+	int id = luaL_checkinteger(L, 1);
+	skynet_socket_nodelay(ctx,id);
+	return 0;
+}
+
 int
 luaopen_socketdriver(lua_State *L) {
 	luaL_checkversion(L);
@@ -470,6 +502,7 @@ luaopen_socketdriver(lua_State *L) {
 		{ "clear", lclearbuffer },
 		{ "readline", lreadline },
 		{ "str2p", lstr2p },
+		{ "header", lheader },
 
 		{ "unpack", lunpack },
 		{ NULL, NULL },
@@ -483,17 +516,15 @@ luaopen_socketdriver(lua_State *L) {
 		{ "lsend", lsendlow },
 		{ "bind", lbind },
 		{ "start", lstart },
+		{ "nodelay", lnodelay },
 		{ NULL, NULL },
 	};
-	lua_getfield(L, LUA_REGISTRYINDEX, "skynet_lua");
+	lua_getfield(L, LUA_REGISTRYINDEX, "skynet_context");
-	struct snlua *lua = lua_touserdata(L,-1);
+	struct skynet_context *ctx = lua_touserdata(L,-1);
-	if (lua == NULL || lua->ctx == NULL) {
+	if (ctx == NULL) {
 		return luaL_error(L, "Init skynet context first");
 	}
-	// assert(lua->L == L);
-	lua_pop(L,1);
 
-	lua_pushlightuserdata(L, lua->ctx);
 	luaL_setfuncs(L,l2,1);
 
 	return 1;

lualib/cluster.lua

@@ -0,0 +1,27 @@
+local skynet = require "skynet"
+
+local clusterd
+local cluster = {}
+
+function cluster.call(node, address, ...)
+	-- skynet.pack(...) will free by cluster.c.packrequest
+	return skynet.call(clusterd, "lua", "req", node, address, skynet.pack(...))
+end
+
+function cluster.open(port)
+	if type(port) == "string" then
+		skynet.call(clusterd, "lua", "listen", port)
+	else
+		skynet.call(clusterd, "lua", "listen", "0.0.0.0", port)
+	end
+end
+
+function cluster.reload()
+	skynet.call(clusterd, "lua", "reload")
+end
+
+skynet.init(function()
+	clusterd = skynet.uniqueservice("clusterd")
+end)
+
+return cluster

lualib/datacenter.lua

@@ -0,0 +1,18 @@
+local skynet = require "skynet"
+
+local datacenter = {}
+
+function datacenter.get(...)
+	return skynet.call("DATACENTER", "lua", "QUERY", ...)
+end
+
+function datacenter.set(...)
+	return skynet.call("DATACENTER", "lua", "UPDATE", ...)
+end
+
+function datacenter.wait(...)
+	return skynet.call("DATACENTER", "lua", "WAIT", ...)
+end
+
+return datacenter
+

lualib/loader.lua

@@ -0,0 +1,48 @@
+local args = {}
+for word in string.gmatch(..., "%S+") do
+	table.insert(args, word)
+end
+
+SERVICE_NAME = args[1]
+
+local main, pattern
+
+local err = {}
+for pat in string.gmatch(LUA_SERVICE, "([^;]+);*") do
+	local filename = string.gsub(pat, "?", SERVICE_NAME)
+	local f, msg = loadfile(filename)
+	if not f then
+		table.insert(err, msg)
+	else
+		pattern = pat
+		main = f
+		break
+	end
+end
+
+if not main then
+	error(table.concat(err, "\n"))
+end
+
+LUA_SERVICE = nil
+package.path , LUA_PATH = LUA_PATH
+package.cpath , LUA_CPATH = LUA_CPATH
+
+local service_path = string.match(pattern, "(.*/)[^/?]+$")
+
+if service_path then
+	service_path = string.gsub(service_path, "?", args[1])
+	package.path = service_path .. "?.lua;" .. package.path
+	SERVICE_PATH = service_path
+else
+	local p = string.match(pattern, "(.*/).+$")
+	SERVICE_PATH = p
+end
+
+if LUA_PRELOAD then
+	local f = assert(loadfile(LUA_PRELOAD))
+	f(table.unpack(args))
+	LUA_PRELOAD = nil
+end
+
+main(select(2, table.unpack(args)))

lualib/mongo.lua

@@ -39,9 +39,7 @@ local client_meta = {
 
 		return "[mongo client : " .. self.host .. port_string .."]"
 	end,
-	__gc = function(self)
+	-- DO NOT need disconnect, because channel will shutdown during gc
-		self:disconnect()
-	end
 }
 
 local mongo_db = {}
@@ -100,7 +98,7 @@ function mongo.client( conf )
 		host = obj.host,
 		port = obj.port,
 		response = dispatch_reply,
-		auth = mongo_auth(conf),
+		auth = mongo_auth(obj),
 	}
 	setmetatable(obj, client_meta)
 	obj.__sock:connect(true)	-- try connect only once
@@ -169,7 +167,9 @@ function mongo_db:runCommand(cmd,cmd_v,...)
 		bson_cmd = bson_encode_order(cmd,cmd_v,...)
 	end
 	local pack = driver.query(request_id, 0, self.__cmd, 0, 1, bson_cmd)
-	local doc = sock:request(pack, request_id).document
+	-- we must hold req (req.data), because req.document is a lightuserdata, it's a pointer to the string (req.data)
+	local req = sock:request(pack, request_id)
+	local doc = req.document
 	return bson_decode(doc)
 end
 
@@ -226,7 +226,9 @@ function mongo_collection:findOne(query, selector)
 	local request_id = conn:genId()
 	local sock = conn.__sock
 	local pack = driver.query(request_id, 0, self.full_name, 0, 1, query and bson_encode(query) or empty_bson, selector and bson_encode(selector))
-	local doc = sock:request(pack, request_id).document
+	-- we must hold req (req.data), because req.document is a lightuserdata, it's a pointer to the string (req.data)
+	local req = sock:request(pack, request_id)
+	local doc = req.document
 	return bson_decode(doc)
 end
 

lualib/mqueue.lua

@@ -1,3 +1,5 @@
+-- This is a deprecated module, use skynet.queue instead.
+
 local skynet = require "skynet"
 local c = require "skynet.c"
 

lualib/multicast.lua

@@ -0,0 +1,102 @@
+local skynet = require "skynet"
+local mc = require "multicast.c"
+
+local multicastd
+local multicast = {}
+local dispatch = setmetatable({} , {__mode = "kv" })
+
+local chan = {}
+local chan_meta = {
+	__index = chan,
+	__gc = unsubscribe,
+	__tostring = function (self)
+		return string.format("[Multicast:%x]",self.channel)
+	end,
+}
+
+local function default_conf(conf)
+	conf = conf or {}
+	conf.pack = conf.pack or skynet.pack
+	conf.unpack = conf.unpack or skynet.unpack
+
+	return conf
+end
+
+function multicast.new(conf)
+	assert(multicastd, "Init first")
+	local self = {}
+	conf = conf or self
+	self.channel = conf.channel
+	if self.channel == nil then
+		self.channel = skynet.call(multicastd, "lua", "NEW")
+	end
+	self.__pack = conf.pack or skynet.pack
+	self.__unpack = conf.unpack or skynet.unpack
+	self.__dispatch = conf.dispatch
+
+	return setmetatable(self, chan_meta)
+end
+
+function chan:delete()
+	local c = assert(self.channel)
+	skynet.send(multicastd, "lua", "DEL", c)
+	self.channel = nil
+	self.__subscribe = nil
+end
+
+function chan:publish(...)
+	local c = assert(self.channel)
+	skynet.call(multicastd, "lua", "PUB", c, mc.pack(self.__pack(...)))
+end
+
+function chan:subscribe()
+	local c = assert(self.channel)
+	if self.__subscribe then
+		-- already subscribe
+		return
+	end
+	skynet.call(multicastd, "lua", "SUB", c)
+	self.__subscribe = true
+	dispatch[c] = self
+end
+
+function chan:unsubscribe()
+	if not self.__subscribe then
+		-- already unsubscribe
+		return
+	end
+	local c = assert(self.channel)
+	skynet.send(multicastd, "lua", "USUB", c)
+	self.__subscribe = nil
+end
+
+local function dispatch_subscribe(channel, source, pack, msg, sz)
+	local self = dispatch[channel]
+	if not self then
+		mc.close(pack)
+		error ("Unknown channel " .. channel)
+	end
+
+	if self.__subscribe then
+		local ok, err = pcall(self.__dispatch, self, source, self.__unpack(msg, sz))
+		mc.close(pack)
+		assert(ok, err)
+	else
+		-- maybe unsubscribe first, but the message is send out. drop the message unneed
+		mc.close(pack)
+	end
+end
+
+local function init()
+	multicastd = skynet.uniqueservice "multicastd"
+	skynet.register_protocol {
+		name = "multicast",
+		id = skynet.PTYPE_MULTICAST,
+		unpack = mc.unpack,
+		dispatch = dispatch_subscribe,
+	}
+end
+
+skynet.init(init, "multicast")
+
+return multicast

lualib/redis.lua

@@ -1,6 +1,7 @@
 local skynet = require "skynet"
 local socket = require "socket"
 local socketchannel = require "socketchannel"
+local int64 = require "int64"
 
 local table = table
 local string = string
@@ -9,9 +10,7 @@ local redis = {}
 local command = {}
 local meta = {
 	__index = command,
-	__gc = function(self)
+	-- DO NOT close channel in __gc
-		self[1]:close()
-	end,
 }
 
 ---------- redis response
@@ -96,12 +95,12 @@ function command:disconnect()
 	setmetatable(self, nil)
 end
 
-local function compose_message(msg)
+-- msg could be any type of value
-	if #msg == 1 then
+local function pack_value(lines, v)
-		return msg[1] .. "\r\n"
+	if v == nil then
+		return
 	end
-	local lines = { "*" .. #msg }
+
-	for _,v in ipairs(msg) do
 	local t = type(v)
 	if t == "number" then
 		v = tostring(v)
@@ -110,17 +109,42 @@ local function compose_message(msg)
 	end
 	table.insert(lines,"$"..#v)
 	table.insert(lines,v)
-	end
+end
-	table.insert(lines,"")
 
-	local cmd =  table.concat(lines,"\r\n")
+local function compose_message(cmd, msg)
-	return cmd
+	local len = 1
+	local t = type(msg)
+
+	if t == "table" then
+		len = len + #msg
+	elseif t ~= nil then
+		len = len + 1
+	end
+
+	local lines = {"*" .. len}
+	pack_value(lines, cmd)
+
+	if t == "table" then
+		for _,v in ipairs(msg) do
+			pack_value(lines, v)
+		end
+	else
+		pack_value(lines, msg)
+	end
+	table.insert(lines, "")
+
+	local chunk =  table.concat(lines,"\r\n")
+	return chunk
 end
 
 setmetatable(command, { __index = function(t,k)
 	local cmd = string.upper(k)
-	local f = function (self, ...)
+	local f = function (self, v, ...)
-		return self[1]:request(compose_message { cmd, ... }, read_response)
+		if type(v) == "table" then
+			return self[1]:request(compose_message(cmd, v), read_response)
+		else
+			return self[1]:request(compose_message(cmd, {v, ...}), read_response)
+		end
 	end
 	t[k] = f
 	return f
@@ -133,12 +157,12 @@ end
 
 function command:exists(key)
 	local fd = self[1]
-	return fd:request(compose_message { "EXISTS", key }, read_boolean)
+	return fd:request(compose_message ("EXISTS", key), read_boolean)
 end
 
 function command:sismember(key, value)
 	local fd = self[1]
-	return fd:request(compose_message { "SISMEMBER", key, value }, read_boolean)
+	return fd:request(compose_message ("SISMEMBER", {key, value}), read_boolean)
 end
 
 --- watch mode
@@ -158,10 +182,10 @@ local function watch_login(obj, auth)
 			so:request("AUTH "..auth.."\r\n", read_response)
 		end
 		for k in pairs(obj.__psubscribe) do
-			so:request(compose_message { "PSUBSCRIBE", k })
+			so:request(compose_message ("PSUBSCRIBE", k))
 		end
 		for k in pairs(obj.__subscribe) do
-			so:request(compose_message { "SUBSCRIBE", k })
+			so:request(compose_message("SUBSCRIBE", k))
 		end
 	end
 end
@@ -194,7 +218,7 @@ local function watch_func( name )
 		local so = self.__sock
 		for i = 1, select("#", ...) do
 			local v = select(i, ...)
-			so:request(compose_message { NAME, v })
+			so:request(compose_message(NAME, v))
 		end
 	end
 end

lualib/skynet.lua

@@ -16,15 +16,16 @@ local skynet = {
 	-- read skynet.h
 	PTYPE_TEXT = 0,
 	PTYPE_RESPONSE = 1,
---	PTYPE_MULTICAST = 2, -- DEPRECATED
+	PTYPE_MULTICAST = 2,
 	PTYPE_CLIENT = 3,
 	PTYPE_SYSTEM = 4,
 	PTYPE_HARBOR = 5,
 	PTYPE_SOCKET = 6,
 	PTYPE_ERROR = 7,
-	PTYPE_QUEUE = 8,
+	PTYPE_QUEUE = 8,	-- use in deprecated mqueue, use skynet.queue instead
 	PTYPE_DEBUG = 9,
-	PTYPE_LUA = 10
+	PTYPE_LUA = 10,
+	PTYPE_SNAX = 11,
 }
 
 -- code cache
@@ -68,13 +69,13 @@ local function dispatch_error_queue()
 	end
 end
 
-local function _error_dispatch(error_session, monitor, service)
+local function _error_dispatch(error_session, error_source)
-	if service then
+	if error_session == 0 then
 		-- service is down
 		--  Don't remove from watching_service , because user may call dead service
-		watching_service[service] = false
+		watching_service[error_source] = false
 		for session, srv in pairs(watching_session) do
-			if srv == service then
+			if srv == error_source then
 				table.insert(error_queue, session)
 			end
 		end
@@ -86,21 +87,6 @@ local function _error_dispatch(error_session, monitor, service)
 	end
 end
 
-local watch_monitor
-
-function skynet.watch(service)
-	assert(type(service) == "number")
-	if watch_monitor == nil then
-		watch_monitor = string_to_handle(c.command("MONITOR"))
-		assert(watch_monitor, "Need a monitor")
-	end
-	if watching_service[service] == nil then
-		watching_service[service] = true
-		-- read lualib/simplemonitor.lua
-		assert(skynet.call(watch_monitor, "lua", "WATCH", service), "watch a dead service")
-	end
-end
-
 -- coroutine reuse
 
 local coroutine_pool = {}
@@ -204,12 +190,33 @@ function skynet.wait()
 	session_id_coroutine[session] = nil
 end
 
+local function globalname(name, handle)
+	local c = string.sub(name,1,1)
+	assert(c ~= ':')
+	if c == '.' then
+		return false
+	end
+
+	assert(#name <= 16)	-- GLOBALNAME_LENGTH is 16, defined in skynet_harbor.h
+	assert(tonumber(name) == nil)	-- global name can't be number
+
+	local harbor = require "skynet.harbor"
+
+	harbor.globalname(name, handle)
+
+	return true
+end
+
 function skynet.register(name)
+	if not globalname(name) then
 		c.command("REG", name)
+	end
 end
 
 function skynet.name(name, handle)
-	c.command("NAME", name .. " " .. handle)
+	if not globalname(name, handle) then
+		c.command("NAME", name .. " " .. skynet.address(handle))
+	end
 end
 
 local self_handle
@@ -222,7 +229,10 @@ function skynet.self()
 end
 
 function skynet.localname(name)
-	return string_to_handle(c.command("QUERY", name))
+	local addr = c.command("QUERY", name)
+	if addr then
+		return string_to_handle(addr)
+	end
 end
 
 function skynet.launch(...)
@@ -240,8 +250,19 @@ function skynet.starttime()
 	return tonumber(c.command("STARTTIME"))
 end
 
+function skynet.time()
+	return skynet.now()/100 + skynet.starttime()	-- get now first would be better
+end
+
 function skynet.exit()
 	skynet.send(".launcher","lua","REMOVE",skynet.self())
+	for co, session in pairs(session_coroutine_id) do
+		local address = session_coroutine_address[co]
+		local self = skynet.self()
+		if session~=0 and address then
+			skynet.redirect(address, self, "error", session, "")
+		end
+	end
 	c.command("EXIT")
 end
 
@@ -254,7 +275,12 @@ function skynet.kill(name)
 end
 
 function skynet.getenv(key)
-	return c.command("GETENV",key)
+	local ret = c.command("GETENV",key)
+	if ret == "" then
+		return
+	else
+		return ret
+	end
 end
 
 function skynet.setenv(key, value)
@@ -276,6 +302,7 @@ skynet.redirect = function(dest,source,typename,...)
 end
 
 skynet.pack = assert(c.pack)
+skynet.packstring = assert(c.packstring)
 skynet.unpack = assert(c.unpack)
 skynet.tostring = assert(c.tostring)
 
@@ -283,7 +310,7 @@ local function yield_call(service, session)
 	watching_session[session] = service
 	local succ, msg, sz = coroutine_yield("CALL", session)
 	watching_session[session] = nil
-	assert(succ, "Capture an error")
+	assert(succ, debug.traceback())
 	return msg,sz
 end
 
@@ -299,19 +326,11 @@ function skynet.call(addr, typename, ...)
 	return p.unpack(yield_call(addr, session))
 end
 
-function skynet.blockcall(addr, typename , ...)
-	local p = proto[typename]
-	c.command("LOCK")
-	local session = c.send(addr, p.id , nil , p.pack(...))
-	if session == nil then
-		c.command("UNLOCK")
-		error("call to invalid address " .. skynet.address(addr))
-	end
-	return p.unpack(yield_call(addr, session))
-end
-
 function skynet.rawcall(addr, typename, msg, sz)
 	local p = proto[typename]
+	if watching_service[addr] == false then
+		error("Service is dead")
+	end
 	local session = assert(c.send(addr, p.id , nil , msg, sz), "call to invalid address")
 	return yield_call(addr, session)
 end
@@ -338,8 +357,8 @@ function skynet.dispatch(typename, func)
 	p.dispatch = func
 end
 
-local function unknown_request(session, address, msg, sz)
+local function unknown_request(session, address, msg, sz, prototype)
-    print("Unknown request :" , c.tostring(msg,sz))
+	skynet.error(string.format("Unknown request (%s): %s", prototype, c.tostring(msg,sz)))
 	error(string.format("Unknown session : %d from %x", session, address))
 end
 
@@ -393,7 +412,7 @@ local function raw_dispatch_message(prototype, msg, sz, session, source, ...)
 			session_coroutine_address[co] = source
 			suspend(co, coroutine.resume(co, session,source, p.unpack(msg,sz, ...)))
 		else
-            unknown_request(session, source, msg, sz)
+			unknown_request(session, source, msg, sz, proto[prototype])
 		end
 	end
 end
@@ -420,8 +439,7 @@ local function dispatch_message(...)
 end
 
 function skynet.newservice(name, ...)
-	local param =  table.concat({"snlua", name, ...}, " ")
+	local handle = skynet.tostring(skynet.rawcall(".launcher", "lua" , skynet.pack("LAUNCH", "snlua", name, ...)))
-	local handle = skynet.call(".launcher", "text" , param)
 	if handle == "" then
 		return nil
 	else
@@ -430,32 +448,18 @@ function skynet.newservice(name, ...)
 end
 
 function skynet.uniqueservice(global, ...)
-	local handle
 	if global == true then
-		handle = skynet.call("SERVICE", "lua", "LAUNCH", ...)
+		return assert(skynet.call(".service", "lua", "GLAUNCH", ...))
 	else
-		handle = skynet.call(".service", "lua", "LAUNCH", global, ...)
+		return assert(skynet.call(".service", "lua", "LAUNCH", global, ...))
 	end
-	assert(handle , "Unique service launch failed")
-	return handle
 end
 
 function skynet.queryservice(global, ...)
-	local handle
 	if global == true then
-		handle = skynet.call("SERVICE", "lua", "QUERY", ...)
+		return assert(skynet.call(".service", "lua", "GQUERY", ...))
 	else
-		handle = skynet.call(".service", "lua", "QUERY", global, ...)
+		return assert(skynet.call(".service", "lua", "QUERY", global, ...))
-	end
-	assert(handle , "Unique service query failed")
-	return handle
-end
-
-local function group_command(cmd, handle, address)
-	if address then
-		return string.format("%s %d :%x",cmd, handle, address)
-	else
-		return string.format("%s %d",cmd,handle)
 	end
 end
 
@@ -479,66 +483,10 @@ function skynet.error(...)
 	return c.error(table.concat(t, " "))
 end
 
------ debug
-
-local internal_info_func
-
-function skynet.info_func(func)
-	internal_info_func = func
-end
-
-local dbgcmd = {}
-
-function dbgcmd.MEM()
-	local kb, bytes = collectgarbage "count"
-	skynet.ret(skynet.pack(kb,bytes))
-end
-
-function dbgcmd.GC()
-	coroutine_pool = {}
-	collectgarbage "collect"
-end
-
-function dbgcmd.STAT()
-	local stat = {}
-	stat.mqlen = skynet.mqlen()
-	skynet.ret(skynet.pack(stat))
-end
-
-function dbgcmd.INFO()
-	if internal_info_func then
-		skynet.ret(skynet.pack(internal_info_func()))
-	else
-		skynet.ret(skynet.pack(nil))
-	end
-end
-
-local function _debug_dispatch(session, address, cmd, ...)
-	local f = dbgcmd[cmd]
-	assert(f, cmd)
-	f(...)
-end
-
 ----- register protocol
 do
 	local REG = skynet.register_protocol
 
-	REG {
-		name = "text",
-		id = skynet.PTYPE_TEXT,
-		pack = function (...)
-			local n = select ("#" , ...)
-			if n == 0 then
-				return ""
-			elseif n == 1 then
-				return tostring(...)
-			else
-				return table.concat({...}," ")
-			end
-		end,
-		unpack = c.tostring
-	}
-
 	REG {
 		name = "lua",
 		id = skynet.PTYPE_LUA,
@@ -551,19 +499,10 @@ do
 		id = skynet.PTYPE_RESPONSE,
 	}
 
-	REG {
-		name = "debug",
-		id = skynet.PTYPE_DEBUG,
-		pack = skynet.pack,
-		unpack = skynet.unpack,
-		dispatch = _debug_dispatch,
-	}
-
 	REG {
 		name = "error",
 		id = skynet.PTYPE_ERROR,
-		pack = skynet.pack,
+		unpack = function(...) return ... end,
-		unpack = skynet.unpack,
 		dispatch = _error_dispatch,
 	}
 end
@@ -602,11 +541,11 @@ end
 local function init_service(start)
 	local ok, err = xpcall(init_template, debug.traceback, start)
 	if not ok then
-		print("init service failed:", err)
+		skynet.error("init service failed: " .. tostring(err))
-		skynet.send(".launcher","text", "ERROR")
+		skynet.send(".launcher","lua", "ERROR")
 		skynet.exit()
 	else
-		skynet.send(".launcher","text", "")
+		skynet.send(".launcher","lua", "LAUNCHOK")
 	end
 end
 
@@ -643,10 +582,26 @@ function skynet.monitor(service, query)
 	end
 	assert(monitor, "Monitor launch failed")
 	c.command("MONITOR", string.format(":%08x", monitor))
+	return monitor
 end
 
 function skynet.mqlen()
 	return tonumber(c.command "MQLEN")
 end
 
+function skynet.task(ret)
+	local t = 0
+	for session,co in pairs(session_id_coroutine) do
+		if ret then
+			ret[session] = debug.traceback(co)
+		end
+		t = t + 1
+	end
+	return t
+end
+
+-- Inject internal debug framework
+local debug = require "skynet.debug"
+debug(skynet)
+
 return skynet

lualib/skynet/debug.lua

@@ -0,0 +1,56 @@
+return function (skynet)
+
+local internal_info_func
+
+function skynet.info_func(func)
+	internal_info_func = func
+end
+
+local dbgcmd = {}
+
+function dbgcmd.MEM()
+	local kb, bytes = collectgarbage "count"
+	skynet.ret(skynet.pack(kb,bytes))
+end
+
+function dbgcmd.GC()
+	coroutine_pool = {}
+	collectgarbage "collect"
+end
+
+function dbgcmd.STAT()
+	local stat = {}
+	stat.mqlen = skynet.mqlen()
+	stat.task = skynet.task()
+	skynet.ret(skynet.pack(stat))
+end
+
+function dbgcmd.TASK()
+	local task = {}
+	skynet.task(task)
+	skynet.ret(skynet.pack(task))
+end
+
+function dbgcmd.INFO()
+	if internal_info_func then
+		skynet.ret(skynet.pack(internal_info_func()))
+	else
+		skynet.ret(skynet.pack(nil))
+	end
+end
+
+local function _debug_dispatch(session, address, cmd, ...)
+	local f = dbgcmd[cmd]
+	assert(f, cmd)
+	f(...)
+end
+
+skynet.register_protocol {
+	name = "debug",
+	id = assert(skynet.PTYPE_DEBUG),
+	pack = assert(skynet.pack),
+	unpack = assert(skynet.unpack),
+	dispatch = _debug_dispatch,
+}
+
+end

lualib/skynet/harbor.lua

@@ -0,0 +1,18 @@
+local skynet = require "skynet"
+
+local harbor = {}
+
+function harbor.globalname(name, handle)
+	handle = handle or skynet.self()
+	skynet.send(".slave", "lua", "REGISTER", name, handle)
+end
+
+function harbor.link(id)
+	skynet.call(".slave", "lua", "LINK", id)
+end
+
+function harbor.connect(id)
+	skynet.call(".slave", "lua", "CONNECT", id)
+end
+
+return harbor

lualib/skynet/queue.lua

@@ -0,0 +1,33 @@
+local skynet = require "skynet"
+local coroutine = coroutine
+local pcall = pcall
+local table = table
+
+function skynet.queue()
+	local current_thread
+	local ref = 0
+	local thread_queue = {}
+	return function(f, ...)
+		local thread = coroutine.running()
+		if ref == 0 then
+			current_thread = thread
+		elseif current_thread ~= thread then
+			table.insert(thread_queue, thread)
+			skynet.wait()
+			assert(ref == 0)
+		end
+		ref = ref + 1
+		local ok, err = pcall(f, ...)
+		ref = ref - 1
+		if ref == 0 then
+			current_thread = nil
+			local co = table.remove(thread_queue,1)
+			if co then
+				skynet.wakeup(co)
+			end
+		end
+		assert(ok,err)
+	end
+end
+
+return skynet.queue

lualib/snax.lua

@@ -1,11 +1,19 @@
 local skynet = require "skynet"
-local snax_interface = require "snax_interface"
+local snax_interface = require "snax.interface"
 
 local snax = {}
 local typeclass = {}
 
 local G = { require = function() end }
 
+skynet.register_protocol {
+	name = "snax",
+	id = skynet.PTYPE_SNAX,
+	pack = skynet.pack,
+	unpack = skynet.unpack,
+}
+
+
 function snax.interface(name)
 	if typeclass[name] then
 		return typeclass[name]
@@ -38,7 +46,7 @@ local function gen_post(type, handle)
 		__index = function( t, k )
 			local id = assert(type.accept[k] , string.format("post %s no exist", k))
 			return function(...)
-				skynet_send(handle, "lua", id, ...)
+				skynet_send(handle, "snax", id, ...)
 			end
 		end })
 end
@@ -48,7 +56,7 @@ local function gen_req(type, handle)
 		__index = function( t, k )
 			local id = assert(type.response[k] , string.format("request %s no exist", k))
 			return function(...)
-				return skynet_call(handle, "lua", id, ...)
+				return skynet_call(handle, "snax", id, ...)
 			end
 		end })
 end
@@ -64,16 +72,14 @@ end
 
 local handle_cache = setmetatable( {} , { __mode = "kv" } )
 
-function snax.newservice(name, ...)
+function snax.rawnewservice(name, ...)
 	local t = snax.interface(name)
 	local handle = skynet.newservice("snaxd", name)
 	assert(handle_cache[handle] == nil)
 	if t.system.init then
-		skynet.call(handle, "lua", t.system.init, ...)
+		skynet.call(handle, "snax", t.system.init, ...)
 	end
-	local ret = wrapper(handle, name, t)
+	return handle
-	handle_cache[handle] = ret
-	return ret
 end
 
 function snax.bind(handle, type)
@@ -88,9 +94,42 @@ function snax.bind(handle, type)
 	return ret
 end
 
+function snax.newservice(name, ...)
+	local handle = snax.rawnewservice(name, ...)
+	return snax.bind(handle, name)
+end
+
+local function service_name(global, name, ...)
+	if global == true then
+		return name
+	else
+		return global
+	end
+end
+
+function snax.uniqueservice(name, ...)
+	local handle = assert(skynet.call(".service", "lua", "LAUNCH", "snaxd", name, ...))
+	return snax.bind(handle, name)
+end
+
+function snax.globalservice(name, ...)
+	local handle = assert(skynet.call(".service", "lua", "GLAUNCH", "snaxd", name, ...))
+	return snax.bind(handle, name)
+end
+
+function snax.queryservice(name)
+	local handle = assert(skynet.call(".service", "lua", "QUERY", "snaxd", name))
+	return snax.bind(handle, name)
+end
+
+function snax.queryglobal(name)
+	local handle = assert(skynet.call(".service", "lua", "GQUERY", "snaxd", name))
+	return snax.bind(handle, name)
+end
+
 function snax.kill(obj, ...)
 	local t = snax.interface(obj.type)
-	skynet_call(obj.handle, "lua", t.system.exit, ...)
+	skynet_call(obj.handle, "snax", t.system.exit, ...)
 end
 
 local function test_result(ok, ...)
@@ -103,7 +142,7 @@ end
 
 function snax.hotfix(obj, source, ...)
 	local t = snax.interface(obj.type)
-	return test_result(skynet_call(obj.handle, "lua", t.system.hotfix, source, ...))
+	return test_result(skynet_call(obj.handle, "snax", t.system.hotfix, source, ...))
 end
 
 return snax

lualib/snax/hotfix.lua

@@ -1,4 +1,4 @@
-local si = require "snax_interface"
+local si = require "snax.interface"
 local io = io
 
 local hotfix = {}

lualib/socket.lua

@@ -2,6 +2,7 @@ local driver = require "socketdriver"
 local skynet = require "skynet"
 local assert = assert
 
+local buffer_limit = -1
 local socket = {}	-- api
 local buffer_pool = {}	-- store all message buffer object
 local socket_pool = setmetatable( -- store all socket object
@@ -30,6 +31,11 @@ local function suspend(s)
 	assert(not s.co)
 	s.co = coroutine.running()
 	skynet.wait()
+	-- wakeup closing corouting every time suspend,
+	-- because socket.close() will wait last socket buffer operation before clear the buffer.
+	if s.closing then
+		skynet.wakeup(s.closing)
+	end
 end
 
 -- read skynet_socket.h for these macro
@@ -37,12 +43,18 @@ end
 socket_message[1] = function(id, size, data)
 	local s = socket_pool[id]
 	if s == nil then
-		print("socket: drop package from " .. id)
+		skynet.error("socket: drop package from " .. id)
 		driver.drop(data, size)
 		return
 	end
 
-	local sz = driver.push(s.buffer, buffer_pool, data, size)
+	local ok , sz = pcall(driver.push, s.buffer, buffer_pool, data, size)
+	if not ok then
+		skynet.error("socket: error on ", id , sz)
+		driver.clear(s.buffer,buffer_pool)
+		driver.close(id)
+		return
+	end
 	local rr = s.read_required
 	local rrt = type(rr)
 	if rrt == "number" then
@@ -95,13 +107,14 @@ end
 socket_message[5] = function(id)
 	local s = socket_pool[id]
 	if s == nil then
-		print("socket: error on unknown", id)
+		skynet.error("socket: error on unknown", id)
 		return
 	end
 	if s.connected then
-		print("socket: error on", id)
+		skynet.error("socket: error on", id)
 	end
 	s.connected = false
+
 	wakeup(s)
 end
 
@@ -117,7 +130,7 @@ skynet.register_protocol {
 local function connect(id, func)
 	local newbuffer
 	if func == nil then
-		newbuffer = driver.buffer()
+		newbuffer = driver.buffer(buffer_limit)
 	end
 	local s = {
 		id = id,
@@ -145,7 +158,7 @@ function socket.bind(os_fd)
 end
 
 function socket.stdin()
-	return socket.bind(1)
+	return socket.bind(0)
 end
 
 function socket.start(id, func)
@@ -175,7 +188,8 @@ function socket.close(id)
 		-- notice: call socket.close in __gc should be carefully,
 		-- because skynet.wait never return in __gc, so driver.clear may not be called
 		if s.co then
-			-- reading this socket on another coroutine
+			-- reading this socket on another coroutine, so don't shutdown (clear the buffer) immediatel
+			-- wait reading coroutine read the buffer.
 			assert(not s.closing)
 			s.closing = coroutine.running()
 			skynet.wait()
@@ -189,13 +203,6 @@ function socket.close(id)
 	socket_pool[id] = nil
 end
 
-local function close_socket(s)
-	if s.closing then
-		skynet.wakeup(s.closing)
-	end
-	return driver.readall(s.buffer, buffer_pool)
-end
-
 function socket.read(id, sz)
 	local s = socket_pool[id]
 	assert(s)
@@ -204,7 +211,7 @@ function socket.read(id, sz)
 		return ret
 	end
 	if not s.connected then
-		return false, close_socket(s)
+		return false, driver.readall(s.buffer, buffer_pool)
 	end
 
 	assert(not s.read_required)
@@ -214,7 +221,7 @@ function socket.read(id, sz)
 	if ret then
 		return ret
 	else
-		return false, close_socket(s)
+		return false, driver.readall(s.buffer, buffer_pool)
 	end
 end
 
@@ -222,14 +229,14 @@ function socket.readall(id)
 	local s = socket_pool[id]
 	assert(s)
 	if not s.connected then
-		local r = close_socket(s)
+		local r = driver.readall(s.buffer, buffer_pool)
 		return r ~= "" and r
 	end
 	assert(not s.read_required)
 	s.read_required = true
 	suspend(s)
 	assert(s.connected == false)
-	return close_socket(s)
+	return driver.readall(s.buffer, buffer_pool)
 end
 
 function socket.readline(id, sep)
@@ -241,7 +248,7 @@ function socket.readline(id, sep)
 		return ret
 	end
 	if not s.connected then
-		return false, close_socket(s)
+		return false, driver.readall(s.buffer, buffer_pool)
 	end
 	assert(not s.read_required)
 	s.read_required = sep
@@ -249,7 +256,7 @@ function socket.readline(id, sep)
 	if s.connected then
 		return driver.readline(s.buffer, buffer_pool, sep)
 	else
-		return false, close_socket(s)
+		return false, driver.readall(s.buffer, buffer_pool)
 	end
 end
 
@@ -261,20 +268,24 @@ function socket.block(id)
 	assert(not s.read_required)
 	s.read_required = 0
 	suspend(s)
-	if not s.connected and s.closing then
-		skynet.wakeup(s.closing)
-	end
 	return s.connected
 end
 
 socket.write = assert(driver.send)
 socket.lwrite = assert(driver.lsend)
+socket.header = assert(driver.header)
 
 function socket.invalid(id)
 	return socket_pool[id] == nil
 end
 
-socket.listen = assert(driver.listen)
+function socket.listen(host, port, backlog)
+	if port == nil then
+		host, port = string.match(host, "([^:]+):(.+)$")
+		port = tonumber(port)
+	end
+	return driver.listen(host, port, backlog)
+end
 
 function socket.lock(id)
 	local s = socket_pool[id]
@@ -314,4 +325,8 @@ function socket.abandon(id)
 	socket_pool[id] = nil
 end
 
+function socket.limit(limit)
+	buffer_limit = limit
+end
+
 return socket

lualib/socketchannel.lua

@@ -27,8 +27,8 @@ function socket_channel.channel(desc)
 		__host = assert(desc.host),
 		__port = assert(desc.port),
 		__auth = desc.auth,
-		__response = desc.response,
+		__response = desc.response,	-- It's for session mode
-		__request = {},	-- request seq { response func or session }
+		__request = {},	-- request seq { response func or session }	-- It's for order mode
 		__thread = {}, -- coroutine seq or session->coroutine map
 		__result = {}, -- response result { coroutine -> result }
 		__result_data = {},
@@ -51,6 +51,17 @@ local function close_channel_socket(self)
 end
 
 local function wakeup_all(self, errmsg)
+	if self.__response then
+		for k,co in pairs(self.__thread) do
+			self.__thread[k] = nil
+			self.__result[co] = socket_error
+			self.__result_data[co] = errmsg
+			skynet.wakeup(co)
+		end
+	else
+		for i = 1, #self.__request do
+			self.__request[i] = nil
+		end
 		for i = 1, #self.__thread do
 			local co = self.__thread[i]
 			self.__thread[i] = nil
@@ -58,11 +69,13 @@ local function wakeup_all(self, errmsg)
 			self.__result_data[co] = errmsg
 			skynet.wakeup(co)
 		end
+	end
 end
 
-local function dispatch_response(self)
+
+
+local function dispatch_by_session(self)
 	local response = self.__response
-	if response then
 	-- response() return session
 	while self.__sock do
 		local ok , session, result_ok, result_data = pcall(response, self.__sock)
@@ -74,7 +87,7 @@ local function dispatch_response(self)
 				self.__result_data[co] = result_data
 				skynet.wakeup(co)
 			else
-					print("socket: unknown session :", session)
+				skynet.error("socket: unknown session :", session)
 			end
 		else
 			close_channel_socket(self)
@@ -82,19 +95,29 @@ local function dispatch_response(self)
 			if session ~= socket_error then
 				errormsg = session
 			end
-				for k,co in pairs(self.__thread) do
+			wakeup_all(self, errormsg)
-					-- throw error (errormsg)
-					self.__thread[k] = nil
-					self.__result[co] = socket_error
-					self.__result_data[co] = errormsg
-					skynet.wakeup(co)
-				end
 		end
 	end
+end
+
+local function pop_response(self)
+	return table.remove(self.__request, 1), table.remove(self.__thread, 1)
+end
+
+local function push_response(self, response, co)
+	if self.__response then
+		-- response is session
+		self.__thread[response] = co
 	else
-		-- pop response function from __request
+		-- response is a function, push it to __request
+		table.insert(self.__request, response)
+		table.insert(self.__thread, co)
+	end
+end
+
+local function dispatch_by_order(self)
 	while self.__sock do
-			local func = table.remove(self.__request, 1)
+		local func, co = pop_response(self)
 		if func == nil then
 			if not socket.block(self.__sock[1]) then
 				close_channel_socket(self)
@@ -103,7 +126,6 @@ local function dispatch_response(self)
 		else
 			local ok, result_ok, result_data = pcall(func, self.__sock)
 			if ok then
-					local co = table.remove(self.__thread, 1)
 				self.__result[co] = result_ok
 				self.__result_data[co] = result_data
 				skynet.wakeup(co)
@@ -113,10 +135,20 @@ local function dispatch_response(self)
 				if result ~= socket_error then
 					errmsg = result_ok
 				end
+				self.__result[co] = socket_error
+				self.__result_data[co] = errmsg
+				skynet.wakeup(co)
 				wakeup_all(self, errmsg)
 			end
 		end
 	end
+end
+
+local function dispatch_function(self)
+	if self.__response then
+		return dispatch_by_session
+	else
+		return dispatch_by_order
 	end
 end
 
@@ -128,14 +160,14 @@ local function connect_once(self)
 	end
 	self.__authcoroutine = coroutine.running()
 	self.__sock = setmetatable( {fd} , channel_socket_meta )
-	skynet.fork(dispatch_response, self)
+	skynet.fork(dispatch_function(self), self)
 
 	if self.__auth then
 		local ok , message = pcall(self.__auth, self)
 		if not ok then
 			close_channel_socket(self)
 			if message ~= socket_error then
-				print("socket: auth failed", message)
+				skynet.error("socket: auth failed", message)
 			end
 		end
 		self.__authcoroutine = false
@@ -150,12 +182,15 @@ local function try_connect(self , once)
 	local t = 100
 	while not self.__closed do
 		if connect_once(self) then
+			if not once then
+				skynet.error("socket: connect to", self.__host, self.__port)
+			end
 			return
 		elseif once then
 			error(string.format("Connect to %s:%d failed", self.__host, self.__port))
 		end
 		if t > 1000 then
-			print("socket: try to reconnect", self.__host, self.__port)
+			skynet.error("socket: try to reconnect", self.__host, self.__port)
 			skynet.sleep(t)
 			t = 0
 		else
@@ -179,6 +214,7 @@ local function block_connect(self, once)
 	if self.__closed then
 		return false
 	end
+
 	if #self.__connecting > 0 then
 		-- connecting in other coroutine
 		local co = coroutine.running()
@@ -187,7 +223,6 @@ local function block_connect(self, once)
 		-- check connection again
 		return block_connect(self, once)
 	end
-
 	self.__connecting[1] = true
 	try_connect(self, once)
 	self.__connecting[1] = nil
@@ -209,10 +244,30 @@ function channel:connect(once)
 	return block_connect(self, once)
 end
 
+local function wait_for_response(self, response)
+	local co = coroutine.running()
+	push_response(self, response, co)
+	skynet.wait()
+
+	local result = self.__result[co]
+	self.__result[co] = nil
+	local result_data = self.__result_data[co]
+	self.__result_data[co] = nil
+
+	if result == socket_error then
+		error(socket_error)
+	else
+		assert(result, result_data)
+		return result_data
+	end
+end
+
 function channel:request(request, response)
 	assert(block_connect(self))
 
 	if not socket.write(self.__sock[1], request) then
+		close_channel_socket(self)
+		wakeup_all(self)
 		error(socket_error)
 	end
 
@@ -221,59 +276,13 @@ function channel:request(request, response)
 		return
 	end
 
-	local co = coroutine.running()
+	return wait_for_response(self, response)
-
-	if self.__response then
-		-- response is session
-		self.__thread[response] = co
-	else
-		-- response is a function, push it to __request
-		table.insert(self.__request, response)
-		table.insert(self.__thread, co)
-	end
-	skynet.wait()
-
-	local result = self.__result[co]
-	self.__result[co] = nil
-	local result_data = self.__result_data[co]
-	self.__result_data[co] = nil
-
-	if result == socket_error then
-		if result_data then
-			print("socket: dispatch", request, result_data)
-		end
-		error(socket_error)
-	else
-		assert(result, result_data)
-		return result_data
-	end
 end
 
 function channel:response(response)
 	assert(block_connect(self))
 
-	assert(type(response) == "function")
+	return wait_for_response(self, response)
-
-	local co = coroutine.running()
-	table.insert(self.__request, response)
-	table.insert(self.__thread, co)
-
-	skynet.wait()
-
-	local result = self.__result[co]
-	self.__result[co] = nil
-	local result_data = self.__result_data[co]
-	self.__result_data[co] = nil
-
-	if result == socket_error then
-		if result_data then
-			print("socket: dispatch", request, result_data)
-		end
-		error(socket_error)
-	else
-		assert(result, result_data)
-		return result_data
-	end
 end
 
 function channel:close()

platform.mk

@@ -5,30 +5,36 @@ CC ?= gcc
 
 .PHONY : none $(PLATS) clean all cleanall
 
-ifneq ($(PLAT), none)
+#ifneq ($(PLAT), none)
 
 .PHONY : default
 
 default :
 	$(MAKE) $(PLAT)
 
-endif
+#endif
 
 none :
 	@echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
 	@echo "   $(PLATS)"
 
-LIBS := -lpthread -lm
+SKYNET_LIBS := -lpthread -lm
 SHARED := -fPIC --shared
 EXPORT := -Wl,-E
 
-$(PLATS) : all 
-
 linux : PLAT = linux
 macosx : PLAT = macosx
 freebsd : PLAT = freebsd
 
-macosx linux : LIBS += -ldl
 macosx : SHARED := -fPIC -dynamiclib -Wl,-undefined,dynamic_lookup
 macosx : EXPORT :=
-linux freebsd : LIBS += -lrt
+macosx linux : SKYNET_LIBS += -ldl
+linux freebsd : SKYNET_LIBS += -lrt
+
+# Turn off jemalloc and malloc hook on macosx
+
+macosx : MALLOC_STATICLIB :=
+macosx : SKYNET_DEFINES :=-DNOUSE_JEMALLOC
+
+linux macosx freebsd :
+	$(MAKE) all PLAT=$@ SKYNET_LIBS="$(SKYNET_LIBS)" SHARED="$(SHARED)" EXPORT="$(EXPORT)" MALLOC_STATICLIB="$(MALLOC_STATICLIB)" SKYNET_DEFINES="$(SKYNET_DEFINES)"

service-src/service_harbor.c

@@ -2,6 +2,16 @@
 #include "skynet_harbor.h"
 #include "skynet_socket.h"
 
+/*
+	harbor listen the PTYPE_HARBOR (in text)
+	N name : update the global name
+	S fd id: connect to new harbor , we should send self_id to fd first , and then recv a id (check it), and at last send queue.
+	A fd id: accept new harbor , we should send self_id to fd , and then send queue.
+
+	If the fd is disconnected, send message to slave in PTYPE_TEXT.  D id
+	If we don't known a globalname, send message to slave in PTYPE_TEXT. Q name
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
@@ -13,8 +23,22 @@
 #define HASH_SIZE 4096
 #define DEFAULT_QUEUE_SIZE 1024
 
+// 12 is sizeof(struct remote_message_header)
+#define HEADER_COOKIE_LENGTH 12
+
+/*
+	message type (8bits) is in destination high 8bits
+	harbor id (8bits) is also in that place , but remote message doesn't need harbor id.
+ */
+struct remote_message_header {
+	uint32_t source;
+	uint32_t destination;
+	uint32_t session;
+};
+
 struct msg {
-	uint8_t * buffer;
+	struct remote_message_header header;
+	void * buffer;
 	size_t size;
 };
 
@@ -37,32 +61,34 @@ struct hashmap {
 	struct keyvalue *node[HASH_SIZE];
 };
 
-/*
+#define STATUS_WAIT 0
-	message type (8bits) is in destination high 8bits
+#define STATUS_HANDSHAKE 1
-	harbor id (8bits) is also in that place , but  remote message doesn't need harbor id.
+#define STATUS_HEADER 2
- */
+#define STATUS_CONTENT 3
-struct remote_message_header {
+#define STATUS_DOWN 4
-	uint32_t source;
+
-	uint32_t destination;
+struct slave {
-	uint32_t session;
+	int fd;
+	struct msg_queue *queue;
+	int status;
+	int length;
+	int read;
+	uint8_t size[4];
+	char * recv_buffer;
 };
 
 struct harbor {
 	struct skynet_context *ctx;
-	char * local_addr;
 	int id;
+	uint32_t slave;
 	struct hashmap * map;
-	int master_fd;
+	struct slave s[REMOTE_MAX];
-	char * master_addr;
-	int remote_fd[REMOTE_MAX];
-	bool connected[REMOTE_MAX];
-	char * remote_addr[REMOTE_MAX];
 };
 
 // hash table
 
 static void
-_push_queue(struct msg_queue * queue, const void * buffer, size_t sz, struct remote_message_header * header) {
+push_queue_msg(struct msg_queue * queue, struct msg * m) {
 	// If there is only 1 free slot which is reserved to distinguish full/empty
 	// of circular buffer, expand it.
 	if (((queue->tail + 1) % queue->size) == queue->head) {
@@ -78,16 +104,21 @@ _push_queue(struct msg_queue * queue, const void * buffer, size_t sz, struct rem
 		queue->size *= 2;
 	}
 	struct msg * slot = &queue->data[queue->tail];
+	*slot = *m;
 	queue->tail = (queue->tail + 1) % queue->size;
+}
 
-	slot->buffer = skynet_malloc(sz + sizeof(*header));
+static void
-	memcpy(slot->buffer, buffer, sz);
+push_queue(struct msg_queue * queue, void * buffer, size_t sz, struct remote_message_header * header) {
-	memcpy(slot->buffer + sz, header, sizeof(*header));
+	struct msg m;
-	slot->size = sz + sizeof(*header);
+	m.header = *header;
+	m.buffer = buffer;
+	m.size = sz;
+	push_queue_msg(queue, &m);
 }
 
 static struct msg *
-_pop_queue(struct msg_queue * queue) {
+pop_queue(struct msg_queue * queue) {
 	if (queue->head == queue->tail) {
 		return NULL;
 	}
@@ -97,7 +128,7 @@ _pop_queue(struct msg_queue * queue) {
 }
 
 static struct msg_queue *
-_new_queue() {
+new_queue() {
 	struct msg_queue * queue = skynet_malloc(sizeof(*queue));
 	queue->size = DEFAULT_QUEUE_SIZE;
 	queue->head = 0;
@@ -108,20 +139,19 @@ _new_queue() {
 }
 
 static void
-_release_queue(struct msg_queue *queue) {
+release_queue(struct msg_queue *queue) {
 	if (queue == NULL)
 		return;
-	struct msg * m = _pop_queue(queue);
+	struct msg * m;
-	while (m) {
+	while ((m=pop_queue(queue)) != NULL) {
 		skynet_free(m->buffer);
-		m = _pop_queue(queue);
 	}
 	skynet_free(queue->data);
 	skynet_free(queue);
 }
 
 static struct keyvalue *
-_hash_search(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
+hash_search(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
 	uint32_t *ptr = (uint32_t*) name;
 	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
 	struct keyvalue * node = hash->node[h % HASH_SIZE];
@@ -139,7 +169,7 @@ _hash_search(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
 // Don't support erase name yet
 
 static struct void
-_hash_erase(struct hashmap * hash, char name[GLOBALNAME_LENGTH) {
+hash_erase(struct hashmap * hash, char name[GLOBALNAME_LENGTH) {
 	uint32_t *ptr = name;
 	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
 	struct keyvalue ** ptr = &hash->node[h % HASH_SIZE];
@@ -157,7 +187,7 @@ _hash_erase(struct hashmap * hash, char name[GLOBALNAME_LENGTH) {
 */
 
 static struct keyvalue *
-_hash_insert(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
+hash_insert(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
 	uint32_t *ptr = (uint32_t *)name;
 	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
 	struct keyvalue ** pkv = &hash->node[h % HASH_SIZE];
@@ -173,20 +203,20 @@ _hash_insert(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
 }
 
 static struct hashmap * 
-_hash_new() {
+hash_new() {
 	struct hashmap * h = skynet_malloc(sizeof(struct hashmap));
 	memset(h,0,sizeof(*h));
 	return h;
 }
 
 static void
-_hash_delete(struct hashmap *hash) {
+hash_delete(struct hashmap *hash) {
 	int i;
 	for (i=0;i<HASH_SIZE;i++) {
 		struct keyvalue * node = hash->node[i];
 		while (node) {
 			struct keyvalue * next = node->next;
-			_release_queue(node->queue);
+			release_queue(node->queue);
 			skynet_free(node);
 			node = next;
 		}
@@ -196,64 +226,50 @@ _hash_delete(struct hashmap *hash) {
 
 ///////////////
 
+static void
+close_harbor(struct harbor *h, int id) {
+	struct slave *s = &h->s[id];
+	s->status = STATUS_DOWN;
+	if (s->fd) {
+		skynet_socket_close(h->ctx, s->fd);
+	}
+	if (s->queue) {
+		release_queue(s->queue);
+		s->queue = NULL;
+	}
+}
+
+static void
+report_harbor_down(struct harbor *h, int id) {
+	char down[64];
+	int n = sprintf(down, "D %d",id);
+
+	skynet_send(h->ctx, 0, h->slave, PTYPE_TEXT, 0, down, n);
+}
+
 struct harbor *
 harbor_create(void) {
 	struct harbor * h = skynet_malloc(sizeof(*h));
-	h->ctx = NULL;
+	memset(h,0,sizeof(*h));
-	h->id = 0;
+	h->map = hash_new();
-	h->master_fd = -1;
-	h->master_addr = NULL;
-	int i;
-	for (i=0;i<REMOTE_MAX;i++) {
-		h->remote_fd[i] = -1;
-		h->connected[i] = false;
-		h->remote_addr[i] = NULL;
-	}
-	h->map = _hash_new();
 	return h;
 }
 
 void
 harbor_release(struct harbor *h) {
-	struct skynet_context *ctx = h->ctx;
-	if (h->master_fd >= 0) {
-		skynet_socket_close(ctx, h->master_fd);
-	}
-	skynet_free(h->master_addr);
-	skynet_free(h->local_addr);
 	int i;
-	for (i=0;i<REMOTE_MAX;i++) {
+	for (i=1;i<REMOTE_MAX;i++) {
-		if (h->remote_fd[i] >= 0) {
+		struct slave *s = &h->s[i];
-			skynet_socket_close(ctx, h->remote_fd[i]);
+		if (s->fd && s->status != STATUS_DOWN) {
-			skynet_free(h->remote_addr[i]);
+			close_harbor(h,i);
+			// don't call report_harbor_down.
+			// never call skynet_send during module exit, because of dead lock
 		}
 	}
-	_hash_delete(h->map);
+	hash_delete(h->map);
 	skynet_free(h);
 }
 
-static int
-_connect_to(struct harbor *h, const char *ipaddress, bool blocking) {
-	char * port = strchr(ipaddress,':');
-	if (port==NULL) {
-		return -1;
-	}
-	int sz = port - ipaddress;
-	char tmp[sz + 1];
-	memcpy(tmp,ipaddress,sz);
-	tmp[sz] = '\0';
-
-	int portid = strtol(port+1, NULL,10);
-
-	skynet_error(h->ctx, "Harbor(%d) connect to %s:%d", h->id, tmp, portid);
-
-	if (blocking) {
-		return skynet_socket_block_connect(h->ctx, tmp, portid);
-	} else {
-		return skynet_socket_connect(h->ctx, tmp, portid);
-	}
-}
-
 static inline void
 to_bigendian(uint8_t *buffer, uint32_t n) {
 	buffer[0] = (n >> 24) & 0xff;
@@ -263,7 +279,7 @@ to_bigendian(uint8_t *buffer, uint32_t n) {
 }
 
 static inline void
-_header_to_message(const struct remote_message_header * header, uint8_t * message) {
+header_to_message(const struct remote_message_header * header, uint8_t * message) {
 	to_bigendian(message , header->source);
 	to_bigendian(message+4 , header->destination);
 	to_bigendian(message+8 , header->session);
@@ -280,112 +296,207 @@ from_bigendian(uint32_t n) {
 }
 
 static inline void
-_message_to_header(const uint32_t *message, struct remote_message_header *header) {
+message_to_header(const uint32_t *message, struct remote_message_header *header) {
 	header->source = from_bigendian(message[0]);
 	header->destination = from_bigendian(message[1]);
 	header->session = from_bigendian(message[2]);
 }
 
-static void
+// socket package
-_send_package(struct skynet_context *ctx, int fd, const void * buffer, size_t sz) {
-	uint8_t * sendbuf = skynet_malloc(sz+4);
-	to_bigendian(sendbuf, sz);
-	memcpy(sendbuf+4, buffer, sz);
 
-	if (skynet_socket_send(ctx, fd, sendbuf, sz+4)) {
+static void
-		skynet_error(ctx, "Send to %d error", fd);
+forward_local_messsage(struct harbor *h, void *msg, int sz) {
+	const char * cookie = msg;
+	cookie += sz - HEADER_COOKIE_LENGTH;
+	struct remote_message_header header;
+	message_to_header((const uint32_t *)cookie, &header);
+
+	uint32_t destination = header.destination;
+	int type = (destination >> HANDLE_REMOTE_SHIFT) | PTYPE_TAG_DONTCOPY;
+	destination = (destination & HANDLE_MASK) | ((uint32_t)h->id << HANDLE_REMOTE_SHIFT);
+
+	if (skynet_send(h->ctx, header.source, destination, type, (int)header.session, (void *)msg, sz-HEADER_COOKIE_LENGTH) < 0) {
+		skynet_error(h->ctx, "Unknown destination :%x from :%x", destination, header.source);
 	}
 }
 
 static void
-_send_remote(struct skynet_context * ctx, int fd, const char * buffer, size_t sz, struct remote_message_header * cookie) {
+send_remote(struct skynet_context * ctx, int fd, const char * buffer, size_t sz, struct remote_message_header * cookie) {
 	uint32_t sz_header = sz+sizeof(*cookie);
 	uint8_t * sendbuf = skynet_malloc(sz_header+4);
 	to_bigendian(sendbuf, sz_header);
 	memcpy(sendbuf+4, buffer, sz);
-	_header_to_message(cookie, sendbuf+4+sz);
+	header_to_message(cookie, sendbuf+4+sz);
 
-	if (skynet_socket_send(ctx, fd, sendbuf, sz_header+4)) {
+	// ignore send error, because if the connection is broken, the mainloop will recv a message.
-		skynet_error(ctx, "Remote send to %d error", fd);
+	skynet_socket_send(ctx, fd, sendbuf, sz_header+4);
-	}
 }
 
 static void
-_update_remote_address(struct harbor *h, int harbor_id, const char * ipaddr) {
+dispatch_name_queue(struct harbor *h, struct keyvalue * node) {
-	if (harbor_id == h->id) {
+	struct msg_queue * queue = node->queue;
-		return;
+	uint32_t handle = node->value;
-	}
-	assert(harbor_id > 0  && harbor_id< REMOTE_MAX);
-	struct skynet_context * context = h->ctx;
-	if (h->remote_fd[harbor_id] >=0) {
-		skynet_socket_close(context, h->remote_fd[harbor_id]);
-		skynet_free(h->remote_addr[harbor_id]);
-		h->remote_addr[harbor_id] = NULL;
-	}
-	h->remote_fd[harbor_id] = _connect_to(h, ipaddr, false);
-	h->connected[harbor_id] = false;
-}
-
-static void
-_dispatch_queue(struct harbor *h, struct msg_queue * queue, uint32_t handle,  const char name[GLOBALNAME_LENGTH] ) {
 	int harbor_id = handle >> HANDLE_REMOTE_SHIFT;
 	assert(harbor_id != 0);
 	struct skynet_context * context = h->ctx;
-	int fd = h->remote_fd[harbor_id];
+	struct slave *s = &h->s[harbor_id];
-	if (fd < 0) {
+	int fd = s->fd;
+	if (fd == 0) {
+		if (s->status == STATUS_DOWN) {
 			char tmp [GLOBALNAME_LENGTH+1];
-		memcpy(tmp, name , GLOBALNAME_LENGTH);
+			memcpy(tmp, node->key, GLOBALNAME_LENGTH);
 			tmp[GLOBALNAME_LENGTH] = '\0';
 			skynet_error(context, "Drop message to %s (in harbor %d)",tmp,harbor_id);
+		} else {
+			if (s->queue == NULL) {
+				s->queue = node->queue;
+				node->queue = NULL;
+			} else {
+				struct msg * m;
+				while ((m = pop_queue(queue))!=NULL) {
+					push_queue_msg(s->queue, m);
+				}
+			}
+		}
 		return;
 	}
-	struct msg * m = _pop_queue(queue);
+	struct msg * m;
-	while (m) {
+	while ((m = pop_queue(queue)) != NULL) {
-		struct remote_message_header cookie;
+		m->header.destination |= (handle & HANDLE_MASK);
-		uint8_t *ptr = m->buffer + m->size - sizeof(cookie);
+		send_remote(context, fd, m->buffer, m->size, &m->header);
-		memcpy(&cookie, ptr, sizeof(cookie));
-		cookie.destination |= (handle & HANDLE_MASK);
-		_header_to_message(&cookie, ptr);
-		_send_package(context, fd, m->buffer, m->size);
-		m = _pop_queue(queue);
 	}
 }
 
 static void
-_update_remote_name(struct harbor *h, const char name[GLOBALNAME_LENGTH], uint32_t handle) {
+dispatch_queue(struct harbor *h, int id) {
-	struct keyvalue * node = _hash_search(h->map, name);
+	struct slave *s = &h->s[id];
+	int fd = s->fd;
+	assert(fd != 0);
+
+	struct msg_queue *queue = s->queue;
+	if (queue == NULL)
+		return;
+
+	struct msg * m;
+	while ((m = pop_queue(queue)) != NULL) {
+		send_remote(h->ctx, fd, m->buffer, m->size, &m->header);
+	}
+	release_queue(queue);
+	s->queue = NULL;
+}
+
+static void
+push_socket_data(struct harbor *h, const struct skynet_socket_message * message) {
+	assert(message->type == SKYNET_SOCKET_TYPE_DATA);
+	int fd = message->id;
+	int i;
+	int id = 0;
+	struct slave * s = NULL;
+	for (i=1;i<REMOTE_MAX;i++) {
+		if (h->s[i].fd == fd) {
+			s = &h->s[i];
+			id = i;
+			break;
+		}
+	}
+	if (s == NULL) {
+		skynet_free(message->buffer);
+		skynet_error(h->ctx, "Invalid socket fd (%d) data", fd);
+		return;
+	}
+	uint8_t * buffer = (uint8_t *)message->buffer;
+	int size = message->ud;
+
+	for (;;) {
+		switch(s->status) {
+		case STATUS_HANDSHAKE: {
+			// check id
+			uint8_t remote_id = buffer[0];
+			if (remote_id != id) {
+				skynet_error(h->ctx, "Invalid shakehand id (%d) from fd = %d , harbor = %d", id, fd, remote_id);
+				close_harbor(h,id);
+				return;
+			}
+			++buffer;
+			--size;
+			s->status = STATUS_HEADER;
+
+			dispatch_queue(h, id);
+
+			if (size == 0) {
+				break;
+			}
+			// go though
+		}
+		case STATUS_HEADER: {
+			// big endian 4 bytes length, the first one must be 0.
+			int need = 4 - s->read;
+			if (size < need) {
+				memcpy(s->size + s->read, buffer, size);
+				s->read += size;
+				return;
+			} else {
+				memcpy(s->size + s->read, buffer, need);
+				buffer += need;
+				size -= need;
+
+				if (s->size[0] != 0) {
+					skynet_error(h->ctx, "Message is too long from harbor %d", id);
+					close_harbor(h,id);
+					return;
+				}
+				s->length = s->size[1] << 16 | s->size[2] << 8 | s->size[3];
+				s->read = 0;
+				s->recv_buffer = skynet_malloc(s->length);
+				s->status = STATUS_CONTENT;
+				if (size == 0) {
+					return;
+				}
+			}
+		}
+		// go though
+		case STATUS_CONTENT: {
+			int need = s->length - s->read;
+			if (size < need) {
+				memcpy(s->recv_buffer + s->read, buffer, size);
+				s->read += size;
+				return;
+			}
+			memcpy(s->recv_buffer + s->read, buffer, need);
+			forward_local_messsage(h, s->recv_buffer, s->length);
+			s->length = 0;
+			s->read = 0;
+			s->recv_buffer = NULL;
+			size -= need;
+			buffer += need;
+			s->status = STATUS_HEADER;
+			if (size == 0)
+				return;
+			break;
+		}
+		default:
+			return;
+		}
+	}
+}
+
+static void
+update_name(struct harbor *h, const char name[GLOBALNAME_LENGTH], uint32_t handle) {
+	struct keyvalue * node = hash_search(h->map, name);
 	if (node == NULL) {
-		node = _hash_insert(h->map, name);
+		node = hash_insert(h->map, name);
 	}
 	node->value = handle;
 	if (node->queue) {
-		_dispatch_queue(h, node->queue, handle, name);
+		dispatch_name_queue(h, node);
-		_release_queue(node->queue);
+		release_queue(node->queue);
 		node->queue = NULL;
 	}
 }
 
-static void
-_request_master(struct harbor *h, const char name[GLOBALNAME_LENGTH], size_t i, uint32_t handle) {
-	uint8_t buffer[4+i];
-	to_bigendian(buffer, handle);
-	memcpy(buffer+4,name,i);
-
-	_send_package(h->ctx, h->master_fd, buffer, 4+i);
-}
-
-/*
-	update global name to master
-
-	2 bytes (size)
-	4 bytes (handle) (handle == 0 for request)
-	n bytes string (name)
- */
-
 static int
-_remote_send_handle(struct harbor *h, uint32_t source, uint32_t destination, int type, int session, const char * msg, size_t sz) {
+remote_send_handle(struct harbor *h, uint32_t source, uint32_t destination, int type, int session, const char * msg, size_t sz) {
 	int harbor_id = destination >> HANDLE_REMOTE_SHIFT;
-	assert(harbor_id != 0);
 	struct skynet_context * context = h->ctx;
 	if (harbor_id == h->id) {
 		// local message
@@ -393,56 +504,117 @@ _remote_send_handle(struct harbor *h, uint32_t source, uint32_t destination, int
 		return 1;
 	}
 
-	int fd = h->remote_fd[harbor_id];
+	struct slave * s = &h->s[harbor_id];
-	if (fd >= 0 && h->connected[harbor_id]) {
+	if (s->fd == 0 || s->status == STATUS_HANDSHAKE) {
+		if (s->status == STATUS_DOWN) {
+			// throw an error return to source
+			// report the destination is dead
+			skynet_send(context, destination, source, PTYPE_ERROR, 0 , NULL, 0);
+			skynet_error(context, "Drop message to harbor %d from %x to %x (session = %d, msgsz = %d)",harbor_id, source, destination,session,(int)sz);
+		} else {
+			if (s->queue == NULL) {
+				s->queue = new_queue();
+			}
+			struct remote_message_header header;
+			header.source = source;
+			header.destination = (type << HANDLE_REMOTE_SHIFT) | (destination & HANDLE_MASK);
+			header.session = (uint32_t)session;
+			push_queue(s->queue, (void *)msg, sz, &header);
+			return 1;
+		}
+	} else {
 		struct remote_message_header cookie;
 		cookie.source = source;
 		cookie.destination = (destination & HANDLE_MASK) | ((uint32_t)type << HANDLE_REMOTE_SHIFT);
 		cookie.session = (uint32_t)session;
-		_send_remote(context, fd, msg,sz,&cookie);
+		send_remote(context, s->fd, msg,sz,&cookie);
-	} else {
-		// throw an error return to source
-		if (session != 0) {
-			skynet_send(context, destination, source, PTYPE_RESERVED_ERROR, session, NULL, 0);
-		}
-		skynet_error(context, "Drop message to harbor %d from %x to %x (session = %d, msgsz = %d)",harbor_id, source, destination,session,(int)sz);
 	}
+
 	return 0;
 }
 
-static void
-_remote_register_name(struct harbor *h, const char name[GLOBALNAME_LENGTH], uint32_t handle) {
-	int i;
-	for (i=0;i<GLOBALNAME_LENGTH;i++) {
-		if (name[i] == '\0')
-			break;
-	}
-	if (handle != 0) {
-		_update_remote_name(h, name, handle);
-	}
-	_request_master(h, name,i,handle);
-}
-
 static int
-_remote_send_name(struct harbor *h, uint32_t source, const char name[GLOBALNAME_LENGTH], int type, int session, const char * msg, size_t sz) {
+remote_send_name(struct harbor *h, uint32_t source, const char name[GLOBALNAME_LENGTH], int type, int session, const char * msg, size_t sz) {
-	struct keyvalue * node = _hash_search(h->map, name);
+	struct keyvalue * node = hash_search(h->map, name);
 	if (node == NULL) {
-		node = _hash_insert(h->map, name);
+		node = hash_insert(h->map, name);
 	}
 	if (node->value == 0) {
 		if (node->queue == NULL) {
-			node->queue = _new_queue();
+			node->queue = new_queue();
 		}
 		struct remote_message_header header;
 		header.source = source;
 		header.destination = type << HANDLE_REMOTE_SHIFT;
 		header.session = (uint32_t)session;
-		_push_queue(node->queue, msg, sz, &header);
+		push_queue(node->queue, (void *)msg, sz, &header);
-		// 0 for request
+		char query[2+GLOBALNAME_LENGTH+1] = "Q ";
-		_remote_register_name(h, name, 0);
+		query[2+GLOBALNAME_LENGTH] = 0;
+		memcpy(query+2, name, GLOBALNAME_LENGTH);
+		skynet_send(h->ctx, 0, h->slave, PTYPE_TEXT, 0, query, strlen(query));
 		return 1;
 	} else {
-		return _remote_send_handle(h, source, node->value, type, session, msg, sz);
+		return remote_send_handle(h, source, node->value, type, session, msg, sz);
+	}
+}
+
+static void
+handshake(struct harbor *h, int id) {
+	struct slave *s = &h->s[id];
+	uint8_t * handshake = skynet_malloc(1);
+	handshake[0] = (uint8_t)h->id;
+	skynet_socket_send(h->ctx, s->fd, handshake, 1);
+}
+
+static void
+harbor_command(struct harbor * h, const char * msg, size_t sz, int session, uint32_t source) {
+	const char * name = msg + 2;
+	int s = (int)sz;
+	s -= 2;
+	switch(msg[0]) {
+	case 'N' : {
+		if (s <=0 || s>= GLOBALNAME_LENGTH) {
+			skynet_error(h->ctx, "Invalid global name %s", name);
+			return;
+		}
+		struct remote_name rn;
+		memset(&rn, 0, sizeof(rn));
+		memcpy(rn.name, name, s);
+		rn.handle = source;
+		update_name(h, rn.name, rn.handle);
+		break;
+	}
+	case 'S' :
+	case 'A' : {
+		char buffer[s+1];
+		memcpy(buffer, name, s);
+		buffer[s] = 0;
+		int fd=0, id=0;
+		sscanf(buffer, "%d %d",&fd,&id);
+		if (fd == 0 || id <= 0 || id>=REMOTE_MAX) {
+			skynet_error(h->ctx, "Invalid command %c %s", msg[0], buffer);
+			return;
+		}
+		struct slave * slave = &h->s[id];
+		if (slave->fd != 0) {
+			skynet_error(h->ctx, "Harbor %d alreay exist", id);
+			return;
+		}
+		slave->fd = fd;
+
+		skynet_socket_start(h->ctx, fd);
+		handshake(h, id);
+		if (msg[0] == 'S') {
+			slave->status = STATUS_HANDSHAKE;
+		} else {
+			slave->status = STATUS_HEADER;
+			dispatch_queue(h,id);
+		}
+		break;
+	}
+	default:
+		skynet_error(h->ctx, "Unknown command %s", msg);
+		return;
 	}
 }
 
@@ -450,105 +622,57 @@ static int
 harbor_id(struct harbor *h, int fd) {
 	int i;
 	for (i=1;i<REMOTE_MAX;i++) {
-		if (h->remote_fd[i] == fd)
+		struct slave *s = &h->s[i];
+		if (s->fd == fd) {
 			return i;
 		}
+	}
 	return 0;
 }
 
-static void
-close_harbor(struct harbor *h, int fd) {
-	int id = harbor_id(h,fd);
-	if (id == 0)
-		return;
-	skynet_error(h->ctx, "Harbor %d closed",id);
-	skynet_socket_close(h->ctx, fd);
-	h->remote_fd[id] = -1;
-	h->connected[id] = false;
-}
-
-static void
-open_harbor(struct harbor *h, int fd) {
-	int id = harbor_id(h,fd);
-	if (id == 0)
-		return;
-	assert(h->connected[id] == false);
-	h->connected[id] = true;
-}
-
 static int
-_mainloop(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
+mainloop(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
 	struct harbor * h = ud;
 	switch (type) {
 	case PTYPE_SOCKET: {
 		const struct skynet_socket_message * message = msg;
 		switch(message->type) {
 		case SKYNET_SOCKET_TYPE_DATA:
+			push_socket_data(h, message);
 			skynet_free(message->buffer);
-			skynet_error(context, "recv invalid socket message (size=%d)", message->ud);
-			break;
-		case SKYNET_SOCKET_TYPE_ACCEPT:
-			skynet_error(context, "recv invalid socket accept message");
 			break;
 		case SKYNET_SOCKET_TYPE_ERROR:
-		case SKYNET_SOCKET_TYPE_CLOSE:
+		case SKYNET_SOCKET_TYPE_CLOSE: {
-			close_harbor(h, message->id);
+			int id = harbor_id(h, message->id);
+			if (id) {
+				report_harbor_down(h,id);
+			} else {
+				skynet_error(context, "Unkown fd (%d) closed", message->id);
+			}
 			break;
+		}
 		case SKYNET_SOCKET_TYPE_CONNECT:
-			open_harbor(h, message->id);
+			// fd forward to this service
+			break;
+		default:
+			skynet_error(context, "recv invalid socket message type %d", type);
 			break;
 		}
 		return 0;
 	}
 	case PTYPE_HARBOR: {
-		// remote message in
+		harbor_command(h, msg,sz,session,source);
-		const char * cookie = msg;
-		cookie += sz - 12;
-		struct remote_message_header header;
-		_message_to_header((const uint32_t *)cookie, &header);
-		if (header.source == 0) {
-			if (header.destination < REMOTE_MAX) {
-				// 1 byte harbor id (0~255)
-				// update remote harbor address
-				char ip [sz - 11];
-				memcpy(ip, msg, sz-12);
-				ip[sz-11] = '\0';
-				_update_remote_address(h, header.destination, ip);
-			} else {
-				// update global name
-				if (sz - 12 > GLOBALNAME_LENGTH) {
-					char name[sz-11];
-					memcpy(name, msg, sz-12);
-					name[sz-11] = '\0';
-					skynet_error(context, "Global name is too long %s", name);
-				}
-				_update_remote_name(h, msg, header.destination);
-			}
-		} else {
-			uint32_t destination = header.destination;
-			int type = (destination >> HANDLE_REMOTE_SHIFT) | PTYPE_TAG_DONTCOPY;
-			destination = (destination & HANDLE_MASK) | ((uint32_t)h->id << HANDLE_REMOTE_SHIFT);
-			skynet_send(context, header.source, destination, type, (int)header.session, (void *)msg, sz-12);
-			return 1;
-		}
-		return 0;
-	}
-	case PTYPE_SYSTEM: {
-		// register name message
-		const struct remote_message *rmsg = msg;
-		assert (sz == sizeof(rmsg->destination));
-		_remote_register_name(h, rmsg->destination.name, rmsg->destination.handle);
 		return 0;
 	}
 	default: {
 		// remote message out
 		const struct remote_message *rmsg = msg;
 		if (rmsg->destination.handle == 0) {
-			if (_remote_send_name(h, source , rmsg->destination.name, type, session, rmsg->message, rmsg->sz)) {
+			if (remote_send_name(h, source , rmsg->destination.name, type, session, rmsg->message, rmsg->sz)) {
 				return 0;
 			}
 		} else {
-			if (_remote_send_handle(h, source , rmsg->destination.handle, type, session, rmsg->message, rmsg->sz)) {
+			if (remote_send_handle(h, source , rmsg->destination.handle, type, session, rmsg->message, rmsg->sz)) {
 				return 0;
 			}
 		}
@@ -558,46 +682,19 @@ _mainloop(struct skynet_context * context, void * ud, int type, int session, uin
 	}
 }
 
-static void
-_launch_gate(struct skynet_context * ctx, const char * local_addr) {
-	char tmp[128];
-	sprintf(tmp,"gate L ! %s %d %d 0",local_addr, PTYPE_HARBOR, REMOTE_MAX);
-	const char * gate_addr = skynet_command(ctx, "LAUNCH", tmp);
-	if (gate_addr == NULL) {
-		fprintf(stderr, "Harbor : launch gate failed\n");
-		exit(1);
-	}
-	uint32_t gate = strtoul(gate_addr+1 , NULL, 16);
-	if (gate == 0) {
-		fprintf(stderr, "Harbor : launch gate invalid %s", gate_addr);
-		exit(1);
-	}
-	const char * self_addr = skynet_command(ctx, "REG", NULL);
-	int n = sprintf(tmp,"broker %s",self_addr);
-	skynet_send(ctx, 0, gate, PTYPE_TEXT, 0, tmp, n);
-	skynet_send(ctx, 0, gate, PTYPE_TEXT, 0, "start", 5);
-}
-
 int
 harbor_init(struct harbor *h, struct skynet_context *ctx, const char * args) {
 	h->ctx = ctx;
-	int sz = strlen(args)+1;
-	char master_addr[sz];
-	char local_addr[sz];
 	int harbor_id = 0;
-	sscanf(args,"%s %s %d",master_addr, local_addr, &harbor_id);
+	uint32_t slave = 0;
-	h->master_addr = skynet_strdup(master_addr);
+	sscanf(args,"%d %u", &harbor_id, &slave);
-	h->id = harbor_id;
+	if (slave == 0) {
-	h->master_fd = _connect_to(h, master_addr, true);
+		return 1;
-	if (h->master_fd == -1) {
-		fprintf(stderr, "Harbor: Connect to master failed\n");
-		exit(1);
 	}
-	h->local_addr = skynet_strdup(local_addr);
+	h->id = harbor_id;
-
+	h->slave = slave;
-	_launch_gate(ctx, local_addr);
+	skynet_callback(ctx, h, mainloop);
-	skynet_callback(ctx, h, _mainloop);
+	skynet_harbor_start(ctx);
-	_request_master(h, local_addr, strlen(local_addr), harbor_id);
 
 	return 0;
 }

service-src/service_logger.c

@@ -28,7 +28,7 @@ logger_release(struct logger * inst) {
 static int
 _logger(struct skynet_context * context, void *ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
 	struct logger * inst = ud;
-	fprintf(inst->handle, "[:%x] ",source);
+	fprintf(inst->handle, "[:%08x] ",source);
 	fwrite(msg, sz , 1, inst->handle);
 	fprintf(inst->handle, "\n");
 	fflush(inst->handle);

service-src/service_lua.h

@@ -1,10 +0,0 @@
-#ifndef SKYNET_SERVICE_LUA_H
-#define SKYNET_SERVICE_LUA_H
-
-struct snlua {
-	lua_State * L;
-	struct skynet_context * ctx;
-	int (*init)(struct snlua *l, struct skynet_context *ctx, const char * args);
-};
-
-#endif

service-src/service_master.c

@@ -1,313 +0,0 @@
-#include "skynet.h"
-#include "skynet_harbor.h"
-#include "skynet_socket.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <string.h>
-#include <assert.h>
-#include <stdint.h>
-
-#define HASH_SIZE 4096
-
-struct name {
-	struct name * next;
-	char key[GLOBALNAME_LENGTH];
-	uint32_t hash;
-	uint32_t value;
-};
-
-struct namemap {
-	struct name *node[HASH_SIZE];
-};
-
-struct master {
-	struct skynet_context *ctx;
-	int remote_fd[REMOTE_MAX];
-	bool connected[REMOTE_MAX];
-	char * remote_addr[REMOTE_MAX];
-	struct namemap map;
-};
-
-struct master *
-master_create() {
-	struct master *m = skynet_malloc(sizeof(*m));
-	int i;
-	for (i=0;i<REMOTE_MAX;i++) {
-		m->remote_fd[i] = -1;
-		m->remote_addr[i] = NULL;
-		m->connected[i] = false;
-	}
-	memset(&m->map, 0, sizeof(m->map));
-	return m;
-}
-
-void
-master_release(struct master * m) {
-	int i;
-	struct skynet_context *ctx = m->ctx;
-	for (i=0;i<REMOTE_MAX;i++) {
-		int fd = m->remote_fd[i];
-		if (fd >= 0) {
-			assert(ctx);
-			skynet_socket_close(ctx, fd);
-		}
-		skynet_free(m->remote_addr[i]);
-	}
-	for (i=0;i<HASH_SIZE;i++) {
-		struct name * node = m->map.node[i];
-		while (node) {
-			struct name * next = node->next;
-			skynet_free(node);
-			node = next;
-		}
-	}
-	skynet_free(m);
-}
-
-static struct name *
-_search_name(struct master *m, char name[GLOBALNAME_LENGTH]) {
-	uint32_t *ptr = (uint32_t *) name;
-	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
-	struct name * node = m->map.node[h % HASH_SIZE];
-	while (node) {
-		if (node->hash == h && strncmp(node->key, name, GLOBALNAME_LENGTH) == 0) {
-			return node;
-		}
-		node = node->next;
-	}
-	return NULL;
-}
-
-static struct name *
-_insert_name(struct master *m, char name[GLOBALNAME_LENGTH]) {
-	uint32_t *ptr = (uint32_t *)name;
-	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
-	struct name **pname = &m->map.node[h % HASH_SIZE];
-	struct name * node = skynet_malloc(sizeof(*node));
-	memcpy(node->key, name, GLOBALNAME_LENGTH);
-	node->next = *pname;
-	node->hash = h;
-	node->value = 0;
-	*pname = node;
-	return node;
-}
-
-static void
-_copy_name(char *name, const char * buffer, size_t sz) {
-	if (sz < GLOBALNAME_LENGTH) {
-		memcpy(name, buffer, sz);
-		memset(name+sz, 0 , GLOBALNAME_LENGTH - sz);
-	} else {
-		memcpy(name, buffer, GLOBALNAME_LENGTH);
-	}
-}
-
-static void
-_connect_to(struct master *m, int id) {
-	assert(m->connected[id] == false);
-	struct skynet_context * ctx = m->ctx;
-	const char *ipaddress = m->remote_addr[id];
-	char * portstr = strchr(ipaddress,':');
-	if (portstr==NULL) {
-		skynet_error(ctx, "Harbor %d : address invalid (%s)",id, ipaddress);
-		return;
-	}
-	int sz = portstr - ipaddress;
-	char tmp[sz + 1];
-	memcpy(tmp,ipaddress,sz);
-	tmp[sz] = '\0';
-	int port = strtol(portstr+1,NULL,10);
-	skynet_error(ctx, "Master connect to harbor(%d) %s:%d", id, tmp, port);
-	m->remote_fd[id] = skynet_socket_connect(ctx, tmp, port);
-}
-
-static inline void
-to_bigendian(uint8_t *buffer, uint32_t n) {
-	buffer[0] = (n >> 24) & 0xff;
-	buffer[1] = (n >> 16) & 0xff;
-	buffer[2] = (n >> 8) & 0xff;
-	buffer[3] = n & 0xff;
-}
-
-static void
-_send_to(struct master *m, int id, const void * buf, int sz, uint32_t handle) {
-	uint8_t * buffer= (uint8_t *)skynet_malloc(4 + sz + 12);
-	to_bigendian(buffer, sz+12);
-	memcpy(buffer+4, buf, sz);
-	to_bigendian(buffer+4+sz, 0);
-	to_bigendian(buffer+4+sz+4, handle);
-	to_bigendian(buffer+4+sz+8, 0);
-
-	sz += 4 + 12;
-
-	if (skynet_socket_send(m->ctx, m->remote_fd[id], buffer, sz)) {
-		skynet_error(m->ctx, "Harbor %d : send error", id);
-	}
-}
-
-static void
-_broadcast(struct master *m, const char *name, size_t sz, uint32_t handle) {
-	int i;
-	for (i=1;i<REMOTE_MAX;i++) {
-		int fd = m->remote_fd[i];
-		if (fd < 0 || m->connected[i]==false)
-			continue;
-		_send_to(m, i , name, sz, handle);
-	}
-}
-
-static void
-_request_name(struct master *m, const char * buffer, size_t sz) {
-	char name[GLOBALNAME_LENGTH];
-	_copy_name(name, buffer, sz);
-	struct name * n = _search_name(m, name);
-	if (n == NULL) {
-		return;
-	}
-	_broadcast(m, name, GLOBALNAME_LENGTH, n->value);
-}
-
-static void
-_update_name(struct master *m, uint32_t handle, const char * buffer, size_t sz) {
-	char name[GLOBALNAME_LENGTH];
-	_copy_name(name, buffer, sz);
-	struct name * n = _search_name(m, name);
-	if (n==NULL) {
-		n = _insert_name(m,name);
-	}
-	n->value = handle;
-	_broadcast(m,name,GLOBALNAME_LENGTH, handle);
-}
-
-static void
-close_harbor(struct master *m, int harbor_id) {
-	if (m->connected[harbor_id]) {
-		struct skynet_context * context = m->ctx;
-		skynet_socket_close(context, m->remote_fd[harbor_id]);
-		m->remote_fd[harbor_id] = -1;
-		m->connected[harbor_id] = false;
-	}
-}
-
-static void
-_update_address(struct master *m, int harbor_id, const char * buffer, size_t sz) {
-	if (m->remote_fd[harbor_id] >= 0) {
-		close_harbor(m, harbor_id);
-	}
-	skynet_free(m->remote_addr[harbor_id]);
-	char * addr = skynet_malloc(sz+1);
-	memcpy(addr, buffer, sz);
-	addr[sz] = '\0';
-	m->remote_addr[harbor_id] = addr;
-	_connect_to(m, harbor_id);
-}
-
-static int
-socket_id(struct master *m, int id) {
-	int i;
-	for (i=1;i<REMOTE_MAX;i++) {
-		if (m->remote_fd[i] == id)
-			return i;
-	}
-	return 0;
-}
-
-static void
-on_connected(struct master *m, int id) {
-	_broadcast(m, m->remote_addr[id], strlen(m->remote_addr[id]), id);
-	m->connected[id] = true;
-	int i;
-	for (i=1;i<REMOTE_MAX;i++) {
-		if (i == id)
-			continue;
-		const char * addr = m->remote_addr[i];
-		if (addr == NULL || m->connected[i] == false) {
-			continue;
-		}
-		_send_to(m, id , addr, strlen(addr), i);
-	}
-}
-
-static void
-dispatch_socket(struct master *m, const struct skynet_socket_message *msg, int sz) {
-	int id = socket_id(m, msg->id);
-	switch(msg->type) {
-	case SKYNET_SOCKET_TYPE_CONNECT:
-		assert(id);
-		on_connected(m, id);
-		break;
-	case SKYNET_SOCKET_TYPE_ERROR:
-		skynet_error(m->ctx, "socket error on harbor %d", id);
-		// go though, close socket
-	case SKYNET_SOCKET_TYPE_CLOSE:
-		close_harbor(m, id);
-		break;
-	default:
-		skynet_error(m->ctx, "Invalid socket message type %d", msg->type);
-		break;
-	}
-}
-
-
-/*
-	update global name to master
-
-	4 bytes (handle) (handle == 0 for request)
-	n bytes string (name)
- */
-
-static int
-_mainloop(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
-	if (type == PTYPE_SOCKET) {
-		dispatch_socket(ud, msg, (int)sz);
-		return 0;
-	}
-	if (type != PTYPE_HARBOR) {
-		skynet_error(context, "None harbor message recv from %x (type = %d)", source, type);
-		return 0;
-	}
-	assert(sz >= 4);
-	struct master *m = ud;
-	const uint8_t *handlen = msg;
-	uint32_t handle = handlen[0]<<24 | handlen[1]<<16 | handlen[2]<<8 | handlen[3];
-	sz -= 4;
-	const char * name = msg;
-	name += 4;
-
-	if (handle == 0) {
-		_request_name(m , name, sz);
-	} else if (handle < REMOTE_MAX) {
-		_update_address(m , handle, name, sz);
-	} else {
-		_update_name(m , handle, name, sz);
-	}
-
-	return 0;
-}
-
-int
-master_init(struct master *m, struct skynet_context *ctx, const char * args) {
-	char tmp[strlen(args) + 32];
-	sprintf(tmp,"gate L ! %s %d %d 0",args,PTYPE_HARBOR,REMOTE_MAX);
-	const char * gate_addr = skynet_command(ctx, "LAUNCH", tmp);
-	if (gate_addr == NULL) {
-		skynet_error(ctx, "Master : launch gate failed");
-		return 1;
-	}
-	uint32_t gate = strtoul(gate_addr+1, NULL, 16);
-	if (gate == 0) {
-		skynet_error(ctx, "Master : launch gate invalid %s", gate_addr);
-		return 1;
-	}
-	const char * self_addr = skynet_command(ctx, "REG", NULL);
-	int n = sprintf(tmp,"broker %s",self_addr);
-	skynet_send(ctx, 0, gate, PTYPE_TEXT, 0, tmp, n);
-	skynet_send(ctx, 0, gate, PTYPE_TEXT, 0, "start", 5);
-
-	skynet_callback(ctx, m, _mainloop);
-
-	m->ctx = ctx;
-	return 0;
-}

service-src/service_snlua.c

@@ -4,13 +4,17 @@
 #include <lualib.h>
 #include <lauxlib.h>
 #include <assert.h>
-#include "service_lua.h"
 
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 
+struct snlua {
+	lua_State * L;
+	struct skynet_context * ctx;
+};
+
 // LUA_CACHELIB may defined in patched lua for shared proto
 #ifdef LUA_CACHELIB
 
@@ -37,114 +41,6 @@ codecache(lua_State *L) {
 
 #endif
 
-// time
-
-#include <time.h>
-#define NANOSEC 1000000000
-
-#if defined(__APPLE__)
-#include <mach/task.h>
-#include <mach/mach.h>
-#endif
-
-static void
-current_time(struct timespec *ti) {
-#if  !defined(__APPLE__)
-	clock_gettime(CLOCK_THREAD_CPUTIME_ID, ti);
-#else
-	struct task_thread_times_info aTaskInfo;
-	mach_msg_type_number_t aTaskInfoCount = TASK_THREAD_TIMES_INFO_COUNT;
-	assert(KERN_SUCCESS == task_info(mach_task_self(), TASK_THREAD_TIMES_INFO, (task_info_t )&aTaskInfo, &aTaskInfoCount));
-	ti->tv_sec = aTaskInfo.user_time.seconds;
-	ti->tv_nsec = aTaskInfo.user_time.microseconds * 1000;
-#endif
-}
-
-static double
-diff_time(struct timespec *ti) {
-	struct timespec end;
-	current_time(&end);
-	int diffsec = end.tv_sec - ti->tv_sec;
-	int diffnsec = end.tv_nsec - ti->tv_nsec;
-	if (diffnsec < 0) {
-		--diffsec;
-		diffnsec += NANOSEC;
-	}
-	return (double)diffsec + (double)diffnsec / NANOSEC;
-}
-
-static int
-_try_load(lua_State *L, const char * path, int pathlen, const char * name) {
-	int namelen = strlen(name);
-	char tmp[pathlen + namelen];
-	int i;
-	for (i=0;i<pathlen;i++) {
-		if (path[i] == '?')
-			break;
-		tmp[i] = path[i];
-	}
-	if (path[i] == '?') {
-		memcpy(tmp+i,name,namelen);
-		memcpy(tmp+i+namelen,path+i+1,pathlen - i -1);
-	} else {
-		fprintf(stderr,"snlua : Invalid lua service path\n");
-		exit(1);
-	}
-	tmp[namelen+pathlen-1] = '\0';
-	int r = luaL_loadfile(L,tmp);
-	if (r == LUA_OK) {
-		int i;
-		for (i=namelen+pathlen-2;i>=0;i--) {
-			if (tmp[i] == '/') {
-				lua_pushlstring(L,tmp,i+1);
-				lua_setglobal(L,"SERVICE_PATH");
-				break;
-			}
-		}
-		if (i<0) {
-			return 0;
-		}
-		lua_getglobal(L,"package");
-		lua_getfield(L,-1,"path");
-		luaL_Buffer b;
-		luaL_buffinit(L, &b);
-		luaL_addlstring(&b, tmp, i+1);
-		luaL_addstring(&b, "?.lua;");
-		luaL_addvalue(&b);
-		luaL_pushresult(&b);
-		lua_setfield(L,-2,"path");
-		lua_pop(L,1);
-		return 0;
-	} else if (r == LUA_ERRFILE) {
-		lua_pop(L,1);
-		return -1;
-	}
-	return 1;
-}
-
-static int
-_load(lua_State *L, char ** filename) {
-	const char * name = strsep(filename, " \r\n");
-	const char * path = skynet_command(NULL, "GETENV", "luaservice");
-	while (path[0]) {
-		int pathlen;
-		char * pathend = strchr(path,';');
-		if (pathend) {
-			pathlen = pathend - path;
-		} else {
-			pathlen = strlen(path);
-		}
-		int r = _try_load(L, path, pathlen, name);
-		if (r >=0) {
-			return r;
-		}
-		path+=pathlen;
-		if (path[0]==';')
-			++path;
-	}
-	return -1;
-}
-
 static int 
 traceback (lua_State *L) {
 	const char *msg = lua_tostring(L, 1);
@@ -156,80 +52,70 @@ traceback (lua_State *L) {
 	return 1;
 }
 
-static void
-_report_error(lua_State *L, struct skynet_context *ctx, const char *filename, int err) {
-	switch (err) {
-	case LUA_ERRRUN:
-		skynet_error(ctx, "lua do [%s] error : %s", filename, lua_tostring(L,-1));
-		break;
-	case LUA_ERRMEM:
-		skynet_error(ctx, "lua memory error : %s",filename);
-		break;
-	case LUA_ERRERR:
-		skynet_error(ctx, "lua message error : %s",filename);
-		break;
-	case LUA_ERRGCMM:
-		skynet_error(ctx, "lua gc error : %s",filename);
-		break;
-	};
-	lua_pop(L,1);
-}
-
 static void
 _report_launcher_error(struct skynet_context *ctx) {
 	// sizeof "ERROR" == 5
 	skynet_sendname(ctx, ".launcher", PTYPE_TEXT, 0, "ERROR", 5);
 }
 
+static const char *
+optstring(struct skynet_context *ctx, const char *key, const char * str) {
+	const char * ret = skynet_command(ctx, "GETENV", key);
+	if (ret == NULL) {
+		return str;
+	}
+	return ret;
+}
+
 static int
-_init(struct snlua *l, struct skynet_context *ctx, const char * args) {
+_init(struct snlua *l, struct skynet_context *ctx, const char * args, size_t sz) {
 	lua_State *L = l->L;
 	l->ctx = ctx;
 	lua_gc(L, LUA_GCSTOP, 0);
+	lua_pushboolean(L, 1);  /* signal for libraries to ignore env. vars. */
+	lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
 	luaL_openlibs(L);
-	lua_pushlightuserdata(L, l);
+	lua_pushlightuserdata(L, ctx);
-	lua_setfield(L, LUA_REGISTRYINDEX, "skynet_lua");
+	lua_setfield(L, LUA_REGISTRYINDEX, "skynet_context");
 	luaL_requiref(L, "skynet.codecache", codecache , 0);
 	lua_pop(L,1);
-	lua_gc(L, LUA_GCRESTART, 0);
 
-	char tmp[strlen(args)+1];
+	const char *path = optstring(ctx, "lua_path","./lualib/?.lua;./lualib/?/init.lua");
-	char *parm = tmp;
+	lua_pushstring(L, path);
-	strcpy(parm,args);
+	lua_setglobal(L, "LUA_PATH");
+	const char *cpath = optstring(ctx, "lua_cpath","./luaclib/?.so");
+	lua_pushstring(L, cpath);
+	lua_setglobal(L, "LUA_CPATH");
+	const char *service = optstring(ctx, "luaservice", "./service/?.lua");
+	lua_pushstring(L, service);
+	lua_setglobal(L, "LUA_SERVICE");
+	const char *preload = skynet_command(ctx, "GETENV", "preload");
+	lua_pushstring(L, preload);
+	lua_setglobal(L, "LUA_PRELOAD");
 
 	lua_pushcfunction(L, traceback);
-	int traceback_index = lua_gettop(L);
+	assert(lua_gettop(L) == 1);
-	assert(traceback_index == 1);
 
-	const char * filename = parm;
+	const char * loader = optstring(ctx, "lualoader", "./lualib/loader.lua");
-	int r = _load(L, &parm);
+
-	if (r != 0) {
+	int r = luaL_loadfile(L,loader);
-		if (r<0) {
+	if (r != LUA_OK) {
-			skynet_error(ctx, "lua parser [%s] load error", filename);
+		skynet_error(ctx, "Can't load %s : %s", loader, lua_tostring(L, -1));
-		} else {
-			skynet_error(ctx, "lua parser [%s] error : %s", filename, lua_tostring(L,-1));
-		}
 		_report_launcher_error(ctx);
 		return 1;
 	}
-	int n=0;
+	lua_pushlstring(L, args, sz);
-	while(parm) {
+	r = lua_pcall(L,1,0,1);
-		const char * arg = strsep(&parm, " \r\n");
+	if (r != LUA_OK) {
-		if (arg && arg[0]!='\0') {
+		skynet_error(ctx, "lua loader error : %s", lua_tostring(L, -1));
-			lua_pushstring(L, arg);
+		_report_launcher_error(ctx);
-			++n;
+		return 1;
 	}
-	}
+	lua_settop(L,0);
-	r = lua_pcall(L,n,0,traceback_index);
+
-	if (r == LUA_OK) {
+	lua_gc(L, LUA_GCRESTART, 0);
-		r = lua_gc(L, LUA_GCCOLLECT, 0);
+
-		if (r == LUA_OK) {
 	return 0;
-		}
-	}
-	_report_error(L, ctx, filename, r);
-	_report_launcher_error(ctx);
-	return 1;
 }
 
 static int
@@ -237,12 +123,7 @@ _launch(struct skynet_context * context, void *ud, int type, int session, uint32
 	assert(type == 0 && session == 0);
 	struct snlua *l = ud;
 	skynet_callback(context, NULL, NULL);
-	struct timespec ti;
+	int err = _init(l, context, msg, sz);
-	current_time(&ti);
-	int err = _init(l, context, msg);
-	double t = diff_time(&ti);
-	lua_pushnumber(l->L, t);
-	lua_setfield(l->L, LUA_REGISTRYINDEX, "skynet_boottime");
 	if (err) {
 		skynet_command(context, "EXIT", NULL);
 	}
@@ -253,13 +134,13 @@ _launch(struct skynet_context * context, void *ud, int type, int session, uint32
 int
 snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) {
 	int sz = strlen(args);
-	char * tmp = skynet_malloc(sz+1);
+	char * tmp = skynet_malloc(sz);
-	memcpy(tmp, args, sz+1);
+	memcpy(tmp, args, sz);
 	skynet_callback(ctx, l , _launch);
 	const char * self = skynet_command(ctx, "REG", NULL);
 	uint32_t handle_id = strtoul(self+1, NULL, 16);
 	// it must be first message
-	skynet_send(ctx, 0, handle_id, PTYPE_TAG_DONTCOPY,0, tmp, sz+1);
+	skynet_send(ctx, 0, handle_id, PTYPE_TAG_DONTCOPY,0, tmp, sz);
 	return 0;
 }
 
@@ -268,7 +149,6 @@ snlua_create(void) {
 	struct snlua * l = skynet_malloc(sizeof(*l));
 	memset(l,0,sizeof(*l));
 	l->L = lua_newstate(skynet_lalloc, NULL);
-	l->init = _init;
 	return l;
 }
 

service/bootstrap.lua

@@ -0,0 +1,43 @@
+local skynet = require "skynet"
+local harbor = require "skynet.harbor"
+
+skynet.start(function()
+	local standalone = skynet.getenv "standalone"
+
+	local launcher = assert(skynet.launch("snlua","launcher"))
+	skynet.name(".launcher", launcher)
+
+	local harbor_id = tonumber(skynet.getenv "harbor")
+	if harbor_id == 0 then
+		assert(standalone ==  nil)
+		standalone = true
+		skynet.setenv("standalone", "true")
+
+		local slave = skynet.newservice "cdummy"
+		if slave == nil then
+			skynet.abort()
+		end
+		skynet.name(".slave", slave)
+
+	else
+		if standalone then
+			if not skynet.newservice "cmaster" then
+				skynet.abort()
+			end
+		end
+
+		local slave = skynet.newservice "cslave"
+		if slave == nil then
+			skynet.abort()
+		end
+		skynet.name(".slave", slave)
+	end
+
+	if standalone then
+		local datacenter = assert(skynet.newservice "datacenterd")
+		skynet.name("DATACENTER", datacenter)
+	end
+	assert(skynet.newservice "service_mgr")
+	assert(skynet.newservice(skynet.getenv "start" or "main"))
+	skynet.exit()
+end)

service/cdummy.lua

@@ -0,0 +1,47 @@
+local skynet = require "skynet"
+
+local globalname = {}
+local harbor = {}
+
+skynet.register_protocol {
+	name = "harbor",
+	id = skynet.PTYPE_HARBOR,
+	pack = function(...) return ... end,
+	unpack = skynet.tostring,
+}
+
+skynet.register_protocol {
+	name = "text",
+	id = skynet.PTYPE_TEXT,
+	pack = function(...) return ... end,
+	unpack = skynet.tostring,
+}
+
+function harbor.REGISTER(name, handle)
+	assert(globalname[name] == nil)
+	globalname[name] = handle
+	skynet.redirect(harbor_service, handle, "harbor", 0, "N " .. name)
+end
+
+function harbor.LINK(id)
+	skynet.ret()
+end
+
+function harbor.CONNECT(id)
+	skynet.error("Can't connect to other harbor in single node mode")
+end
+
+skynet.start(function()
+	local harbor_id = tonumber(skynet.getenv "harbor")
+	assert(harbor_id == 0)
+
+	skynet.dispatch("lua", function (session,source,command,...)
+		local f = assert(harbor[command])
+		f(...)
+	end)
+	skynet.dispatch("text", function(session,source,command)
+		-- ignore all the command
+	end)
+
+	harbor_service = assert(skynet.launch("harbor", harbor_id, skynet.self()))
+end)

service/clusterd.lua

@@ -0,0 +1,90 @@
+local skynet = require "skynet"
+local sc = require "socketchannel"
+local socket = require "socket"
+local cluster = require "cluster.c"
+
+local config_name = skynet.getenv "cluster"
+local node_address = {}
+
+local function loadconfig()
+	local f = assert(io.open(config_name))
+	local source = f:read "*a"
+	f:close()
+	assert(load(source, "@"..config_name, "t", node_address))()
+end
+
+local node_session = {}
+local command = {}
+
+local function read_response(sock)
+	local sz = socket.header(sock:read(2))
+	local msg = sock:read(sz)
+	return cluster.unpackresponse(msg)	-- session, ok, data
+end
+
+local function open_channel(t, key)
+	local host, port = string.match(node_address[key], "([^:]+):(.*)$")
+	local c = sc.channel {
+		host = host,
+		port = tonumber(port),
+		response = read_response,
+	}
+	assert(c:connect(true))
+	t[key] = c
+	node_session[key] = 1
+	return c
+end
+
+local node_channel = setmetatable({}, { __index = open_channel })
+
+function command.reload()
+	loadconfig()
+	skynet.ret(skynet.pack(nil))
+end
+
+function command.listen(source, addr, port)
+	local gate = skynet.newservice("gate")
+	if port == nil then
+		addr, port = string.match(node_address[addr], "([^:]+):(.*)$")
+	end
+	skynet.call(gate, "lua", "open", { address = addr, port = port })
+	skynet.ret(skynet.pack(nil))
+end
+
+function command.req(source, node, addr, msg, sz)
+	local request
+	local c = node_channel[node]
+	local session = node_session[node]
+	-- msg is a local pointer, cluster.packrequest will free it
+	request, node_session[node] = cluster.packrequest(addr, session , msg, sz)
+	skynet.ret(c:request(request, session))
+end
+
+local request_fd = {}
+
+function command.socket(source, subcmd, fd, msg)
+	if subcmd == "data" then
+		local addr, session, msg = cluster.unpackrequest(msg)
+		local ok , msg, sz = pcall(skynet.rawcall, addr, "lua", msg)
+		local response
+		if ok then
+			response = cluster.packresponse(session, true, msg, sz)
+		else
+			response = cluster.packresponse(session, false, msg)
+		end
+		socket.write(fd, response)
+	elseif subcmd == "open" then
+		skynet.error(string.format("socket accept from %s", msg))
+		skynet.call(source, "lua", "accept", fd)
+	else
+		skynet.error(string.format("socket %s %d : %s", subcmd, fd, msg))
+	end
+end
+
+skynet.start(function()
+	loadconfig()
+	skynet.dispatch("lua", function(session , source, cmd, ...)
+		local f = assert(command[cmd])
+		f(source, ...)
+	end)
+end)

service/cmaster.lua

@@ -0,0 +1,125 @@
+local skynet = require "skynet"
+local socket = require "socket"
+
+--[[
+	master manage data :
+		1. all the slaves address : id -> ipaddr:port
+		2. all the global names : name -> address
+
+	master hold connections from slaves .
+
+	protocol slave->master :
+		package size 1 byte
+		type 1 byte :
+			'H' : HANDSHAKE, report slave id, and address.
+			'R' : REGISTER name address
+			'Q' : QUERY name
+
+
+	protocol master->slave:
+		package size 1 byte
+		type 1 byte :
+			'W' : WAIT n
+			'C' : CONNECT slave_id slave_address
+			'N' : NAME globalname address
+			'D' : DISCONNECT slave_id
+]]
+
+local slave_node = {}
+local global_name = {}
+
+local function read_package(fd)
+	local sz = socket.read(fd, 1)
+	assert(sz, "closed")
+	sz = string.byte(sz)
+	local content = socket.read(fd, sz)
+	return skynet.unpack(content)
+end
+
+local function pack_package(...)
+	local message = skynet.packstring(...)
+	local size = #message
+	assert(size <= 255 , "too long")
+	return string.char(size) .. message
+end
+
+local function report_slave(fd, slave_id, slave_addr)
+	local message = pack_package("C", slave_id, slave_addr)
+	local n = 0
+	for k,v in pairs(slave_node) do
+		if v.fd ~= 0 then
+			socket.write(v.fd, message)
+			n = n + 1
+		end
+	end
+	socket.write(fd, pack_package("W", n))
+end
+
+local function handshake(fd)
+	local t, slave_id, slave_addr = read_package(fd)
+	assert(t=='H', "Invalid handshake type " .. t)
+	assert(slave_id ~= 0 , "Invalid slave id 0")
+	if slave_node[slave_id] then
+		error(string.format("Slave %d already register on %s", slave_id, slave_node[slave_id].addr))
+	end
+	report_slave(fd, slave_id, slave_addr)
+	slave_node[slave_id] = {
+		fd = fd,
+		id = slave_id,
+		addr = slave_addr,
+	}
+	return slave_id , slave_addr
+end
+
+local function dispatch_slave(fd)
+	local t, name, address = read_package(fd)
+	if t == 'R' then
+		-- register name
+		assert(type(address)=="number", "Invalid request")
+		if not global_name[name] then
+			global_name[name] = address
+		end
+		local message = pack_package("N", name, address)
+		for k,v in pairs(slave_node) do
+			socket.write(v.fd, message)
+		end
+	elseif t == 'Q' then
+		-- query name
+		local address = global_name[name]
+		if address then
+			socket.write(fd, pack_package("N", name, address))
+		end
+	else
+		skynet.error("Invalid slave message type " .. t)
+	end
+end
+
+local function monitor_slave(slave_id, slave_address)
+	local fd = slave_node[slave_id].fd
+	skynet.error(string.format("Harbor %d (fd=%d) report %s", slave_id, fd, slave_address))
+	while pcall(dispatch_slave, fd) do end
+	skynet.error("slave " ..slave_id .. " is down")
+	local message = pack_package("D", slave_id)
+	slave_node[slave_id].fd = 0
+	for k,v in pairs(slave_node) do
+		socket.write(v.fd, message)
+	end
+	socket.close(fd)
+end
+
+skynet.start(function()
+	local master_addr = skynet.getenv "standalone"
+	skynet.error("master listen socket " .. tostring(master_addr))
+	local fd = socket.listen(master_addr)
+	socket.start(fd , function(id, addr)
+		skynet.error("connect from " .. addr .. " " .. id)
+		socket.start(id)
+		local ok, slave, slave_addr = pcall(handshake, id)
+		if ok then
+			skynet.fork(monitor_slave, slave, slave_addr)
+		else
+			skynet.error(string.format("disconnect fd = %d, error = %s", id, slave))
+			socket.close(id)
+		end
+	end)
+end)

service/cslave.lua

@@ -0,0 +1,222 @@
+local skynet = require "skynet"
+local socket = require "socket"
+
+local slaves = {}
+local connect_queue = {}
+local globalname = {}
+local harbor = {}
+local harbor_service
+local monitor = {}
+
+local function read_package(fd)
+	local sz = socket.read(fd, 1)
+	assert(sz, "closed")
+	sz = string.byte(sz)
+	local content = socket.read(fd, sz)
+	return skynet.unpack(content)
+end
+
+local function pack_package(...)
+	local message = skynet.packstring(...)
+	local size = #message
+	assert(size <= 255 , "too long")
+	return string.char(size) .. message
+end
+
+local function monitor_clear(id)
+	local v = monitor[id]
+	if v then
+		monitor[id] = nil
+		for _, v in ipairs(v) do
+			skynet.redirect(v.address, 0, "response", v.session, "")
+		end
+	end
+end
+
+local function connect_slave(slave_id, address)
+	local ok, err = pcall(function()
+		if slaves[slave_id] == nil then
+			local fd = assert(socket.open(address), "Can't connect to "..address)
+			skynet.error(string.format("Connect to harbor %d (fd=%d), %s", slave_id, fd, address))
+			slaves[slave_id] = fd
+			monitor_clear(slave_id)
+			socket.abandon(fd)
+			skynet.send(harbor_service, "harbor", string.format("S %d %d",fd,slave_id))
+		end
+	end)
+	if not ok then
+		skynet.error(err)
+	end
+end
+
+local function ready()
+	local queue = connect_queue
+	connect_queue = nil
+	for k,v in pairs(queue) do
+		connect_slave(k,v)
+	end
+	for name,address in pairs(globalname) do
+		skynet.redirect(harbor_service, address, "harbor", "N " .. name)
+	end
+end
+
+local function monitor_master(master_fd)
+	while true do
+		local ok, t, id_name, address = pcall(read_package,master_fd)
+		if ok then
+			if t == 'C' then
+				if connect_queue then
+					connect_queue[id_name] = address
+				else
+					connect_slave(id_name, address)
+				end
+			elseif t == 'N' then
+				globalname[id_name] = address
+				if connect_queue == nil then
+					skynet.redirect(harbor_service, address, "harbor", 0, "N " .. id_name)
+				end
+			elseif t == 'D' then
+				local fd = slaves[id_name]
+				slaves[id_name] = false
+				if fd then
+					socket.close(fd)
+				end
+			end
+		else
+			skynet.error("Master disconnect")
+			socket.close(master_fd)
+			break
+		end
+	end
+end
+
+local function accept_slave(fd)
+	socket.start(fd)
+	local id = socket.read(fd, 1)
+	if not id then
+		skynet.error(string.format("Connection (fd =%d) closed", fd))
+		socket.close(fd)
+		return
+	end
+	id = string.byte(id)
+	if slaves[id] ~= nil then
+		skynet.error(string.format("Slave %d exist (fd =%d)", id, fd))
+		socket.close(fd)
+		return
+	end
+	slaves[id] = fd
+	monitor_clear(id)
+	socket.abandon(fd)
+	skynet.error(string.format("Harbor %d connected (fd = %d)", id, fd))
+	skynet.send(harbor_service, "harbor", string.format("A %d %d", fd, id))
+end
+
+skynet.register_protocol {
+	name = "harbor",
+	id = skynet.PTYPE_HARBOR,
+	pack = function(...) return ... end,
+	unpack = skynet.tostring,
+}
+
+skynet.register_protocol {
+	name = "text",
+	id = skynet.PTYPE_TEXT,
+	pack = function(...) return ... end,
+	unpack = skynet.tostring,
+}
+
+local function monitor_harbor(master_fd)
+	return function(session, source, command)
+		local t = string.sub(command, 1, 1)
+		local arg = string.sub(command, 3)
+		if t == "Q" then
+			-- query name
+			if globalname[arg] then
+				skynet.redirect(harbor_service, globalname[arg], "harbor", 0, "N " .. arg)
+			else
+				socket.write(master_fd, pack_package("Q", arg))
+			end
+		elseif t == "D" then
+			-- harbor down
+			local id = tonumber(arg)
+			if slaves[id] then
+				monitor_clear(id)
+			end
+			slaves[id] = false
+		else
+			skynet.error("Unknown command ", command)
+		end
+	end
+end
+
+function harbor.REGISTER(_,_, fd, name, handle)
+	assert(globalname[name] == nil)
+	globalname[name] = handle
+	socket.write(fd, pack_package("R", name, handle))
+	skynet.redirect(harbor_service, handle, "harbor", 0, "N " .. name)
+end
+
+function harbor.LINK(session, source, fd, id)
+	if slaves[id] then
+		if monitor[id] == nil then
+			monitor[id] = {}
+		end
+		table.insert(monitor[id], { address = source, session = session })
+	else
+		skynet.ret()
+	end
+end
+
+function harbor.CONNECT(session, source, fd, id)
+	if not slaves[id] then
+		if monitor[id] == nil then
+			monitor[id] = {}
+		end
+		table.insert(monitor[id], { address = source, session = session })
+	else
+		skynet.ret()
+	end
+end
+
+skynet.start(function()
+	local master_addr = skynet.getenv "master"
+	local harbor_id = tonumber(skynet.getenv "harbor")
+	local slave_address = assert(skynet.getenv "address")
+	local slave_fd = socket.listen(slave_address)
+	skynet.error("slave connect to master " .. tostring(master_addr))
+	local master_fd = socket.open(master_addr)
+
+	skynet.dispatch("lua", function (session,source,command,...)
+		local f = assert(harbor[command])
+		f(session, source, master_fd, ...)
+	end)
+	skynet.dispatch("text", monitor_harbor(master_fd))
+
+	harbor_service = assert(skynet.launch("harbor", harbor_id, skynet.self()))
+
+	local hs_message = pack_package("H", harbor_id, slave_address)
+	socket.write(master_fd, hs_message)
+	local t, n = read_package(master_fd)
+	assert(t == "W" and type(n) == "number", "slave shakehand failed")
+	skynet.error(string.format("Waiting for %d harbors", n))
+	skynet.fork(monitor_master, master_fd)
+	if n > 0 then
+		local co = coroutine.running()
+		socket.start(slave_fd, function(fd, addr)
+			skynet.error(string.format("New connection (fd = %d, %s)",fd, addr))
+			if pcall(accept_slave,fd) then
+				local s = 0
+				for k,v in pairs(slaves) do
+					s = s + 1
+				end
+				if s >= n then
+					skynet.wakeup(co)
+				end
+			end
+		end)
+		skynet.wait()
+	end
+	socket.close(slave_fd)
+	skynet.error("Shakehand ready")
+	skynet.fork(ready)
+end)

service/datacenterd.lua

@@ -0,0 +1,114 @@
+local skynet = require "skynet"
+
+local command = {}
+local database = {}
+local wait_queue = {}
+local mode = {}
+
+local function query(db, key, ...)
+	if key == nil then
+		return db
+	else
+		return query(db[key], ...)
+	end
+end
+
+function command.QUERY(key, ...)
+	local d = database[key]
+	if d then
+		return query(d, ...)
+	end
+end
+
+local function update(db, key, value, ...)
+	if select("#",...) == 0 then
+		local ret = db[key]
+		db[key] = value
+		return ret, value
+	else
+		if db[key] == nil then
+			db[key] = {}
+		end
+		return update(db[key], value, ...)
+	end
+end
+
+local function wakeup(db, key1, key2, value, ...)
+	if key1 == nil then
+		return
+	end
+	local q = db[key1]
+	if q == nil then
+		return
+	end
+	if q[mode] == "queue" then
+		db[key1] = nil
+		if value then
+			-- throw error because can't wake up a branch
+			for _,v in ipairs(q) do
+				local session = v[1]
+				local source = v[2]
+				skynet.redirect(source, 0, "error", session, "")
+			end
+		else
+			return q
+		end
+	else
+		-- it's branch
+		return wakeup(q , key2, value, ...)
+	end
+end
+
+function command.UPDATE(...)
+	local ret, value = update(database, ...)
+	if ret or value == nil then
+		return ret
+	end
+	local q = wakeup(wait_queue, ...)
+	if q then
+		for _, v in ipairs(q) do
+			local session = v[1]
+			local source = v[2]
+			skynet.redirect(source, 0, "response", session, skynet.pack(value))
+		end
+	end
+end
+
+local function waitfor(session, source, db, key1, key2, ...)
+	if key2 == nil then
+		-- push queue
+		local q = db[key1]
+		if q == nil then
+			q = { [mode] = "queue" }
+			db[key1] = q
+		else
+			assert(q[mode] == "queue")
+		end
+		table.insert(q, { session, source })
+	else
+		local q = db[key1]
+		if q == nil then
+			q = { [mode] = "branch" }
+			db[key1] = q
+		else
+			assert(q[mode] == "branch")
+		end
+		return waitfor(session, source, q, key2, ...)
+	end
+end
+
+skynet.start(function()
+	skynet.dispatch("lua", function (session, source, cmd, ...)
+		if cmd == "WAIT" then
+			local ret = command.QUERY(...)
+			if ret then
+				skynet.ret(skynet.pack(ret))
+			else
+				waitfor(session, source, wait_queue, ...)
+			end
+		else
+			local f = assert(command[cmd])
+			skynet.ret(skynet.pack(f(...)))
+		end
+	end)
+end)

service/debug_console.lua

@@ -1,6 +1,7 @@
 local skynet = require "skynet"
 local codecache = require "skynet.codecache"
 local socket = require "socket"
+local snax = require "snax"
 
 local port = tonumber(...)
 local COMMAND = {}
@@ -87,7 +88,7 @@ end
 
 skynet.start(function()
 	local listen_socket = socket.listen ("127.0.0.1", port)
-	print("Start debug console at 127.0.0.1",port)
+	skynet.error("Start debug console at 127.0.0.1 " .. port)
 	socket.start(listen_socket , function(id, addr)
 		local function print(...)
 			local t = { ... }
@@ -109,7 +110,10 @@ function COMMAND.help()
 		mem = "mem : show memory status",
 		gc = "gc : force every lua service do garbage collect",
 		start = "lanuch a new lua service",
+		snax = "lanuch a new snax service",
 		clearcache = "clear lua code cache",
+		service = "List unique service",
+		task = "task address : show service task detail",
 	}
 end
 
@@ -126,4 +130,16 @@ function COMMAND.start(...)
 	end
 end
 
+function COMMAND.snax(...)
+	local s = snax.newservice(...)
+	if s then
+		local addr = s.handle
+		return { [skynet.address(addr)] = ... }
+	else
+		return "Failed"
+	end
+end
 
+function COMMAND.service()
+	return skynet.call("SERVICE", "lua", "LIST")
+end

service/gate.lua

@@ -8,6 +8,7 @@ local watchdog
 local maxclient
 local client_number = 0
 local CMD = setmetatable({}, { __gc = function() netpack.clear(queue) end })
+local nodelay = false
 
 local connection = {}	-- fd -> connection : { fd , client, agent , ip, mode }
 local forwarding = {}	-- agent -> connection
@@ -22,6 +23,13 @@ function CMD.open( source , conf )
 	socketdriver.start(socket)
 end
 
+function CMD.nodelay(source, v)
+	if v ~= false then
+		v = true
+	end
+	nodelay = v
+end
+
 function CMD.close()
 	assert(socket)
 	socketdriver.close(socket)
@@ -85,7 +93,7 @@ function MSG.data(fd, msg, sz)
 	if agent then
 		skynet.redirect(agent, c.client, "client", 0, msg, sz)
 	else
-		skynet.send(watchdog, "lua", "socket", "data", netpack.tostring(msg, sz))
+		skynet.send(watchdog, "lua", "socket", "data", fd, netpack.tostring(msg, sz))
 	end
 end
 
@@ -106,6 +114,9 @@ function MSG.open(fd, msg)
 	}
 	connection[fd] = c
 	client_number = client_number + 1
+	if nodelay then
+		socketdriver.nodelay(fd)
+	end
 	skynet.send(watchdog, "lua", "socket", "open", fd, msg)
 end
 

service/launcher.lua

@@ -2,8 +2,8 @@ local skynet = require "skynet"
 local string = string
 
 local services = {}
-
 local command = {}
+local instance = {} -- for confirm (function command.LAUNCH / command.ERROR / command.LAUNCHOK)
 
 local function handle_to_address(handle)
 	return tonumber("0x" .. string.sub(handle , 2))
@@ -19,18 +19,6 @@ function command.LIST()
 	return list
 end
 
-function command.RELOAD(handle)
-	handle = handle_to_address(handle)
-	local cmd = string.match(services[handle], "snlua (.+)")
-	print(services[handle],cmd)
-	if cmd then
-		skynet.send(handle,"debug","RELOAD",cmd)
-		return {cmd}
-	else
-		return {"Support only snlua"}
-	end
-end
-
 function command.STAT()
 	local list = {}
 	for k,v in pairs(services) do
@@ -40,7 +28,7 @@ function command.STAT()
 	return list
 end
 
-function command.INFO(handle)
+function command.INFO(_, _, handle)
 	handle = handle_to_address(handle)
 	if services[handle] == nil then
 		return
@@ -50,23 +38,17 @@ function command.INFO(handle)
 	end
 end
 
-function command.TIMING(handle)
+function command.TASK(_, _, handle)
 	handle = handle_to_address(handle)
 	if services[handle] == nil then
 		return
 	else
-		local r = skynet.call(handle,"debug","TIMING")
+		local result = skynet.call(handle,"debug","TASK")
-		local result = {}
-		for k,v in pairs(r) do
-			v.name = services[k]
-			v.avg = v.ti/v.n
-			result[skynet.address(k)] = v
-		end
 		return result
 	end
 end
 
-function command.KILL(handle)
+function command.KILL(_, _, handle)
 	handle = handle_to_address(handle)
 	skynet.kill(handle)
 	local ret = { [skynet.address(handle)] = tostring(services[handle]) }
@@ -90,23 +72,25 @@ function command.GC()
 	return command.MEM()
 end
 
-function command.REMOVE(handle)
+function command.REMOVE(_,_, handle)
 	services[handle] = nil
 	-- don't return (skynet.ret) because the handle may exit
 	return NORET
 end
 
-local instance = {}
+function command.LAUNCH(address, session, service, ...)
-
+	local param = table.concat({...}, " ")
-skynet.dispatch("text" , function(session, address , cmd)
+	local inst = skynet.launch(service, param)
-	if cmd == "" then
+	if inst then
-		-- init notice
+		services[inst] = service .. " " .. param
-		local reply = instance[address]
+		instance[inst] = { session = session, address = address }
-		if reply then
+	else
-			skynet.redirect(reply.address , 0, "response", reply.session, skynet.address(address))
+		skynet.ret("")	-- launch failed
-			instance[address] = nil
 	end
-	elseif cmd == "ERROR" then
+	return NORET
+end
+
+function command.ERROR(address)
 	-- see serivce-src/service_lua.c
 	-- init failed
 	local reply = instance[address]
@@ -114,24 +98,45 @@ skynet.dispatch("text" , function(session, address , cmd)
 		skynet.redirect(reply.address , 0, "response", reply.session, "")
 		instance[address] = nil
 	end
+	services[address] = nil
+	return NORET
+end
+
+function command.LAUNCHOK(address)
+	-- init notice
+	local reply = instance[address]
+	if reply then
+		skynet.redirect(reply.address , 0, "response", reply.session, skynet.address(address))
+		instance[address] = nil
+	end
+
+	return NORET
+end
+
+-- for historical reasons, launcher support text command (for C service)
+
+skynet.register_protocol {
+	name = "text",
+	id = skynet.PTYPE_TEXT,
+	unpack = skynet.tostring,
+	dispatch = function(session, address , cmd)
+		if cmd == "" then
+			command.LAUNCHOK(address)
+		elseif cmd == "ERROR" then
+			command.ERROR(address)
 		else
 			-- launch request
 			local service, param = string.match(cmd,"([^ ]+) (.*)")
-		local inst = skynet.launch(service, param)
+			command.LAUNCH(address, session, service, param)
-		if inst then
-			services[inst] = cmd
-			instance[inst] = { session = session, address = address }
-		else
-			skynet.ret("")
 		end
-	end
+	end,
-end)
+}
 
 skynet.dispatch("lua", function(session, address, cmd , ...)
 	cmd = string.upper(cmd)
 	local f = command[cmd]
 	if f then
-		local ret = f(...)
+		local ret = f(address, session, ...)
 		if ret ~= NORET then
 			skynet.ret(skynet.pack(ret))
 		end

service/multicastd.lua

@@ -0,0 +1,194 @@
+local skynet = require "skynet"
+local mc = require "multicast.c"
+local datacenter = require "datacenter"
+
+local harbor_id = skynet.harbor(skynet.self())
+
+local command = {}
+local channel = {}
+local channel_n = {}
+local channel_remote = {}
+local channel_id = harbor_id
+local NORET = {}
+
+local function get_address(t, id)
+	local v = assert(datacenter.get("multicast", id))
+	t[id] = v
+	return v
+end
+
+local node_address = setmetatable({}, { __index = get_address })
+
+-- new LOCAL channel , The low 8bit is the same with harbor_id
+function command.NEW()
+	while channel[channel_id] do
+		channel_id = mc.nextid(channel_id)
+	end
+	channel[channel_id] = {}
+	channel_n[channel_id] = 0
+	local ret = channel_id
+	channel_id = mc.nextid(channel_id)
+	return ret
+end
+
+-- MUST call by the owner node of channel, delete a remote channel
+function command.DELR(source, c)
+	channel[c] = nil
+	channel_n[c] = nil
+	return NORET
+end
+
+-- delete a channel, if the channel is remote, forward the command to the owner node
+-- otherwise, delete the channel, and call all the remote node, DELR
+function command.DEL(source, c)
+	local node = c % 256
+	if node ~= harbor_id then
+		skynet.send(node_address[node], "lua", "DEL", c)
+		return NORET
+	end
+	local remote = channel_remote[c]
+	channel[c] = nil
+	channel_n[c] = nil
+	channel_remote[c] = nil
+	for node in pairs(remote) do
+		skynet.send(node_address[node], "lua", "DELR", c)
+	end
+	return NORET
+end
+
+-- forward multicast message to a node (channel id use the session field)
+local function remote_publish(node, channel, source, ...)
+	skynet.redirect(node_address[node], source, "multicast", channel, ...)
+end
+
+-- publish a message, for local node, use the message pointer (call mc.bind to add the reference)
+-- for remote node, call remote_publish. (call mc.unpack and skynet.tostring to convert message pointer to string)
+local function publish(c , source, pack, size)
+	local group = channel[c]
+	if group == nil then
+		-- dead channel, delete the pack
+		mc.bind(pack, 1)
+		mc.close(pack)
+		return
+	end
+	mc.bind(pack, channel_n[c])
+	local msg = skynet.tostring(pack, size)
+	for k in pairs(group) do
+		skynet.redirect(k, source, "multicast", c , msg)
+	end
+	local remote = channel_remote[c]
+	if remote then
+		local _, msg, sz = mc.unpack(pack, size)
+		local msg = skynet.tostring(msg,sz)
+		for node in pairs(remote) do
+			remote_publish(node, c, source, msg)
+		end
+	end
+end
+
+skynet.register_protocol {
+	name = "multicast",
+	id = skynet.PTYPE_MULTICAST,
+	unpack = function(msg, sz)
+		return mc.packremote(msg, sz)
+	end,
+	dispatch = publish,
+}
+
+-- publish a message, if the caller is remote, forward the message to the owner node (by remote_publish)
+-- If the caller is local, call publish
+function command.PUB(source, c, pack, size)
+	assert(skynet.harbor(source) == harbor_id)
+	local node = c % 256
+	if node ~= harbor_id then
+		-- remote publish
+		remote_publish(node, c, source, mc.remote(pack))
+	else
+		publish(c, source, pack,size)
+	end
+end
+
+-- the node (source) subscribe a channel
+-- MUST call by channel owner node (assert source is not local and channel is create by self)
+-- If channel is not exist, return true
+-- Else set channel_remote[channel] true
+function command.SUBR(source, c)
+	local node = skynet.harbor(source)
+	if not channel[c] then
+		-- channel none exist
+		return true
+	end
+	assert(node ~= harbor_id and c % 256 == harbor_id)
+	local group = channel_remote[c]
+	if group == nil then
+		group = {}
+		channel_remote[c] = group
+	end
+	group[node] = true
+end
+
+-- the service (source) subscribe a channel
+-- If the channel is remote, node subscribe it by send a SUBR to the owner .
+function command.SUB(source, c)
+	local node = c % 256
+	if node ~= harbor_id then
+		-- remote group
+		if channel[c] == nil then
+			if skynet.call(node_address[node], "lua", "SUBR", c) then
+				return
+			end
+			if channel[c] == nil then
+				-- double check, because skynet.call whould yield, other SUB may occur.
+				channel[c] = {}
+				channel_n[c] = 0
+			end
+		end
+	end
+	local group = channel[c]
+	if group and not group[source] then
+		channel_n[c] = channel_n[c] + 1
+		group[source] = true
+	end
+end
+
+-- MUST call by a node, unsubscribe a channel
+function command.USUBR(source, c)
+	local node = skynet.harbor(source)
+	assert(node ~= harbor_id)
+	local group = assert(channel_remote[c])
+	group[node] = nil
+	return NORET
+end
+
+-- Unsubscribe a channel, if the subscriber is empty and the channel is remote, send USUBR to the channel owner
+function command.USUB(source, c)
+	local group = assert(channel[c])
+	if group[source] then
+		group[source] = nil
+		channel_n[c] = channel_n[c] - 1
+		if channel_n[c] == 0 then
+			local node = c % 256
+			if node ~= harbor_id then
+				-- remote group
+				channel[c] = nil
+				channel_n[c] = nil
+				skynet.send(node_address[node], "lua", "USUBR", c)
+			end
+		end
+	end
+	return NORET
+end
+
+skynet.start(function()
+	skynet.dispatch("lua", function(_,source, cmd, ...)
+		local f = assert(command[cmd])
+		local result = f(source, ...)
+		if result ~= NORET then
+			skynet.ret(skynet.pack(result))
+		end
+	end)
+	local self = skynet.self()
+	local id = skynet.harbor(self)
+	assert(datacenter.set("multicast", id, self) == nil)
+end)
+

service/service_mgr.lua

@@ -1,72 +1,191 @@
 local skynet = require "skynet"
+local snax = require "snax"
 
 local cmd = {}
 local service = {}
 
-function cmd.LAUNCH(service_name, ...)
+local function request(name, func, ...)
-	local s = service[service_name]
+	local ok, handle = pcall(func, ...)
-	if type(s) == "number" then
+	local s = service[name]
-		return s
-	end
-
-	if s == nil then
-		s = { launch = true }
-		service[service_name] = s
-	elseif s.launch then
 	assert(type(s) == "table")
-		local co = coroutine.running()
+	if ok then
-		table.insert(s, co)
+		service[name] = handle
-		skynet.wait()
+	else
-		s = service[service_name]
+		service[name] = tostring(handle)
-		assert(type(s) == "number")
-		return s
 	end
 
-	local handle = skynet.newservice(service_name, ...)
 	for _,v in ipairs(s) do
 		skynet.wakeup(v)
 	end
 
-	service[service_name] = handle
+	if ok then
-
 		return handle
+	else
+		error(tostring(handle))
+	end
 end
 
-function cmd.QUERY(service_name)
+local function waitfor(name , func, ...)
-	local s = service[service_name]
+	local s = service[name]
 	if type(s) == "number" then
 		return s
 	end
+	local co = coroutine.running()
+
 	if s == nil then
 		s = {}
-		service[service_name] = s
+		service[name] = s
+	elseif type(s) == "string" then
+		error(s)
 	end
+
 	assert(type(s) == "table")
-	local co = coroutine.running()
+
+	if not s.launch and func then
+		s.launch = true
+		return request(name, func, ...)
+	end
+
 	table.insert(s, co)
 	skynet.wait()
-	s = service[service_name]
+	s = service[name]
+	if type(s) == "string" then
+		error(s)
+	end
 	assert(type(s) == "number")
 	return s
 end
 
+local function read_name(service_name)
+	if string.byte(service_name) == 64 then -- '@'
+		return string.sub(service_name , 2)
+	else
+		return service_name
+	end
+end
+
+function cmd.LAUNCH(service_name, subname, ...)
+	local realname = read_name(service_name)
+
+	if realname == "snaxd" then
+		return waitfor(service_name.."."..subname, snax.rawnewservice, subname, ...)
+	else
+		return waitfor(service_name, skynet.newservice, realname, subname, ...)
+	end
+end
+
+function cmd.QUERY(service_name, subname)
+	local realname = read_name(service_name)
+
+	if realname == "snaxd" then
+		return waitfor(service_name.."."..subname)
+	else
+		return waitfor(service_name)
+	end
+end
+
+local function list_service()
+	local result = {}
+	for k,v in pairs(service) do
+		if type(v) == "string" then
+			v = "Error: " .. v
+		elseif type(v) == "table" then
+			v = "Querying"
+		else
+			v = skynet.address(v)
+		end
+
+		result[k] = v
+	end
+
+	return result
+end
+
+
+local function register_global()
+	function cmd.GLAUNCH(name, ...)
+		local global_name = "@" .. name
+		return cmd.LAUNCH(global_name, ...)
+	end
+
+	function cmd.GQUERY(name, ...)
+		local global_name = "@" .. name
+		return cmd.QUERY(global_name, ...)
+	end
+
+	local mgr = {}
+
+	function cmd.REPORT(m)
+		mgr[m] = true
+		skynet.watch(m)
+	end
+
+	local function add_list(all, m)
+		local harbor = "@" .. skynet.harbor(m)
+		local result = skynet.call(m, "lua", "LIST")
+		for k,v in pairs(result) do
+			all[k .. harbor] = v
+		end
+	end
+
+	function cmd.LIST()
+		local result = {}
+		for k in pairs(mgr) do
+			pcall(add_list, result, k)
+		end
+		local l = list_service()
+		for k, v in pairs(l) do
+			result[k] = v
+		end
+		return result
+	end
+end
+
+local function register_local()
+	function cmd.GLAUNCH(name, ...)
+		local global_name = "@" .. name
+		return waitfor(global_name, skynet.call, "SERVICE", "lua", "LAUNCH", global_name, ...)
+	end
+
+	function cmd.GQUERY(name, ...)
+		local global_name = "@" .. name
+		return waitfor(global_name, skynet.call, "SERVICE", "lua", "QUERY", global_name, ...)
+	end
+
+	function cmd.LIST()
+		return list_service()
+	end
+
+	skynet.call("SERVICE", "lua", "REPORT", skynet.self())
+end
+
 skynet.start(function()
-	skynet.dispatch("lua", function(session, address, command, service_name , ...)
+	skynet.dispatch("lua", function(session, address, command, ...)
 		local f = cmd[command]
 		if f == nil then
-			skynet.ret(skynet.pack(nil))
+			skynet.ret(skynet.pack(nil, "Invalid command " .. command))
 			return
 		end
 
-		local ok, r = pcall(f, service_name, ...)
+		local ok, r = pcall(f, ...)
+
 		if ok then
 			skynet.ret(skynet.pack(r))
 		else
-			skynet.ret(skynet.pack(nil))
+			skynet.ret(skynet.pack(nil, r))
 		end
 	end)
+	local handle = skynet.localname ".service"
+	if  handle then
+		skynet.error(".service is already register by ", skynet.address(handle))
+		skynet.exit()
+	else
 		skynet.register(".service")
+	end
 	if skynet.getenv "standalone" then
 		skynet.register("SERVICE")
+		register_global()
+	else
+		register_local()
 	end
 end)

service/snaxd.lua

@@ -1,7 +1,8 @@
 local skynet = require "skynet"
 local c = require "skynet.c"
-local snax_interface = require "snax_interface"
+local snax_interface = require "snax.interface"
 local profile = require "profile"
+local snax = require "snax"
 
 local func = snax_interface(tostring(...), _ENV)
 local mode
@@ -20,8 +21,10 @@ local function update_stat(name, ti)
 	t.time = t.time + ti
 end
 
+local traceback = debug.traceback
+
 local function do_func(f, msg)
-	return pcall(f, table.unpack(msg))
+	return xpcall(f, traceback, table.unpack(msg))
 end
 
 local function dispatch(f, ...)
@@ -41,7 +44,7 @@ local function message_dispatch()
 				if method[2] == "accept" then
 					-- no return
 					profile.start()
-					local ok, data = pcall(f, table.unpack(msg))
+					local ok, data = xpcall(f, traceback, table.unpack(msg))
 					local ti = profile.stop()
 					update_stat(method[3], ti)
 					if not ok then
@@ -49,7 +52,7 @@ local function message_dispatch()
 					end
 				else
 					profile.start()
-					local ok, data, size = pcall(dispatch, f, table.unpack(msg))
+					local ok, data, size = xpcall(dispatch, traceback, f, table.unpack(msg))
 					local ti = profile.stop()
 					update_stat(method[3], ti)
 					if ok then
@@ -88,9 +91,9 @@ local function timing( method, ... )
 	profile.start()
 	if method[2] == "accept" then
 		-- no return
-		err,msg = pcall(method[4], ...)
+		err,msg = xpcall(method[4], traceback, ...)
 	else
-		err,msg = pcall(return_f, method[4], ...)
+		err,msg = xpcall(return_f, traceback, method[4], ...)
 	end
 	local ti = profile.stop()
 	update_stat(method[3], ti)
@@ -98,13 +101,13 @@ local function timing( method, ... )
 end
 
 skynet.start(function()
-	skynet.dispatch("lua", function ( session , source , id, ...)
+	skynet.dispatch("snax", function ( session , source , id, ...)
 		local method = func[id]
 
 		if method[2] == "system" then
 			local command = method[3]
 			if command == "hotfix" then
-				local hotfix = require "snax_hotfix"
+				local hotfix = require "snax.hotfix"
 				skynet.ret(skynet.pack(hotfix(func, ...)))
 			elseif command == "init" then
 				assert(not init, "Already init")

skynet-src/malloc_hook.c

@@ -1,13 +1,11 @@
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
+#include <stdlib.h>
 
 #include "malloc_hook.h"
-#include "jemalloc.h"
-
 #include "skynet.h"
 
-
 static size_t _used_memory = 0;
 static size_t _memory_block = 0;
 typedef struct _mem_data {
@@ -20,6 +18,11 @@ typedef struct _mem_data {
 
 static mem_data mem_stats[SLOT_SIZE];
 
+
+#ifndef NOUSE_JEMALLOC
+
+#include "jemalloc.h"
+
 static ssize_t*
 get_allocated_field(uint32_t handle) {
 	int h = (int)(handle & (SLOT_SIZE - 1));
@@ -89,21 +92,13 @@ static void malloc_oom(size_t size) {
 	abort();
 }
 
-size_t
+void 
-malloc_used_memory(void) {
+memory_info_dump(void) {
-    return _used_memory;
-}
-
-size_t
-malloc_memory_block(void) {
-    return _memory_block;
-}
-
-void memory_info_dump(void) {
 	je_malloc_stats_print(0,0,0);
 }
 
-size_t mallctl_int64(const char* name, size_t* newval) {
+size_t 
+mallctl_int64(const char* name, size_t* newval) {
 	size_t v = 0;
 	size_t len = sizeof(v);
 	if(newval) {
@@ -111,19 +106,20 @@ size_t mallctl_int64(const char* name, size_t* newval) {
 	} else {
 		je_mallctl(name, &v, &len, NULL, 0);
 	}
-    // printf("name: %s, value: %zd\n", name, v);
+	// skynet_error(NULL, "name: %s, value: %zd\n", name, v);
 	return v;
 }
 
-int mallctl_opt(const char* name, int* newval) {
+int 
+mallctl_opt(const char* name, int* newval) {
 	int v = 0;
 	size_t len = sizeof(v);
 	if(newval) {
 		int ret = je_mallctl(name, &v, &len, newval, sizeof(int));
 		if(ret == 0) {
-            printf("set new value(%d) for (%s) succeed\n", *newval, name);
+			skynet_error(NULL, "set new value(%d) for (%s) succeed\n", *newval, name);
 		} else {
-            printf("set new value(%d) for (%s) failed: error -> %d\n", *newval, name, ret);
+			skynet_error(NULL, "set new value(%d) for (%s) failed: error -> %d\n", *newval, name, ret);
 		}
 	} else {
 		je_mallctl(name, &v, &len, NULL, 0);
@@ -132,22 +128,7 @@ int mallctl_opt(const char* name, int* newval) {
 	return v;
 }
 
-void
+// hook : malloc, realloc, free, calloc
-dump_c_mem() {
-    int i;
-    size_t total = 0;
-    printf("dump all service mem:\n");
-    for(i=0; i<SLOT_SIZE; i++) {
-        mem_data* data = &mem_stats[i];
-        if(data->handle != 0 && data->allocated != 0) {
-            total += data->allocated;
-            printf("0x%x -> %zdkb\n", data->handle, data->allocated >> 10);
-        }
-    }
-    printf("+total: %zdkb\n",total >> 10);
-}
-
-// hook : malloc, realloc, memalign, free, calloc
 
 void *
 skynet_malloc(size_t size) {
@@ -180,6 +161,52 @@ skynet_calloc(size_t nmemb,size_t size) {
 	return fill_prefix(ptr);
 }
 
+#else
+
+void 
+memory_info_dump(void) {
+	skynet_error(NULL, "No jemalloc");
+}
+
+size_t 
+mallctl_int64(const char* name, size_t* newval) {
+	skynet_error(NULL, "No jemalloc : mallctl_int64 %s.", name);
+	return 0;
+}
+
+int 
+mallctl_opt(const char* name, int* newval) {
+	skynet_error(NULL, "No jemalloc : mallctl_opt %s.", name);
+	return 0;
+}
+
+#endif
+
+size_t
+malloc_used_memory(void) {
+	return _used_memory;
+}
+
+size_t
+malloc_memory_block(void) {
+	return _memory_block;
+}
+
+void
+dump_c_mem() {
+	int i;
+	size_t total = 0;
+	skynet_error(NULL, "dump all service mem:");
+	for(i=0; i<SLOT_SIZE; i++) {
+		mem_data* data = &mem_stats[i];
+		if(data->handle != 0 && data->allocated != 0) {
+			total += data->allocated;
+			skynet_error(NULL, "0x%x -> %zdkb", data->handle, data->allocated >> 10);
+		}
+	}
+	skynet_error(NULL, "+total: %zdkb",total >> 10);
+}
+
 char *
 skynet_strdup(const char *str) {
 	size_t sz = strlen(str);
@@ -197,4 +224,3 @@ skynet_lalloc(void *ud, void *ptr, size_t osize, size_t nsize) {
 		return skynet_realloc(ptr, nsize);
 	}
 }
-

skynet-src/skynet.h

@@ -8,17 +8,18 @@
 
 #define PTYPE_TEXT 0
 #define PTYPE_RESPONSE 1
-#define PTYPE_MULTICAST_DEPRECATED 2
+#define PTYPE_MULTICAST 2
 #define PTYPE_CLIENT 3
 #define PTYPE_SYSTEM 4
 #define PTYPE_HARBOR 5
 #define PTYPE_SOCKET 6
-// read lualib/skynet.lua lualib/simplemonitor.lua
+// read lualib/skynet.lua examples/simplemonitor.lua
-#define PTYPE_RESERVED_ERROR 7	
+#define PTYPE_ERROR 7	
-// read lualib/skynet.lua lualib/mqueue.lua
+// read lualib/skynet.lua lualib/mqueue.lua lualib/snax.lua
 #define PTYPE_RESERVED_QUEUE 8
 #define PTYPE_RESERVED_DEBUG 9
 #define PTYPE_RESERVED_LUA 10
+#define PTYPE_RESERVED_SNAX 11
 
 #define PTYPE_TAG_DONTCOPY 0x10000
 #define PTYPE_TAG_ALLOCSESSION 0x20000

skynet-src/skynet_daemon.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "skynet_daemon.h"
+
+static int
+check_pid(const char *pidfile) {
+	int pid = 0;
+	FILE *f = fopen(pidfile,"r");
+	if (f == NULL)
+		return 0;
+	int n = fscanf(f,"%d", &pid);
+	fclose(f);
+
+	if (n !=1 || pid == 0 || pid == getpid()) {
+		return 0;
+	}
+
+	if (kill(pid, 0) && errno == ESRCH)
+		return 0;
+
+	return pid;
+}
+
+static int 
+write_pid(const char *pidfile) {
+	FILE *f;
+	int pid = 0;
+	int fd = open(pidfile, O_RDWR|O_CREAT, 0644);
+	if (fd == -1) {
+		fprintf(stderr, "Can't create %s.\n", pidfile);
+		return 0;
+	}
+	f = fdopen(fd, "r+");
+	if (f == NULL) {
+		fprintf(stderr, "Can't open %s.\n", pidfile);
+		return 0;
+	}
+
+	if (flock(fd, LOCK_EX|LOCK_NB) == -1) {
+		int n = fscanf(f, "%d", &pid);
+		fclose(f);
+		if (n != 1) {
+			fprintf(stderr, "Can't lock and read pidfile.\n");
+		} else {
+			fprintf(stderr, "Can't lock pidfile, lock is held by pid %d.\n", pid);
+		}
+		return 0;
+	}
+	
+	pid = getpid();
+	if (!fprintf(f,"%d\n", pid)) {
+		fprintf(stderr, "Can't write pid.\n");
+		close(fd);
+		return 0;
+	}
+	fflush(f);
+
+	return pid;
+}
+
+int
+daemon_init(const char *pidfile) {
+	int pid = check_pid(pidfile);
+
+	if (pid) {
+		fprintf(stderr, "Skynet is already running, pid = %d.\n", pid);
+		return 1;
+	}
+
+#ifdef __APPLE__
+	fprintf(stderr, "'daemon' is deprecated: first deprecated in OS X 10.5 , use launchd instead.\n");
+#else
+	if (daemon(1,0)) {
+		fprintf(stderr, "Can't daemonize.\n");
+		return 1;
+	}
+#endif
+
+	pid = write_pid(pidfile);
+	if (pid == 0) {
+		return 1;
+	}
+
+	return 0;
+}
+
+int 
+daemon_exit(const char *pidfile) {
+	return unlink(pidfile);
+}

skynet-src/skynet_daemon.h

@@ -0,0 +1,7 @@
+#ifndef skynet_daemon_h
+#define skynet_daemon_h
+
+int daemon_init(const char *pidfile);
+int daemon_exit(const char *pidfile);
+
+#endif

skynet-src/skynet_handle.c

@@ -9,6 +9,7 @@
 #include <string.h>
 
 #define DEFAULT_SLOT_SIZE 4
+#define MAX_SLOT_SIZE 0x40000000
 
 struct handle_name {
 	char * name;
@@ -168,6 +169,7 @@ static void
 _insert_name_before(struct handle_storage *s, char *name, uint32_t handle, int before) {
 	if (s->name_count >= s->name_cap) {
 		s->name_cap *= 2;
+		assert(s->name_cap <= MAX_SLOT_SIZE);
 		struct handle_name * n = skynet_malloc(s->name_cap * sizeof(struct handle_name));
 		int i;
 		for (i=0;i<before;i++) {

skynet-src/skynet_harbor.c

@@ -7,33 +7,19 @@
 #include <assert.h>
 
 static struct skynet_context * REMOTE = 0;
-static unsigned int HARBOR = 0;
+static unsigned int HARBOR = ~0;
 
 void 
 skynet_harbor_send(struct remote_message *rmsg, uint32_t source, int session) {
 	int type = rmsg->sz >> HANDLE_REMOTE_SHIFT;
 	rmsg->sz &= HANDLE_MASK;
-	assert(type != PTYPE_SYSTEM && type != PTYPE_HARBOR);
+	assert(type != PTYPE_SYSTEM && type != PTYPE_HARBOR && REMOTE);
 	skynet_context_send(REMOTE, rmsg, sizeof(*rmsg) , source, type , session);
 }
 
-void 
-skynet_harbor_register(struct remote_name *rname) {
-	int i;
-	int number = 1;
-	for (i=0;i<GLOBALNAME_LENGTH;i++) {
-		char c = rname->name[i];
-		if (!(c >= '0' && c <='9')) {
-			number = 0;
-			break;
-		}
-	}
-	assert(number == 0);
-	skynet_context_send(REMOTE, rname, sizeof(*rname), 0, PTYPE_SYSTEM , 0);
-}
-
 int 
 skynet_harbor_message_isremote(uint32_t handle) {
+	assert(HARBOR != ~0);
 	int h = (handle & ~HANDLE_MASK);
 	return h != HARBOR && h !=0;
 }
@@ -43,16 +29,7 @@ skynet_harbor_init(int harbor) {
 	HARBOR = (unsigned int)harbor << HANDLE_REMOTE_SHIFT;
 }
 
-int
+void
-skynet_harbor_start(const char * master, const char *local) {
+skynet_harbor_start(void *ctx) {
-	size_t sz = strlen(master) + strlen(local) + 32;
+	REMOTE = ctx;
-	char args[sz];
-	sprintf(args, "%s %s %d",master,local,HARBOR >> HANDLE_REMOTE_SHIFT);
-	struct skynet_context * inst = skynet_context_new("harbor",args);
-	if (inst == NULL) {
-		return 1;
-	}
-	REMOTE = inst;
-
-	return 0;
 }

skynet-src/skynet_harbor.h

@@ -23,9 +23,8 @@ struct remote_message {
 };
 
 void skynet_harbor_send(struct remote_message *rmsg, uint32_t source, int session);
-void skynet_harbor_register(struct remote_name *rname);
 int skynet_harbor_message_isremote(uint32_t handle);
 void skynet_harbor_init(int harbor);
-int skynet_harbor_start(const char * master, const char *local);
+void skynet_harbor_start(void * ctx);
 
 #endif

skynet-src/skynet_imp.h

@@ -4,14 +4,18 @@
 struct skynet_config {
 	int thread;
 	int harbor;
-	const char * logger;
+	const char * daemon;
 	const char * module_path;
-	const char * master;
+	const char * bootstrap;
-	const char * local;
+	const char * logger;
-	const char * start;
-	const char * standalone;
 };
 
+#define THREAD_WORKER 0
+#define THREAD_MAIN 1
+#define THREAD_SOCKET 2
+#define THREAD_TIMER 3
+#define THREAD_MONITOR 4
+
 void skynet_start(struct skynet_config * config);
 
 #endif

skynet-src/skynet_main.c

@@ -2,6 +2,7 @@
 
 #include "skynet_imp.h"
 #include "skynet_env.h"
+#include "skynet_server.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -34,6 +35,7 @@ optboolean(const char *key, int opt) {
 	return strcmp(str,"true")==0;
 }
 */
+
 static const char *
 optstring(const char *key,const char * opt) {
 	const char * str = skynet_getenv(key);
@@ -87,6 +89,7 @@ main(int argc, char *argv[]) {
 	if (argc > 1) {
 		config_file = argv[1];
 	}
+	skynet_globalinit();
 	skynet_env_init();
 
 	sigign();
@@ -107,30 +110,17 @@ main(int argc, char *argv[]) {
 	} 
 	_init_env(L);
 
-#ifdef LUA_CACHELIB
-  printf("Skynet lua code cache enable\n");
-#endif
-
-	const char *path = optstring("lua_path","./lualib/?.lua;./lualib/?/init.lua");
-	setenv("LUA_PATH",path,1);
-	const char *cpath = optstring("lua_cpath","./luaclib/?.so");
-	setenv("LUA_CPATH",cpath,1);
-	optstring("luaservice","./service/?.lua");
-
 	config.thread =  optint("thread",8);
 	config.module_path = optstring("cpath","./cservice/?.so");
-	config.logger = optstring("logger",NULL);
 	config.harbor = optint("harbor", 1);
-	config.master = optstring("master","127.0.0.1:2012");
+	config.bootstrap = optstring("bootstrap","snlua bootstrap");
-	config.start = optstring("start","main.lua");
+	config.daemon = optstring("daemon", NULL);
-	config.local = optstring("address","127.0.0.1:2525");
+	config.logger = optstring("logger", NULL);
-	config.standalone = optstring("standalone",NULL);
 
 	lua_close(L);
 
 	skynet_start(&config);
-
+	skynet_globalexit();
-	printf("skynet exit\n");
 
 	return 0;
 }

skynet-src/skynet_malloc.h

@@ -3,14 +3,10 @@
 
 #include <stddef.h>
 
-#ifdef SKYNET_MALLOC_RENAME
+#define skynet_malloc malloc
-
+#define skynet_calloc calloc
-#define malloc skynet_malloc
+#define skynet_realloc realloc
-#define calloc skynet_calloc
+#define skynet_free free
-#define realloc skynet_realloc
-#define free skynet_free
-
-#endif
 
 void * skynet_malloc(size_t sz);
 void * skynet_calloc(size_t nmemb,size_t size);

skynet-src/skynet_mq.c

@@ -13,12 +13,8 @@
 
 // 0 means mq is not in global mq.
 // 1 means mq is in global mq , or the message is dispatching.
-// 2 means message is dispatching with locked session set.
-// 3 means mq is not in global mq, and locked session has been set.
 
 #define MQ_IN_GLOBAL 1
-#define MQ_DISPATCHING 2
-#define MQ_LOCKED 3
 
 struct message_queue {
 	uint32_t handle;
@@ -27,17 +23,18 @@ struct message_queue {
 	int tail;
 	int lock;
 	int release;
-	int lock_session;
 	int in_global;
 	struct skynet_message *queue;
+	struct message_queue *next;
 };
 
 struct global_queue {
 	uint32_t head;
 	uint32_t tail;
 	struct message_queue ** queue;
-	bool * flag;
+	// We use a separated flag array to ensure the mq is pushed.
-
+	// See the comments below.
+	struct message_queue *list;
 };
 
 static struct global_queue *Q = NULL;
@@ -47,36 +44,61 @@ static struct global_queue *Q = NULL;
 
 #define GP(p) ((p) % MAX_GLOBAL_MQ)
 
-static void 
+void 
 skynet_globalmq_push(struct message_queue * queue) {
 	struct global_queue *q= Q;
 
 	uint32_t tail = GP(__sync_fetch_and_add(&q->tail,1));
-	q->queue[tail] = queue;
+
-	__sync_synchronize();
+	// only one thread can set the slot (change q->queue[tail] from NULL to queue)
-	q->flag[tail] = true;
+	if (!__sync_bool_compare_and_swap(&q->queue[tail], NULL, queue)) {
+		// The queue may full seldom, save queue in list
+		assert(queue->next == NULL);
+		struct message_queue * last;
+		do {
+			last = q->list;
+			queue->next = last;
+		} while(!__sync_bool_compare_and_swap(&q->list, last, queue));
+
+		return;
+	}
 }
 
 struct message_queue * 
 skynet_globalmq_pop() {
 	struct global_queue *q = Q;
 	uint32_t head =  q->head;
+
+	if (head == q->tail) {
+		// The queue is empty.
+		return NULL;
+	}
+
 	uint32_t head_ptr = GP(head);
-	if (head_ptr == GP(q->tail)) {
-		return NULL;
-	}
 
-	if(!q->flag[head_ptr]) {
+	struct message_queue * list = q->list;
-		return NULL;
+	if (list) {
+		// If q->list is not empty, try to load it back to the queue
+		struct message_queue *newhead = list->next;
+		if (__sync_bool_compare_and_swap(&q->list, list, newhead)) {
+			// try load list only once, if success , push it back to the queue.
+			list->next = NULL;
+			skynet_globalmq_push(list);
+		}
 	}
-
-	__sync_synchronize();
 
 	struct message_queue * mq = q->queue[head_ptr];
+	if (mq == NULL) {
+		// globalmq push not complete
+		return NULL;
+	}
 	if (!__sync_bool_compare_and_swap(&q->head, head, head+1)) {
 		return NULL;
 	}
-	q->flag[head_ptr] = false;
+	// only one thread can get the slot (change q->queue[head_ptr] to NULL)
+	if (!__sync_bool_compare_and_swap(&q->queue[head_ptr], mq, NULL)) {
+		return NULL;
+	}
 
 	return mq;
 }
@@ -89,16 +111,20 @@ skynet_mq_create(uint32_t handle) {
 	q->head = 0;
 	q->tail = 0;
 	q->lock = 0;
+	// When the queue is create (always between service create and service init) ,
+	// set in_global flag to avoid push it to global queue .
+	// If the service init success, skynet_context_new will call skynet_mq_force_push to push it to global queue.
 	q->in_global = MQ_IN_GLOBAL;
 	q->release = 0;
-	q->lock_session = 0;
 	q->queue = skynet_malloc(sizeof(struct skynet_message) * q->cap);
+	q->next = NULL;
 
 	return q;
 }
 
 static void 
 _release(struct message_queue *q) {
+	assert(q->next == NULL);
 	skynet_free(q->queue);
 	skynet_free(q);
 }
@@ -161,45 +187,11 @@ expand_queue(struct message_queue *q) {
 	q->queue = new_queue;
 }
 
-static void
-_unlock(struct message_queue *q) {
-	// this api use in push a unlock message, so the in_global flags must not be 0 , 
-	// but the q is not exist in global queue.
-	if (q->in_global == MQ_LOCKED) {
-		skynet_globalmq_push(q);
-		q->in_global = MQ_IN_GLOBAL;
-	} else {
-		assert(q->in_global == MQ_DISPATCHING);
-	}
-	q->lock_session = 0;
-}
-
-static void 
-_pushhead(struct message_queue *q, struct skynet_message *message) {
-	int head = q->head - 1;
-	if (head < 0) {
-		head = q->cap - 1;
-	}
-	if (head == q->tail) {
-		expand_queue(q);
-		--q->tail;
-		head = q->cap - 1;
-	}
-
-	q->queue[head] = *message;
-	q->head = head;
-
-	_unlock(q);
-}
-
 void 
 skynet_mq_push(struct message_queue *q, struct skynet_message *message) {
 	assert(message);
 	LOCK(q)
 
-	if (q->lock_session !=0 && message->session == q->lock_session) {
-		_pushhead(q,message);
-	} else {
 	q->queue[q->tail] = *message;
 	if (++ q->tail >= q->cap) {
 		q->tail = 0;
@@ -209,65 +201,23 @@ skynet_mq_push(struct message_queue *q, struct skynet_message *message) {
 		expand_queue(q);
 	}
 
-		if (q->lock_session == 0) {
 	if (q->in_global == 0) {
 		q->in_global = MQ_IN_GLOBAL;
 		skynet_globalmq_push(q);
 	}
-		}
-	}
 	
 	UNLOCK(q)
 }
 
-void
-skynet_mq_lock(struct message_queue *q, int session) {
-	LOCK(q)
-	assert(q->lock_session == 0);
-	assert(q->in_global == MQ_IN_GLOBAL);
-	q->in_global = MQ_DISPATCHING;
-	q->lock_session = session;
-	UNLOCK(q)
-}
-
-void
-skynet_mq_unlock(struct message_queue *q) {
-	LOCK(q)
-	_unlock(q);
-	UNLOCK(q)
-}
-
 void 
 skynet_mq_init() {
 	struct global_queue *q = skynet_malloc(sizeof(*q));
 	memset(q,0,sizeof(*q));
 	q->queue = skynet_malloc(MAX_GLOBAL_MQ * sizeof(struct message_queue *));
-	q->flag = skynet_malloc(MAX_GLOBAL_MQ * sizeof(bool));
+	memset(q->queue, 0, sizeof(struct message_queue *) * MAX_GLOBAL_MQ);
-	memset(q->flag, 0, sizeof(bool) * MAX_GLOBAL_MQ);
 	Q=q;
 }
 
-void 
-skynet_mq_force_push(struct message_queue * queue) {
-	assert(queue->in_global);
-	skynet_globalmq_push(queue);
-}
-
-void 
-skynet_mq_pushglobal(struct message_queue *queue) {
-	LOCK(queue)
-	assert(queue->in_global);
-	if (queue->in_global == MQ_DISPATCHING) {
-		// lock message queue just now.
-		queue->in_global = MQ_LOCKED;
-	}
-	if (queue->lock_session == 0) {
-		skynet_globalmq_push(queue);
-		queue->in_global = MQ_IN_GLOBAL;
-	}
-	UNLOCK(queue)
-}
-
 void 
 skynet_mq_mark_release(struct message_queue *q) {
 	LOCK(q)
@@ -279,31 +229,24 @@ skynet_mq_mark_release(struct message_queue *q) {
 	UNLOCK(q)
 }
 
-static int
+static void
-_drop_queue(struct message_queue *q) {
+_drop_queue(struct message_queue *q, message_drop drop_func, void *ud) {
-	// todo: send message back to message source
 	struct skynet_message msg;
-	int s = 0;
 	while(!skynet_mq_pop(q, &msg)) {
-		++s;
+		drop_func(&msg, ud);
-		skynet_free(msg.data);
 	}
 	_release(q);
-	return s;
 }
 
-int 
+void 
-skynet_mq_release(struct message_queue *q) {
+skynet_mq_release(struct message_queue *q, message_drop drop_func, void *ud) {
-	int ret = 0;
 	LOCK(q)
 	
 	if (q->release) {
 		UNLOCK(q)
-		ret = _drop_queue(q);
+		_drop_queue(q, drop_func, ud);
 	} else {
-		skynet_mq_force_push(q);
+		skynet_globalmq_push(q);
 		UNLOCK(q)
 	}
-	
-	return ret;
 }

skynet-src/skynet_mq.h

@@ -13,25 +13,24 @@ struct skynet_message {
 
 struct message_queue;
 
+void skynet_globalmq_push(struct message_queue * queue);
 struct message_queue * skynet_globalmq_pop(void);
 
 struct message_queue * skynet_mq_create(uint32_t handle);
 void skynet_mq_mark_release(struct message_queue *q);
-int skynet_mq_release(struct message_queue *q);
+
+typedef void (*message_drop)(struct skynet_message *, void *);
+
+void skynet_mq_release(struct message_queue *q, message_drop drop_func, void *ud);
 uint32_t skynet_mq_handle(struct message_queue *);
 
 // 0 for success
 int skynet_mq_pop(struct message_queue *q, struct skynet_message *message);
 void skynet_mq_push(struct message_queue *q, struct skynet_message *message);
-void skynet_mq_lock(struct message_queue *q, int session);
-void skynet_mq_unlock(struct message_queue *q);
 
 // return the length of message queue, for debug
 int skynet_mq_length(struct message_queue *q);
 
-void skynet_mq_force_push(struct message_queue *q);
-void skynet_mq_pushglobal(struct message_queue *q);
-
 void skynet_mq_init();
 
 #endif

skynet-src/skynet_server.c

@@ -8,6 +8,9 @@
 #include "skynet_harbor.h"
 #include "skynet_env.h"
 #include "skynet_monitor.h"
+#include "skynet_imp.h"
+
+#include <pthread.h>
 
 #include <string.h>
 #include <assert.h>
@@ -49,11 +52,12 @@ struct skynet_context {
 
 struct skynet_node {
 	int total;
+	int init;
 	uint32_t monitor_exit;
+	pthread_key_t handle_key;
 };
 
-static struct skynet_node G_NODE = { 0,0 };
+static struct skynet_node G_NODE;
-static __thread uint32_t handle_tls = 0xffffffff;
 
 int 
 skynet_context_total() {
@@ -61,22 +65,28 @@ skynet_context_total() {
 }
 
 static void
-_context_inc() {
+context_inc() {
 	__sync_fetch_and_add(&G_NODE.total,1);
 }
 
 static void
-_context_dec() {
+context_dec() {
 	__sync_fetch_and_sub(&G_NODE.total,1);
 }
 
 uint32_t 
 skynet_current_handle(void) {
-	return handle_tls;
+	if (G_NODE.init) {
+		void * handle = pthread_getspecific(G_NODE.handle_key);
+		return (uint32_t)(uintptr_t)handle;
+	} else {
+		uintptr_t v = (uint32_t)(-THREAD_MAIN);
+		return v;
+	}
 }
 
 static void
-_id_to_hex(char * str, uint32_t id) {
+id_to_hex(char * str, uint32_t id) {
 	int i;
 	static char hex[16] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
 	str[0] = ':';
@@ -86,6 +96,20 @@ _id_to_hex(char * str, uint32_t id) {
 	str[9] = '\0';
 }
 
+struct drop_t {
+	uint32_t handle;
+};
+
+static void
+drop_message(struct skynet_message *msg, void *ud) {
+	struct drop_t *d = ud;
+	skynet_free(msg->data);
+	uint32_t source = d->handle;
+	assert(source);
+	// report error to the message source
+	skynet_send(NULL, source, msg->source, PTYPE_ERROR, 0, NULL, 0);
+}
+
 struct skynet_context * 
 skynet_context_new(const char * name, const char *param) {
 	struct skynet_module * mod = skynet_module_query(name);
@@ -111,7 +135,7 @@ skynet_context_new(const char * name, const char *param) {
 	ctx->handle = skynet_handle_register(ctx);
 	struct message_queue * queue = ctx->queue = skynet_mq_create(ctx->handle);
 	// init function maybe use ctx->handle, so it must init at last
-	_context_inc();
+	context_inc();
 
 	CHECKCALLING_BEGIN(ctx)
 	int r = skynet_module_instance_init(mod, inst, ctx, param);
@@ -121,16 +145,18 @@ skynet_context_new(const char * name, const char *param) {
 		if (ret) {
 			ctx->init = true;
 		}
-		skynet_mq_force_push(queue);
+		skynet_globalmq_push(queue);
 		if (ret) {
 			skynet_error(ret, "LAUNCH %s %s", name, param ? param : "");
 		}
 		return ret;
 	} else {
 		skynet_error(ctx, "FAILED launch %s", name);
+		uint32_t handle = ctx->handle;
 		skynet_context_release(ctx);
-		skynet_handle_retire(ctx->handle);
+		skynet_handle_retire(handle);
-		skynet_mq_release(queue);
+		struct drop_t d = { handle };
+		skynet_mq_release(queue, drop_message, &d);
 		return NULL;
 	}
 }
@@ -148,17 +174,17 @@ skynet_context_grab(struct skynet_context *ctx) {
 }
 
 static void 
-_delete_context(struct skynet_context *ctx) {
+delete_context(struct skynet_context *ctx) {
 	skynet_module_instance_release(ctx->mod, ctx->instance);
 	skynet_mq_mark_release(ctx->queue);
 	skynet_free(ctx);
-	_context_dec();
+	context_dec();
 }
 
 struct skynet_context * 
 skynet_context_release(struct skynet_context *ctx) {
 	if (__sync_sub_and_fetch(&ctx->ref,1) == 0) {
-		_delete_context(ctx);
+		delete_context(ctx);
 		return NULL;
 	}
 	return ctx;
@@ -199,59 +225,80 @@ static void
 _dispatch_message(struct skynet_context *ctx, struct skynet_message *msg) {
 	assert(ctx->init);
 	CHECKCALLING_BEGIN(ctx)
-	handle_tls = ctx->handle;
+	pthread_setspecific(G_NODE.handle_key, (void *)(uintptr_t)(ctx->handle));
 	int type = msg->sz >> HANDLE_REMOTE_SHIFT;
 	size_t sz = msg->sz & HANDLE_MASK;
 	if (!ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz)) {
 		skynet_free(msg->data);
 	}
-	handle_tls = 0xffffffff;
 	CHECKCALLING_END(ctx)
 }
 
-int
+void 
-skynet_context_message_dispatch(struct skynet_monitor *sm) {
+skynet_context_dispatchall(struct skynet_context * ctx) {
-	struct message_queue * q = skynet_globalmq_pop();
+	// for skynet_error
+	struct skynet_message msg;
+	struct message_queue *q = ctx->queue;
+	while (!skynet_mq_pop(q,&msg)) {
+		_dispatch_message(ctx, &msg);
+	}
+}
+
+struct message_queue * 
+skynet_context_message_dispatch(struct skynet_monitor *sm, struct message_queue *q, int weight) {
+	if (q == NULL) {
+		q = skynet_globalmq_pop();
 		if (q==NULL)
-		return 1;
+			return NULL;
+	}
 
 	uint32_t handle = skynet_mq_handle(q);
 
 	struct skynet_context * ctx = skynet_handle_grab(handle);
 	if (ctx == NULL) {
-		int s = skynet_mq_release(q);
+		struct drop_t d = { handle };
-		if (s>0) {
+		skynet_mq_release(q, drop_message, &d);
-			skynet_error(NULL, "Drop message queue %x (%d messages)", handle,s);
+		return skynet_globalmq_pop();
-		}
-		return 0;
 	}
 
+	int i,n=1;
 	struct skynet_message msg;
+
+	for (i=0;i<n;i++) {
 		if (skynet_mq_pop(q,&msg)) {
 			skynet_context_release(ctx);
-		return 0;
+			return skynet_globalmq_pop();
+		} else if (i==0 && weight >= 0) {
+			n = skynet_mq_length(q);
+			n >>= weight;
 		}
 
 		skynet_monitor_trigger(sm, msg.source , handle);
 
 		if (ctx->cb == NULL) {
 			skynet_free(msg.data);
-		skynet_error(NULL, "Drop message from %x to %x without callback , size = %d",msg.source, handle, (int)msg.sz);
 		} else {
 			_dispatch_message(ctx, &msg);
 		}
 
+		skynet_monitor_trigger(sm, 0,0);
+	}
+
 	assert(q == ctx->queue);
-	skynet_mq_pushglobal(q);
+	struct message_queue *nq = skynet_globalmq_pop();
+	if (nq) {
+		// If global mq is not empty , push q back, and return next queue (nq)
+		// Else (global mq is empty or block, don't push q back, and return q again (for next dispatch)
+		skynet_globalmq_push(q);
+		q = nq;
+	} 
 	skynet_context_release(ctx);
 
-	skynet_monitor_trigger(sm, 0,0);
+	return q;
-
-	return 0;
 }
 
 static void
-_copy_name(char name[GLOBALNAME_LENGTH], const char * addr) {
+copy_name(char name[GLOBALNAME_LENGTH], const char * addr) {
 	int i;
 	for (i=0;i<GLOBALNAME_LENGTH && addr[i];i++) {
 		name[i] = addr[i];
@@ -287,59 +334,50 @@ handle_exit(struct skynet_context * context, uint32_t handle) {
 	skynet_handle_retire(handle);
 }
 
-const char * 
+// skynet command
-skynet_command(struct skynet_context * context, const char * cmd , const char * param) {
+
-	if (strcmp(cmd,"TIMEOUT") == 0) {
+struct command_func {
+	const char *name;
+	const char * (*func)(struct skynet_context * context, const char * param);
+};
+
+static const char *
+cmd_timeout(struct skynet_context * context, const char * param) {
 	char * session_ptr = NULL;
 	int ti = strtol(param, &session_ptr, 10);
 	int session = skynet_context_newsession(context);
 	skynet_timeout(context->handle, ti, session);
 	sprintf(context->result, "%d", session);
 	return context->result;
-	}
+}
 
-	if (strcmp(cmd,"LOCK") == 0) {
+static const char *
-		if (context->init == false) {
+cmd_reg(struct skynet_context * context, const char * param) {
-			return NULL;
-		}
-		skynet_mq_lock(context->queue, context->session_id+1);
-		return NULL;
-	}
-
-	if (strcmp(cmd,"UNLOCK") == 0) {
-		if (context->init == false) {
-			return NULL;
-		}
-		skynet_mq_unlock(context->queue);
-		return NULL;
-	}
-
-	if (strcmp(cmd,"REG") == 0) {
 	if (param == NULL || param[0] == '\0') {
 		sprintf(context->result, ":%x", context->handle);
 		return context->result;
 	} else if (param[0] == '.') {
 		return skynet_handle_namehandle(context->handle, param + 1);
 	} else {
-			assert(context->handle!=0);
+		skynet_error(context, "Can't register global name %s in C", param);
-			struct remote_name *rname = skynet_malloc(sizeof(*rname));
-			_copy_name(rname->name, param);
-			rname->handle = context->handle;
-			skynet_harbor_register(rname);
 		return NULL;
 	}
-	}
+}
 
-	if (strcmp(cmd,"QUERY") == 0) {
+static const char *
+cmd_query(struct skynet_context * context, const char * param) {
 	if (param[0] == '.') {
 		uint32_t handle = skynet_handle_findname(param+1);
+		if (handle) {
 			sprintf(context->result, ":%x", handle);
 			return context->result;
 		}
-		return NULL;
 	}
+	return NULL;
+}
 
-	if (strcmp(cmd,"NAME") == 0) {
+static const char *
+cmd_name(struct skynet_context * context, const char * param) {
 	int size = strlen(param);
 	char name[size+1];
 	char handle[size+1];
@@ -354,26 +392,26 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 	if (name[0] == '.') {
 		return skynet_handle_namehandle(handle_id, name + 1);
 	} else {
-			struct remote_name *rname = skynet_malloc(sizeof(*rname));
+		skynet_error(context, "Can't set global name %s in C", name);
-			_copy_name(rname->name, name);
-			rname->handle = handle_id;
-			skynet_harbor_register(rname);
 	}
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd,"NOW") == 0) {
+static const char *
+cmd_now(struct skynet_context * context, const char * param) {
 	uint32_t ti = skynet_gettime();
 	sprintf(context->result,"%u",ti);
 	return context->result;
-	}
+}
 
-	if (strcmp(cmd,"EXIT") == 0) {
+static const char *
+cmd_exit(struct skynet_context * context, const char * param) {
 	handle_exit(context, 0);
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd,"KILL") == 0) {
+static const char *
+cmd_kill(struct skynet_context * context, const char * param) {
 	uint32_t handle = 0;
 	if (param[0] == ':') {
 		handle = strtoul(param+1, NULL, 16);
@@ -387,9 +425,10 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 		handle_exit(context, handle);
 	}
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd,"LAUNCH") == 0) {
+static const char *
+cmd_launch(struct skynet_context * context, const char * param) {
 	size_t sz = strlen(param);
 	char tmp[sz+1];
 	strcpy(tmp,param);
@@ -400,16 +439,18 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 	if (inst == NULL) {
 		return NULL;
 	} else {
-			_id_to_hex(context->result, inst->handle);
+		id_to_hex(context->result, inst->handle);
 		return context->result;
 	}
-	}
+}
 
-	if (strcmp(cmd,"GETENV") == 0) {
+static const char *
+cmd_getenv(struct skynet_context * context, const char * param) {
 	return skynet_getenv(param);
-	}
+}
 
-	if (strcmp(cmd,"SETENV") == 0) {
+static const char *
+cmd_setenv(struct skynet_context * context, const char * param) {
 	size_t sz = strlen(param);
 	char key[sz+1];
 	int i;
@@ -424,29 +465,33 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 	
 	skynet_setenv(key,param);
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd,"STARTTIME") == 0) {
+static const char *
+cmd_starttime(struct skynet_context * context, const char * param) {
 	uint32_t sec = skynet_gettime_fixsec();
 	sprintf(context->result,"%u",sec);
 	return context->result;
-	}
+}
 
-	if (strcmp(cmd,"ENDLESS") == 0) {
+static const char *
+cmd_endless(struct skynet_context * context, const char * param) {
 	if (context->endless) {
 		strcpy(context->result, "1");
 		context->endless = false;
 		return context->result;
 	}
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd,"ABORT") == 0) {
+static const char *
+cmd_abort(struct skynet_context * context, const char * param) {
 	skynet_handle_retireall();
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd,"MONITOR") == 0) {
+static const char *
+cmd_monitor(struct skynet_context * context, const char * param) {
 	uint32_t handle=0;
 	if (param == NULL || param[0] == '\0') {
 		if (G_NODE.monitor_exit) {
@@ -467,12 +512,42 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 	}
 	G_NODE.monitor_exit = handle;
 	return NULL;
-	}
+}
 
-	if (strcmp(cmd, "MQLEN") == 0) {
+static const char *
+cmd_mqlen(struct skynet_context * context, const char * param) {
 	int len = skynet_mq_length(context->queue);
 	sprintf(context->result, "%d", len);
 	return context->result;
+}
+
+static struct command_func cmd_funcs[] = {
+	{ "TIMEOUT", cmd_timeout },
+	{ "REG", cmd_reg },
+	{ "QUERY", cmd_query },
+	{ "NAME", cmd_name },
+	{ "NOW", cmd_now },
+	{ "EXIT", cmd_exit },
+	{ "KILL", cmd_kill },
+	{ "LAUNCH", cmd_launch },
+	{ "GETENV", cmd_getenv },
+	{ "SETENV", cmd_setenv },
+	{ "STARTTIME", cmd_starttime },
+	{ "ENDLESS", cmd_endless },
+	{ "ABORT", cmd_abort },
+	{ "MONITOR", cmd_monitor },
+	{ "MQLEN", cmd_mqlen },
+	{ NULL, NULL },
+};
+
+const char * 
+skynet_command(struct skynet_context * context, const char * cmd , const char * param) {
+	struct command_func * method = &cmd_funcs[0];
+	while(method->name) {
+		if (strcmp(cmd, method->name) == 0) {
+			return method->func(context, param);
+		}
+		++method;
 	}
 
 	return NULL;
@@ -496,12 +571,16 @@ _filter_args(struct skynet_context * context, int type, int *session, void ** da
 		*data = msg;
 	}
 
-	assert((*sz & HANDLE_MASK) == *sz);
 	*sz |= type << HANDLE_REMOTE_SHIFT;
 }
 
 int
 skynet_send(struct skynet_context * context, uint32_t source, uint32_t destination , int type, int session, void * data, size_t sz) {
+	if ((sz & HANDLE_MASK) != sz) {
+		skynet_error(context, "The message to %x is too large (sz = %lu)", destination, sz);
+		skynet_free(data);
+		return -1;
+	}
 	_filter_args(context, type, &session, (void **)&data, &sz);
 
 	if (source == 0) {
@@ -526,7 +605,6 @@ skynet_send(struct skynet_context * context, uint32_t source, uint32_t destinati
 
 		if (skynet_context_push(destination, &smsg)) {
 			skynet_free(data);
-			skynet_error(NULL, "Drop message from %x to %x (type=%d)(size=%d)", source, destination, type&0xff, (int)(sz & HANDLE_MASK));
 			return -1;
 		}
 	}
@@ -545,14 +623,13 @@ skynet_sendname(struct skynet_context * context, const char * addr , int type, i
 			if (type & PTYPE_TAG_DONTCOPY) {
 				skynet_free(data);
 			}
-			skynet_error(context, "Drop message to %s", addr);
 			return session;
 		}
 	} else {
 		_filter_args(context, type, &session, (void **)&data, &sz);
 
 		struct remote_message * rmsg = skynet_malloc(sizeof(*rmsg));
-		_copy_name(rmsg->destination.name, addr);
+		copy_name(rmsg->destination.name, addr);
 		rmsg->destination.handle = 0;
 		rmsg->message = data;
 		rmsg->sz = sz;
@@ -590,3 +667,28 @@ skynet_context_send(struct skynet_context * ctx, void * msg, size_t sz, uint32_t
 
 	skynet_mq_push(ctx->queue, &smsg);
 }
+
+void 
+skynet_globalinit(void) {
+	G_NODE.total = 0;
+	G_NODE.monitor_exit = 0;
+	G_NODE.init = 1;
+	if (pthread_key_create(&G_NODE.handle_key, NULL)) {
+		fprintf(stderr, "pthread_key_create failed");
+		exit(1);
+	}
+	// set mainthread's key
+	skynet_initthread(THREAD_MAIN);
+}
+
+void 
+skynet_globalexit(void) {
+	pthread_key_delete(G_NODE.handle_key);
+}
+
+void
+skynet_initthread(int m) {
+	uintptr_t v = (uint32_t)(-m);
+	pthread_setspecific(G_NODE.handle_key, (void *)v);
+}
+

skynet-src/skynet_server.h

@@ -16,9 +16,14 @@ void skynet_context_init(struct skynet_context *, uint32_t handle);
 int skynet_context_push(uint32_t handle, struct skynet_message *message);
 void skynet_context_send(struct skynet_context * context, void * msg, size_t sz, uint32_t source, int type, int session);
 int skynet_context_newsession(struct skynet_context *);
-int skynet_context_message_dispatch(struct skynet_monitor *);	// return 1 when block
+struct message_queue * skynet_context_message_dispatch(struct skynet_monitor *, struct message_queue *, int weight);	// return next queue
 int skynet_context_total();
+void skynet_context_dispatchall(struct skynet_context * context);	// for skynet_error output before exit
 
 void skynet_context_endless(uint32_t handle);	// for monitor
 
+void skynet_globalinit(void);
+void skynet_globalexit(void);
+void skynet_initthread(int m);
+
 #endif

skynet-src/skynet_socket.c

@@ -133,12 +133,6 @@ skynet_socket_connect(struct skynet_context *ctx, const char *host, int port) {
 	return socket_server_connect(SOCKET_SERVER, source, host, port);
 }
 
-int 
-skynet_socket_block_connect(struct skynet_context *ctx, const char *host, int port) {
-	uint32_t source = skynet_context_handle(ctx);
-	return socket_server_block_connect(SOCKET_SERVER, source, host, port);
-}
-
 int 
 skynet_socket_bind(struct skynet_context *ctx, int fd) {
 	uint32_t source = skynet_context_handle(ctx);
@@ -156,3 +150,8 @@ skynet_socket_start(struct skynet_context *ctx, int id) {
 	uint32_t source = skynet_context_handle(ctx);
 	socket_server_start(SOCKET_SERVER, source, id);
 }
+
+void
+skynet_socket_nodelay(struct skynet_context *ctx, int id) {
+	socket_server_nodelay(SOCKET_SERVER, id);
+}

skynet-src/skynet_socket.h

@@ -25,9 +25,9 @@ int skynet_socket_send(struct skynet_context *ctx, int id, void *buffer, int sz)
 void skynet_socket_send_lowpriority(struct skynet_context *ctx, int id, void *buffer, int sz);
 int skynet_socket_listen(struct skynet_context *ctx, const char *host, int port, int backlog);
 int skynet_socket_connect(struct skynet_context *ctx, const char *host, int port);
-int skynet_socket_block_connect(struct skynet_context *ctx, const char *host, int port);
 int skynet_socket_bind(struct skynet_context *ctx, int fd);
 void skynet_socket_close(struct skynet_context *ctx, int id);
 void skynet_socket_start(struct skynet_context *ctx, int id);
+void skynet_socket_nodelay(struct skynet_context *ctx, int id);
 
 #endif

skynet-src/skynet_start.c

@@ -5,9 +5,9 @@
 #include "skynet_handle.h"
 #include "skynet_module.h"
 #include "skynet_timer.h"
-#include "skynet_harbor.h"
 #include "skynet_monitor.h"
 #include "skynet_socket.h"
+#include "skynet_daemon.h"
 
 #include <pthread.h>
 #include <unistd.h>
@@ -27,6 +27,7 @@ struct monitor {
 struct worker_parm {
 	struct monitor *m;
 	int id;
+	int weight;
 };
 
 #define CHECK_ABORT if (skynet_context_total()==0) break;
@@ -50,6 +51,7 @@ wakeup(struct monitor *m, int busy) {
 static void *
 _socket(void *p) {
 	struct monitor * m = p;
+	skynet_initthread(THREAD_SOCKET);
 	for (;;) {
 		int r = skynet_socket_poll();
 		if (r==0)
@@ -81,6 +83,7 @@ _monitor(void *p) {
 	struct monitor * m = p;
 	int i;
 	int n = m->count;
+	skynet_initthread(THREAD_MONITOR);
 	for (;;) {
 		CHECK_ABORT
 		for (i=0;i<n;i++) {
@@ -98,6 +101,7 @@ _monitor(void *p) {
 static void *
 _timer(void *p) {
 	struct monitor * m = p;
+	skynet_initthread(THREAD_TIMER);
 	for (;;) {
 		skynet_updatetime();
 		CHECK_ABORT
@@ -115,10 +119,14 @@ static void *
 _worker(void *p) {
 	struct worker_parm *wp = p;
 	int id = wp->id;
+	int weight = wp->weight;
 	struct monitor *m = wp->m;
 	struct skynet_monitor *sm = m->m[id];
+	skynet_initthread(THREAD_WORKER);
+	struct message_queue * q = NULL;
 	for (;;) {
-		if (skynet_context_message_dispatch(sm)) {
+		q = skynet_context_message_dispatch(sm, q, weight);
+		if (q == NULL) {
 			CHECK_ABORT
 			if (pthread_mutex_lock(&m->mutex) == 0) {
 				++ m->sleep;
@@ -163,10 +171,20 @@ _start(int thread) {
 	create_thread(&pid[1], _timer, m);
 	create_thread(&pid[2], _socket, m);
 
+	static int weight[] = { 
+		-1, -1, -1, -1, 0, 0, 0, 0,
+		1, 1, 1, 1, 1, 1, 1, 1, 
+		2, 2, 2, 2, 2, 2, 2, 2, 
+		3, 3, 3, 3, 3, 3, 3, 3, };
 	struct worker_parm wp[thread];
 	for (i=0;i<thread;i++) {
 		wp[i].m = m;
 		wp[i].id = i;
+		if (i < sizeof(weight)/sizeof(weight[0])) {
+			wp[i].weight= weight[i];
+		} else {
+			wp[i].weight = 0;
+		}
 		create_thread(&pid[i+3], _worker, &wp[i]);
 	}
 
@@ -177,16 +195,27 @@ _start(int thread) {
 	free_monitor(m);
 }
 
-static int
+static void
-_start_master(const char * master) {
+bootstrap(struct skynet_context * logger, const char * cmdline) {
-	struct skynet_context *ctx = skynet_context_new("master", master);
+	int sz = strlen(cmdline);
-	if (ctx == NULL)
+	char name[sz+1];
-		return 1;
+	char args[sz+1];
-	return 0;	
+	sscanf(cmdline, "%s %s", name, args);
+	struct skynet_context *ctx = skynet_context_new(name, args);
+	if (ctx == NULL) {
+		skynet_error(NULL, "Bootstrap error : %s\n", cmdline);
+		skynet_context_dispatchall(logger);
+		exit(1);
+	}
 }
 
 void 
 skynet_start(struct skynet_config * config) {
+	if (config->daemon) {
+		if (daemon_init(config->daemon)) {
+			exit(1);
+		}
+	}
 	skynet_harbor_init(config->harbor);
 	skynet_handle_init(config->harbor);
 	skynet_mq_init();
@@ -194,32 +223,17 @@ skynet_start(struct skynet_config * config) {
 	skynet_timer_init();
 	skynet_socket_init();
 
-	struct skynet_context *ctx;
+	struct skynet_context *ctx = skynet_context_new("logger", config->logger);
-	ctx = skynet_context_new("logger", config->logger);
 	if (ctx == NULL) {
-		fprintf(stderr,"launch logger error");
+		fprintf(stderr, "Can't launch logger service\n");
 		exit(1);
 	}
 
-	if (config->standalone) {
+	bootstrap(ctx, config->bootstrap);
-		if (_start_master(config->standalone)) {
-			fprintf(stderr, "Init fail : mater");
-			return;
-		}
-	}
-	// harbor must be init first
-	if (skynet_harbor_start(config->master , config->local)) {
-		fprintf(stderr, "Init fail : no master");
-		return;
-	}
-
-	ctx = skynet_context_new("snlua", "launcher");
-	if (ctx) {
-		skynet_command(ctx, "REG", ".launcher");
-		ctx = skynet_context_new("snlua", config->start);
-	}
 
 	_start(config->thread);
 	skynet_socket_free();
+	if (config->daemon) {
+		daemon_exit(config->daemon);
+	}
 }
-

skynet-src/skynet_timer.c

@@ -16,6 +16,9 @@
 
 typedef void (*timer_execute_func)(void *ud,void *arg);
 
+#define LOCK(q) while (__sync_lock_test_and_set(&(q)->lock,1)) {}
+#define UNLOCK(q) __sync_lock_release(&(q)->lock);
+
 #define TIME_NEAR_SHIFT 8
 #define TIME_NEAR (1 << TIME_NEAR_SHIFT)
 #define TIME_LEVEL_SHIFT 6
@@ -45,13 +48,14 @@ struct timer {
 	int time;
 	uint32_t current;
 	uint32_t starttime;
+	uint64_t current_point;
+	uint64_t origin_point;
 };
 
 static struct timer * TI = NULL;
 
 static inline struct timer_node *
-link_clear(struct link_list *list)
+link_clear(struct link_list *list) {
-{
 	struct timer_node * ret = list->head.next;
 	list->head.next = 0;
 	list->tail = &(list->head);
@@ -60,23 +64,20 @@ link_clear(struct link_list *list)
 }
 
 static inline void
-link(struct link_list *list,struct timer_node *node)
+link(struct link_list *list,struct timer_node *node) {
-{
 	list->tail->next = node;
 	list->tail = node;
 	node->next=0;
 }
 
 static void
-add_node(struct timer *T,struct timer_node *node)
+add_node(struct timer *T,struct timer_node *node) {
-{
 	int time=node->expire;
 	int current_time=T->time;
 	
 	if ((time|TIME_NEAR_MASK)==(current_time|TIME_NEAR_MASK)) {
 		link(&T->near[time&TIME_NEAR_MASK],node);
-	}
+	} else {
-	else {
 		int i;
 		int mask=TIME_NEAR << TIME_LEVEL_SHIFT;
 		for (i=0;i<3;i++) {
@@ -90,21 +91,21 @@ add_node(struct timer *T,struct timer_node *node)
 }
 
 static void
-timer_add(struct timer *T,void *arg,size_t sz,int time)
+timer_add(struct timer *T,void *arg,size_t sz,int time) {
-{
 	struct timer_node *node = (struct timer_node *)skynet_malloc(sizeof(*node)+sz);
 	memcpy(node+1,arg,sz);
 
-	while (__sync_lock_test_and_set(&T->lock,1)) {};
+	LOCK(T);
 
 		node->expire=time+T->time;
 		add_node(T,node);
 
-	__sync_lock_release(&T->lock);
+	UNLOCK(T);
 }
 
 static void
 timer_shift(struct timer *T) {
+	LOCK(T);
 	int mask = TIME_NEAR;
 	int time = (++T->time) >> TIME_NEAR_SHIFT;
 	int i=0;
@@ -125,15 +126,11 @@ timer_shift(struct timer *T) {
 		time >>= TIME_LEVEL_SHIFT;
 		++i;
 	}	
+	UNLOCK(T);
 }
 
 static inline void
-timer_execute(struct timer *T) {
+dispatch_list(struct timer_node *current) {
-	int idx = T->time & TIME_NEAR_MASK;
-	
-	while (T->near[idx].head.next) {
-		struct timer_node *current = link_clear(&T->near[idx]);
-		
 	do {
 		struct timer_event * event = (struct timer_event *)(current+1);
 		struct skynet_message message;
@@ -148,27 +145,38 @@ timer_execute(struct timer *T) {
 		current=current->next;
 		skynet_free(temp);	
 	} while (current);
+}
+
+static inline void
+timer_execute(struct timer *T) {
+	LOCK(T);
+	int idx = T->time & TIME_NEAR_MASK;
+	
+	while (T->near[idx].head.next) {
+		struct timer_node *current = link_clear(&T->near[idx]);
+		UNLOCK(T);
+		// dispatch_list don't need lock T
+		dispatch_list(current);
+		LOCK(T);
 	}
+
+	UNLOCK(T);
 }
 
 static void 
-timer_update(struct timer *T)
+timer_update(struct timer *T) {
-{
-	while (__sync_lock_test_and_set(&T->lock,1)) {};
-
 	// try to dispatch timeout 0 (rare condition)
 	timer_execute(T);
 
 	// shift time first, and then dispatch timer message
 	timer_shift(T);
+
 	timer_execute(T);
 
-	__sync_lock_release(&T->lock);
 }
 
 static struct timer *
-timer_create_timer()
+timer_create_timer() {
-{
 	struct timer *r=(struct timer *)skynet_malloc(sizeof(struct timer));
 	memset(r,0,sizeof(*r));
 
@@ -212,18 +220,41 @@ skynet_timeout(uint32_t handle, int time, int session) {
 	return session;
 }
 
-static uint32_t
+// centisecond: 1/100 second
-_gettime(void) {
+static void
-	uint32_t t;
+systime(uint32_t *sec, uint32_t *cs) {
 #if !defined(__APPLE__)
 	struct timespec ti;
-	clock_gettime(CLOCK_MONOTONIC, &ti);
+	clock_gettime(CLOCK_REALTIME, &ti);
-	t = (uint32_t)(ti.tv_sec & 0xffffff) * 100;
+	*sec = (uint32_t)ti.tv_sec;
+	*cs = (uint32_t)(ti.tv_nsec / 10000000);
+#else
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	*sec = tv.tv_sec;
+	*cs = tv.tv_usec / 10000;
+#endif
+}
+
+static uint64_t
+gettime() {
+	uint64_t t;
+#if !defined(__APPLE__)
+
+#ifdef CLOCK_MONOTONIC_RAW
+#define CLOCK_TIMER CLOCK_MONOTONIC_RAW
+#else
+#define CLOCK_TIMER CLOCK_MONOTONIC
+#endif
+
+	struct timespec ti;
+	clock_gettime(CLOCK_TIMER, &ti);
+	t = (uint64_t)ti.tv_sec * 100;
 	t += ti.tv_nsec / 10000000;
 #else
 	struct timeval tv;
 	gettimeofday(&tv, NULL);
-	t = (uint32_t)(tv.tv_sec & 0xffffff) * 100;
+	t = (uint64_t)tv.tv_sec * 100;
 	t += tv.tv_usec / 10000;
 #endif
 	return t;
@@ -231,10 +262,19 @@ _gettime(void) {
 
 void
 skynet_updatetime(void) {
-	uint32_t ct = _gettime();
+	uint64_t cp = gettime();
-	if (ct != TI->current) {
+	if(cp < TI->current_point) {
-		int diff = ct>=TI->current?ct-TI->current:(0xffffff+1)*100-TI->current+ct;
+		skynet_error(NULL, "time diff error: change from %lld to %lld", cp, TI->current_point);
-		TI->current = ct;
+	} else if (cp != TI->current_point) {
+		uint32_t diff = (uint32_t)(cp - TI->current_point);
+		TI->current_point = cp;
+
+		uint32_t oc = TI->current;
+		TI->current += diff;
+		if (TI->current < oc) {
+			// when cs > 0xffffffff(about 497 days), time rewind
+			TI->starttime += 0xffffffff / 100;
+		}
 		int i;
 		for (i=0;i<diff;i++) {
 			timer_update(TI);
@@ -255,18 +295,9 @@ skynet_gettime(void) {
 void 
 skynet_timer_init(void) {
 	TI = timer_create_timer();
-	TI->current = _gettime();
+	systime(&TI->starttime, &TI->current);
-
+	uint64_t point = gettime();
-#if !defined(__APPLE__)
+	TI->current_point = point;
-	struct timespec ti;
+	TI->origin_point = point;
-	clock_gettime(CLOCK_REALTIME, &ti);
-	uint32_t sec = (uint32_t)ti.tv_sec;
-#else
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	uint32_t sec = (uint32_t)tv.tv_sec;
-#endif
-	uint32_t mono = _gettime() / 100;
-
-	TI->starttime = sec - mono;
 }
+

skynet-src/socket_server.c

@@ -5,6 +5,7 @@
 
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <netinet/tcp.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdlib.h>
@@ -34,6 +35,8 @@
 #define PRIORITY_HIGH 0
 #define PRIORITY_LOW 1
 
+#define HASH_ID(id) (((unsigned)id) % MAX_SOCKET)
+
 struct write_buffer {
 	struct write_buffer * next;
 	char *ptr;
@@ -107,6 +110,12 @@ struct request_start {
 	uintptr_t opaque;
 };
 
+struct request_setopt {
+	int id;
+	int what;
+	int value;
+};
+
 struct request_package {
 	uint8_t header[8];	// 6 bytes dummy
 	union {
@@ -117,6 +126,7 @@ struct request_package {
 		struct request_listen listen;
 		struct request_bind bind;
 		struct request_start start;
+		struct request_setopt setopt;
 	} u;
 	uint8_t dummy[256];
 };
@@ -144,9 +154,11 @@ reserve_id(struct socket_server *ss) {
 		if (id < 0) {
 			id = __sync_and_and_fetch(&(ss->alloc_id), 0x7fffffff);
 		}
-		struct socket *s = &ss->slot[id % MAX_SOCKET];
+		struct socket *s = &ss->slot[HASH_ID(id)];
 		if (s->type == SOCKET_TYPE_INVALID) {
 			if (__sync_bool_compare_and_swap(&s->type, SOCKET_TYPE_INVALID, SOCKET_TYPE_RESERVE)) {
+				s->id = id;
+				s->fd = -1;
 				return id;
 			} else {
 				// retry
@@ -265,7 +277,7 @@ check_wb_list(struct wb_list *s) {
 
 static struct socket *
 new_fd(struct socket_server *ss, int id, int fd, uintptr_t opaque, bool add) {
-	struct socket * s = &ss->slot[id % MAX_SOCKET];
+	struct socket * s = &ss->slot[HASH_ID(id)];
 	assert(s->type == SOCKET_TYPE_RESERVE);
 
 	if (add) {
@@ -287,7 +299,7 @@ new_fd(struct socket_server *ss, int id, int fd, uintptr_t opaque, bool add) {
 
 // return -1 when connecting
 static int
-open_socket(struct socket_server *ss, struct request_open * request, struct socket_message *result, bool blocking) {
+open_socket(struct socket_server *ss, struct request_open * request, struct socket_message *result) {
 	int id = request->id;
 	result->opaque = request->opaque;
 	result->id = id;
@@ -316,18 +328,14 @@ open_socket(struct socket_server *ss, struct request_open * request, struct sock
 			continue;
 		}
 		socket_keepalive(sock);
-		if (!blocking) {
 		sp_nonblocking(sock);
-		}
 		status = connect( sock, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
 		if ( status != 0 && errno != EINPROGRESS) {
 			close(sock);
 			sock = -1;
 			continue;
 		}
-		if (blocking) {
 		sp_nonblocking(sock);
-		}
 		break;
 	}
 
@@ -359,7 +367,7 @@ open_socket(struct socket_server *ss, struct request_open * request, struct sock
 	return -1;
 _failed:
 	freeaddrinfo( ai_list );
-	ss->slot[id % MAX_SOCKET].type = SOCKET_TYPE_INVALID;
+	ss->slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID;
 	return SOCKET_ERROR;
 }
 
@@ -504,7 +512,7 @@ send_buffer_empty(struct socket *s) {
 static int
 send_socket(struct socket_server *ss, struct request_send * request, struct socket_message *result, int priority) {
 	int id = request->id;
-	struct socket * s = &ss->slot[id % MAX_SOCKET];
+	struct socket * s = &ss->slot[HASH_ID(id)];
 	if (s->type == SOCKET_TYPE_INVALID || s->id != id 
 		|| s->type == SOCKET_TYPE_HALFCLOSE
 		|| s->type == SOCKET_TYPE_PACCEPT) {
@@ -512,7 +520,7 @@ send_socket(struct socket_server *ss, struct request_send * request, struct sock
 		return -1;
 	}
 	assert(s->type != SOCKET_TYPE_PLISTEN && s->type != SOCKET_TYPE_LISTEN);
-	if (send_buffer_empty(s)) {
+	if (send_buffer_empty(s) && s->type == SOCKET_TYPE_CONNECTED) {
 		int n = write(s->fd, request->buffer, request->sz);
 		if (n<0) {
 			switch(errno) {
@@ -558,7 +566,7 @@ _failed:
 	result->id = id;
 	result->ud = 0;
 	result->data = NULL;
-	ss->slot[id % MAX_SOCKET].type = SOCKET_TYPE_INVALID;
+	ss->slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID;
 
 	return SOCKET_ERROR;
 }
@@ -566,7 +574,7 @@ _failed:
 static int
 close_socket(struct socket_server *ss, struct request_close *request, struct socket_message *result) {
 	int id = request->id;
-	struct socket * s = &ss->slot[id % MAX_SOCKET];
+	struct socket * s = &ss->slot[HASH_ID(id)];
 	if (s->type == SOCKET_TYPE_INVALID || s->id != id) {
 		result->id = id;
 		result->opaque = request->opaque;
@@ -614,7 +622,7 @@ start_socket(struct socket_server *ss, struct request_start *request, struct soc
 	result->opaque = request->opaque;
 	result->ud = 0;
 	result->data = NULL;
-	struct socket *s = &ss->slot[id % MAX_SOCKET];
+	struct socket *s = &ss->slot[HASH_ID(id)];
 	if (s->type == SOCKET_TYPE_INVALID || s->id !=id) {
 		return SOCKET_ERROR;
 	}
@@ -635,6 +643,17 @@ start_socket(struct socket_server *ss, struct request_start *request, struct soc
 	return -1;
 }
 
+static void
+setopt_socket(struct socket_server *ss, struct request_setopt *request) {
+	int id = request->id;
+	struct socket *s = &ss->slot[HASH_ID(id)];
+	if (s->type == SOCKET_TYPE_INVALID || s->id !=id) {
+		return;
+	}
+	int v = request->value;
+	setsockopt(s->fd, IPPROTO_TCP, request->what, &v, sizeof(v));
+}
+
 static void
 block_readpipe(int pipefd, void *buffer, int sz) {
 	for (;;) {
@@ -687,7 +706,7 @@ ctrl_cmd(struct socket_server *ss, struct socket_message *result) {
 	case 'K':
 		return close_socket(ss,(struct request_close *)buffer, result);
 	case 'O':
-		return open_socket(ss, (struct request_open *)buffer, result, false);
+		return open_socket(ss, (struct request_open *)buffer, result);
 	case 'X':
 		result->opaque = 0;
 		result->id = 0;
@@ -698,6 +717,9 @@ ctrl_cmd(struct socket_server *ss, struct socket_message *result) {
 		return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_HIGH);
 	case 'P':
 		return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_LOW);
+	case 'T':
+		setopt_socket(ss, (struct request_setopt *)buffer);
+		return -1;
 	default:
 		fprintf(stderr, "socket-server: Unknown ctrl %c.\n",type);
 		return -1;
@@ -765,7 +787,9 @@ report_connect(struct socket_server *ss, struct socket *s, struct socket_message
 		result->opaque = s->opaque;
 		result->id = s->id;
 		result->ud = 0;
+		if (send_buffer_empty(s)) {
 			sp_write(ss->event_fd, s->fd, s, false);
+		}
 		union sockaddr_all u;
 		socklen_t slen = sizeof(u);
 		if (getpeername(s->fd, &u.s, &slen) == 0) {
@@ -815,6 +839,22 @@ report_accept(struct socket_server *ss, struct socket *s, struct socket_message
 	return 1;
 }
 
+static inline void 
+clear_closed_event(struct socket_server *ss, struct socket_message * result, int type) {
+	if (type == SOCKET_CLOSE || type == SOCKET_ERROR) {
+		int id = result->id;
+		int i;
+		for (i=ss->event_index; i<ss->event_n; i++) {
+			struct event *e = &ss->ev[i];
+			struct socket *s = e->s;
+			if (s) {
+				if (s->type == SOCKET_TYPE_INVALID && s->id == id) {
+					e->s = NULL;
+				}
+			}
+		}
+	}
+}
 
 // return type
 int 
@@ -823,9 +863,10 @@ socket_server_poll(struct socket_server *ss, struct socket_message * result, int
 		if (ss->checkctrl) {
 			if (has_cmd(ss)) {
 				int type = ctrl_cmd(ss, result);
-				if (type != -1)
+				if (type != -1) {
+					clear_closed_event(ss, result, type);
 					return type;
-				else
+				} else
 					continue;
 			} else {
 				ss->checkctrl = 0;
@@ -865,12 +906,14 @@ socket_server_poll(struct socket_server *ss, struct socket_message * result, int
 				int type = send_buffer(ss, s, result);
 				if (type == -1)
 					break;
+				clear_closed_event(ss, result, type);
 				return type;
 			}
 			if (e->read) {
 				int type = forward_message(ss, s, result);
 				if (type == -1)
 					break;
+				clear_closed_event(ss, result, type);
 				return type;
 			}
 			break;
@@ -920,27 +963,13 @@ socket_server_connect(struct socket_server *ss, uintptr_t opaque, const char * a
 	return request.u.open.id;
 }
 
-int 
-socket_server_block_connect(struct socket_server *ss, uintptr_t opaque, const char * addr, int port) {
-	struct request_package request;
-	struct socket_message result;
-	open_request(ss, &request, opaque, addr, port);
-	int ret = open_socket(ss, &request.u.open, &result, true);
-	if (ret == SOCKET_OPEN) {
-		return result.id;
-	} else {
-		return -1;
-	}
-}
-
 // return -1 when error
 int64_t 
 socket_server_send(struct socket_server *ss, int id, const void * buffer, int sz) {
-	struct socket * s = &ss->slot[id % MAX_SOCKET];
+	struct socket * s = &ss->slot[HASH_ID(id)];
 	if (s->id != id || s->type == SOCKET_TYPE_INVALID) {
 		return -1;
 	}
-	assert(s->type != SOCKET_TYPE_RESERVE);
 
 	struct request_package request;
 	request.u.send.id = id;
@@ -953,11 +982,10 @@ socket_server_send(struct socket_server *ss, int id, const void * buffer, int sz
 
 void 
 socket_server_send_lowpriority(struct socket_server *ss, int id, const void * buffer, int sz) {
-	struct socket * s = &ss->slot[id % MAX_SOCKET];
+	struct socket * s = &ss->slot[HASH_ID(id)];
 	if (s->id != id || s->type == SOCKET_TYPE_INVALID) {
 		return;
 	}
-	assert(s->type != SOCKET_TYPE_RESERVE);
 
 	struct request_package request;
 	request.u.send.id = id;
@@ -1049,4 +1077,11 @@ socket_server_start(struct socket_server *ss, uintptr_t opaque, int id) {
 	send_request(ss, &request, 'S', sizeof(request.u.start));
 }
 
-
+void
+socket_server_nodelay(struct socket_server *ss, int id) {
+	struct request_package request;
+	request.u.setopt.id = id;
+	request.u.setopt.what = TCP_NODELAY;
+	request.u.setopt.value = 1;
+	send_request(ss, &request, 'T', sizeof(request.u.setopt));
+}

skynet-src/socket_server.h

@@ -36,6 +36,6 @@ int socket_server_listen(struct socket_server *, uintptr_t opaque, const char *
 int socket_server_connect(struct socket_server *, uintptr_t opaque, const char * addr, int port);
 int socket_server_bind(struct socket_server *, uintptr_t opaque, int fd);
 
-int socket_server_block_connect(struct socket_server *, uintptr_t opaque, const char * addr, int port);
+void socket_server_nodelay(struct socket_server *, int id);
 
 #endif

test/pingqueue.lua

@@ -1,12 +0,0 @@
-local skynet = require "skynet"
-local mqueue = require "mqueue"
-
-skynet.start(function()
-	local id = 0
-	local pingserver = skynet.newservice "pingserver"
-	mqueue.register(function(str)
-		id = id + 1
-		str = string.format("id = %d , %s",id, str)
-		return skynet.call(pingserver, "lua", "PING", str)
-	end)
-end)

test/pingserver.lua

@@ -1,4 +1,5 @@
 local skynet = require "skynet"
+local queue = require "skynet.queue"
 
 local i = 0
 local hello = "hello"
@@ -8,9 +9,27 @@ function response.ping(hello)
 	return hello
 end
 
+-- response.sleep and accept.hello share one lock
+local lock
+
+function accept.sleep(queue, n)
+	if queue then
+		lock(
+		function()
+			print("queue=",queue, n)
+			skynet.sleep(n)
+		end)
+	else
+		print("queue=",queue, n)
+		skynet.sleep(n)
+	end
+end
+
 function accept.hello()
+	lock(function()
 	i = i + 1
 	print (i, hello)
+	end)
 end
 
 function response.error()
@@ -19,6 +38,8 @@ end
 
 function init( ... )
 	print ("ping server start:", ...)
+	-- init queue
+	lock = queue()
 
 -- You can return "queue" for queue service mode
 --	return "queue"

test/testdatacenter.lua

@@ -0,0 +1,23 @@
+local skynet = require "skynet"
+local datacenter = require "datacenter"
+
+local function f1()
+	print("====1==== wait hello")
+	print("\t1>",datacenter.wait ("hello"))
+	print("====1==== wait key.foobar")
+	print("\t1>", pcall(datacenter.wait,"key"))	-- will failed, because "key" is a branch
+	print("\t1>",datacenter.wait ("key", "foobar"))
+end
+
+local function f2()
+	skynet.sleep(10)
+	print("====2==== set key.foobar")
+	datacenter.set("key", "foobar", "bingo")
+end
+
+skynet.start(function()
+	datacenter.set("hello", "world")
+	print(datacenter.get "hello")
+	skynet.fork(f1)
+	skynet.fork(f2)
+end)

test/testdeadcall.lua

@@ -0,0 +1,25 @@
+local skynet = require "skynet"
+
+local mode = ...
+
+if mode == "test" then
+
+skynet.start(function()
+	skynet.dispatch("lua", function (...)
+		print("====>", ...)
+		skynet.exit()
+	end)
+end)
+
+else
+
+	skynet.start(function()
+		local test = skynet.newservice(SERVICE_NAME, "test")	-- launch self in test mode
+
+		print(pcall(function()
+			skynet.call(test,"lua", "dead call")
+		end))
+
+		skynet.exit()
+	end)
+end

test/testharborlink.lua

@@ -0,0 +1,11 @@
+local skynet = require "skynet"
+local harbor = require "skynet.harbor"
+
+skynet.start(function()
+	print("wait for harbor 2")
+	print("run skynet examples/config_log please")
+	harbor.connect(2)
+	print("harbor 2 connected")
+	harbor.link(2)
+	print("disconnected")
+end)

test/testlog.lua

@@ -1,9 +0,0 @@
-local skynet = require "skynet"
-local log = require "log"
-
-skynet.start(function()
-	log.Info("hello world")
-	skynet.exit()
-end)
-
-

test/testmulticast.lua

@@ -0,0 +1,40 @@
+local skynet = require "skynet"
+local mc = require "multicast"
+local dc = require "datacenter"
+
+local mode = ...
+
+if mode == "sub" then
+
+skynet.start(function()
+	skynet.dispatch("lua", function (_,_, cmd, channel)
+		assert(cmd == "init")
+		local c = mc.new {
+			channel = channel ,
+			dispatch = function (channel, source, ...)
+				print(string.format("%s <=== %s %s",skynet.address(skynet.self()),skynet.address(source), channel), ...)
+			end
+		}
+		print(skynet.address(skynet.self()), "sub", c)
+		c:subscribe()
+		skynet.ret(skynet.pack())
+	end)
+end)
+
+else
+
+skynet.start(function()
+	local channel = mc.new()
+	print("New channel", channel)
+	for i=1,10 do
+		local sub = skynet.newservice(SERVICE_NAME, "sub")
+		skynet.call(sub, "lua", "init", channel.channel)
+	end
+
+	dc.set("MCCHANNEL", channel.channel)	-- for multi node test
+
+	print(skynet.address(skynet.self()), "===>", channel)
+	channel:publish("Hello World")
+end)
+
+end

test/testmulticast2.lua

@@ -0,0 +1,24 @@
+local skynet = require "skynet"
+local dc = require "datacenter"
+local mc = require "multicast"
+
+skynet.start(function()
+	print("remote start")
+	skynet.monitor("simplemonitor", true)
+	local console = skynet.newservice("console")
+	local channel = dc.get "MCCHANNEL"
+	for i=1,10 do
+		local sub = skynet.newservice("testmulticast", "sub")
+		skynet.call(sub, "lua", "init", channel)
+	end
+	local c = mc.new {
+		channel = channel ,
+		dispatch = function(...) print("======>", ...) end,
+	}
+	c:subscribe()
+	c:publish("Remote message")
+	c:unsubscribe()
+	c:publish("Remote message2")
+	c:delete()
+	skynet.exit()
+end)

test/testping.lua

@@ -2,7 +2,7 @@ local skynet = require "skynet"
 local snax = require "snax"
 
 skynet.start(function()
-	local ps = snax.newservice ("pingserver", "hello world")
+	local ps = snax.uniqueservice ("pingserver", "hello world")
 	print(ps.req.ping("foobar"))
 	print(ps.post.hello())
 	print(pcall(ps.req.error))

test/testqueue.lua

@@ -0,0 +1,18 @@
+local skynet = require "skynet"
+local snax = require "snax"
+
+skynet.start(function()
+	local ps = snax.uniqueservice ("pingserver", "test queue")
+	for i=1, 10 do
+		ps.post.sleep(true,i*10)
+		ps.post.hello()
+	end
+	for i=1, 10 do
+		ps.post.sleep(false,i*10)
+		ps.post.hello()
+	end
+
+	skynet.exit()
+end)
+
+

test/testredis2.lua

@@ -0,0 +1,53 @@
+local skynet = require "skynet"
+local redis  = require "redis"
+
+local db
+
+function add1(key, count)
+    local t = {}
+    for i = 1, count do
+        t[2*i -1] = "key" ..i
+        t[2*i] = "value" .. i
+    end
+    db:hmset(key, table.unpack(t))
+end
+
+function add2(key, count)
+    local t = {}
+    for i = 1, count do
+        t[2*i -1] = "key" ..i
+        t[2*i] = "value" .. i
+    end
+    table.insert(t, 1, key)
+    db:hmset(t)
+end
+
+function __init__()
+    db = redis.connect {
+        host = "127.0.0.1",
+        port = 6300,
+        db   = 0,
+        auth = "foobared"
+    }
+    print("dbsize:", db:dbsize())
+    local ok, msg = xpcall(add1, debug.traceback, "test1", 250000)
+    if not ok then
+        print("add1 failed", msg)
+    else
+        print("add1 succeed")
+
+    end
+
+    local ok, msg = xpcall(add2, debug.traceback, "test2", 250000)
+    if not ok then
+        print("add2 failed", msg)
+    else
+        print("add2 succeed")
+    end
+    print("dbsize:", db:dbsize())
+
+    print("redistest launched")
+end
+
+skynet.start(__init__)
+

test/testsocket.lua

@@ -21,6 +21,9 @@ if mode == "agent" then
 	id = tonumber(id)
 
 	skynet.start(function()
+		-- A small limit, if socket buffer overflow, close the client
+		socket.limit(64)
+
 		skynet.fork(function()
 			echo(id)
 			skynet.exit()
@@ -30,14 +33,15 @@ else
 	local function accept(id)
 		socket.start(id)
 		socket.write(id, "Hello Skynet\n")
-		skynet.newservice("testsocket", "agent", id)
+		skynet.newservice(SERVICE_NAME, "agent", id)
 		-- notice: Some data on this connection(id) may lost before new service start.
 		-- So, be careful when you want to use start / abandon / start .
 		socket.abandon(id)
 	end
 
 	skynet.start(function()
-		local id = socket.listen("127.0.0.1", 8000)
+		local id = socket.listen("127.0.0.1", 8001)
+		print("Listen socket :", "127.0.0.1", 8001)
 
 		socket.start(id , function(id, addr)
 			print("connect from " .. addr .. " " .. id)

test/time.lua

@@ -0,0 +1,22 @@
+local skynet = require "skynet"
+skynet.start(function()
+    print(skynet.starttime())
+    print(skynet.now())
+
+    skynet.timeout(1, function()
+        print("in 1", skynet.now())
+    end)
+    skynet.timeout(2, function()
+        print("in 2", skynet.now())
+    end)
+    skynet.timeout(3, function()
+        print("in 3", skynet.now())
+    end)
+
+    skynet.timeout(4, function()
+        print("in 4", skynet.now())
+    end)
+    skynet.timeout(100, function()
+        print("in 100", skynet.now())
+    end)
+end)