diff --git a/.github/ISSUE_TEMPLATE/bug-report.md b/.github/ISSUE_TEMPLATE/bug-report.md
new file mode 100644
index 00000000..8e65e36a
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug-report.md
@@ -0,0 +1,18 @@
+---
+name: "\U0001F41B Bug Report"
+labels: "bug"
+about: Something isn't working as expected
+
+---
+
+## Bug Report
+
+Please answer these questions before submitting your issue. Thanks!
+
+1. What did you do? If possible, provide a recipe for reproducing the error.
+
+2. What did you expect to see?
+
+3. What did you see instead?
+
+4. Versions of the `nano`
diff --git a/.github/ISSUE_TEMPLATE/feature-request.md b/.github/ISSUE_TEMPLATE/feature-request.md
new file mode 100644
index 00000000..45e38b9d
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature-request.md
@@ -0,0 +1,20 @@
+---
+name: "\U0001F680 Feature Request"
+labels: "feature-request"
+about: I have a suggestion
+
+---
+
+## Feature Request
+
+**Is your feature request related to a problem? Please describe:**
+<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
+
+**Describe the feature you'd like:**
+<!-- A clear and concise description of what you want to happen. -->
+
+**Describe alternatives you've considered:**
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+**Teachability, Documentation, Adoption, Optimization:**
+<!-- If you can, explain some scenarios how users might use this, situations it would be helpful in. Any API designs, mockups, or diagrams are also helpful. -->
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md
new file mode 100644
index 00000000..c55d0a57
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question.md
@@ -0,0 +1,14 @@
+---
+name: "\U0001F914 Question"
+labels: "question"
+about: Usage question that isn't answered in docs or discussion
+
+---
+
+## Question
+
+Before asking a question, make sure you have:
+
+- Searched existing Stack Overflow questions.
+- Googled your question.
+- Searched open and closed [GitHub issues](https://github.com/lonng/nano/issues?q=is%3Aissue)
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..84af8240
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,30 @@
+<!--
+Thank you for contributing to Nano! Please read the [CONTRIBUTING](https://github.com/lonng/nano/blob/master/CONTRIBUTING.md) document **BEFORE** filing this PR.
+-->
+
+### What problem does this PR solve? <!--add issue link with summary if exists-->
+
+
+### What is changed and how it works?
+
+
+### Check List <!--REMOVE the items that are not applicable-->
+
+Tests <!-- At least one of them must be included. -->
+
+ - Unit test
+ - Integration test
+ - Manual test (add detailed scripts or steps below)
+ - No code
+
+Side effects
+
+ - Possible performance regression
+ - Increased code complexity
+ - Breaking backward compatibility
+
+Related changes
+
+ - Need to cherry-pick to the release branch
+ - Need to update the documentation
+ - Need to be included in the release note
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000..47e873d7
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,94 @@
+# How to contribute
+
+This document outlines some of the conventions on development workflow, commit
+message formatting, contact points and other resources to make it easier to get
+your contribution accepted.
+
+## Getting started
+
+- Fork the repository on GitHub.
+- Read the README.md for build instructions.
+- Play with the project, submit bugs, submit patches!
+
+## Building Nano
+
+Developing Nano requires:
+
+* [Go 1.12](http://golang.org/doc/code.html)
+* An internet connection to download the dependencies
+
+Simply run `make` to build the program.
+
+```sh
+make
+```
+
+### Running tests
+
+This project contains unit tests and integration tests with coverage collection.
+See [tests/README.md](./tests/README.md) for how to execute and add tests.
+
+### Updating dependencies
+
+Failpoint manages dependencies using [Go module](https://github.com/golang/go/wiki/Modules).
+To add or update a dependency, either
+
+* Use the `go mod edit` command to change the dependency, or
+* Edit `go.mod` and then run `make update` to update the checksum.
+
+## Contribution flow
+
+This is a rough outline of what a contributor's workflow looks like:
+
+- Create a topic branch from where you want to base your work. This is usually `master`.
+- Make commits of logical units and add test case if the change fixes a bug or adds new functionality.
+- Run tests and make sure all the tests are passed.
+- Make sure your commit messages are in the proper format (see below).
+- Push your changes to a topic branch in your fork of the repository.
+- Submit a pull request.
+- Your PR must receive LGTMs from two maintainers.
+
+Thanks for your contributions!
+
+### Code style
+
+The coding style suggested by the Golang community is used in `failpoint`.
+See the [style doc](https://github.com/golang/go/wiki/CodeReviewComments) for details.
+
+Please follow this style to makeg `failpoint` easy to review, maintain and develop.
+
+### Format of the Commit Message
+
+We follow a rough convention for commit messages that is designed to answer two
+questions: what changed and why. The subject line should feature the what and
+the body of the commit should describe the why.
+
+```
+restore: add comment for variable declaration
+
+Improve documentation.
+```
+
+The format can be described more formally as follows:
+
+```
+<subsystem>: <what changed>
+<BLANK LINE>
+<why this change was made>
+<BLANK LINE>
+<footer>(optional)
+```
+
+The first line is the subject and should be no longer than 70 characters, the
+second line is always blank, and other lines should be wrapped at 80 characters.
+This allows the message to be easier to read on GitHub as well as in various
+git tools.
+
+If the change affects more than one subsystem, you can use comma to separate them like `code,examples:`.
+
+If the change affects many subsystems, you can use ```*``` instead, like ```*:```.
+
+For the why part, if no specific reason for the change,
+you can use one of some generic reasons like "Improve documentation.",
+"Improve performance.", "Improve robustness.", "Improve test coverage."
+
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
new file mode 100644
index 00000000..adc91a6f
--- /dev/null
+++ b/MAINTAINERS.md
@@ -0,0 +1,13 @@
+# Maintainers
+
+This file lists who are the core maintainers of the nano project.
+
+## Project Lead
+
+* [Lonng](https://github.com/lonng)
+
+## Other Core Maintainers
+
+* None
+
+
diff --git a/README.md b/README.md
index 95c61b4c..a32ef765 100644
--- a/README.md
+++ b/README.md
@@ -1,178 +1,178 @@
-# Nano [![Build Status][1]][2] [![GoDoc][3]][4] [![Go Report Card][5]][6] [![MIT licensed][7]][8] 
-
-[1]: https://travis-ci.org/lonng/nano.svg?branch=master
-[2]: https://travis-ci.org/lonng/nano
-[3]: https://godoc.org/github.com/lonng/nano?status.svg
-[4]: https://godoc.org/github.com/lonng/nano
-[5]: https://goreportcard.com/badge/github.com/lonng/nano
-[6]: https://goreportcard.com/report/github.com/lonng/nano
-[7]: https://img.shields.io/badge/license-MIT-blue.svg
-[8]: LICENSE
-
-Nano is an easy to use, fast, lightweight game server networking library for Go.
-It provides a core network architecture and a series of tools and libraries that
-can help developers eliminate boring duplicate work for common underlying logic.
-The goal of nano is to improve development efficiency by eliminating the need to
-spend time on repetitious network related programming.
-
-Nano was designed for server-side applications like real-time games, social games,
-mobile games, etc of all sizes.
-
-## How to build a system with `Nano`
-
-#### What does a `Nano` application look like?
-
-The simplest "nano" application as shown in the following figure, you can make powerful applications by combining different components.
-
-![Application](./application.png)
-
-In fact, the `nano` application is a collection of  [Component ](./docs/get_started.md#component) , and a component is a bundle of  [Handler](./docs/get_started.md#handler), once you register a component to nano, nano will register all methods that can be converted to `Handler` to nano service container. Service was accessed by `Component.Handler`, and the handler will be called while client request. The handler will receive two parameters while handling a message:
-  - `*session.Session`: corresponding a client that apply this request or notify.
-  - `*protocol.FooBar`: the payload of the request.
-
-While you had processed your logic, you can response or push message to the client by `session.Response(payload)` and `session.Push('eventName', payload)`, or returns error when some unexpected data received.
-
-#### How to build distributed system with `Nano`
-
-Nano has no built-in distributed system components, but you can easily implement it with `gRPC` and `smux` . Here we take grpc as an example.
-
-- First of all, you need to define a remote component
-```go
-type RemoteComponent struct {
-	rpcClients []*grpc.ClientConn
-}
-```
-
-- Second, fetch all grpc servers infomation from services like `etcd` or `consul`  in `nano` lifetime hooks
-```go
-type ServerInfo struct {
-	Host string `json:"host"`
-	Port int    `json:"port"`
-}
-
-// lifetime callback
-func (r *RemoteComponent) Init() {
-	// fetch server list from etcd
-	resp, err := http.Get("http://your_etcd_server/backend/server_list/area/10023")
-	if err != nil {
-		panic(err)
-	}
-	
-	servers := []ServerInfo{}
-	if err := json.NewDecoder(resp.Body).Decode(&servers); err != nil {
-		panic(err)
-	}
-	
-	for i := range servers {
-		server := servers[i]
-		client, err := grpc.Dial(fmt.Sprintf("%s:%d", server.Host, server.Post), options)
-		if err != nil {
-			panic(err)
-		}
-		r.rpcClients = append(r.rpcClients, client)
-	}
-}
-
-func (r *RemoteComponent) client(s *session.Session) *grpc.ClientConn {
-	// load balance
-	return r.rpcClients[s.UID() % len(s.rpcClients)]
-}
-
-// Your handler, accessed by:
-// nanoClient.Request("RemoteComponent.DemoHandler", &pb.DemoMsg{/*...*/})
-func (r *RemoteComponent) DemoHandler(s *session.Session, msg *pb.DemoMsg) error {
-	client := r.client(s)
-	// do something with client
-	// ....
-	// ...
-	return nil
-}
-```
-
-The Nano will remain simple, but you can perform any operations in the component and get the desired goals. You can startup a group of `Nano` application as agent to dispatch message to backend servers.
-
-#### How to execute the asynchronous task
-
-```go
-func (manager *PlayerManager) Login(s *session.Session, msg *ReqPlayerLogin) error {
-    var onDBResult = func(player *Player) {
-        manager.players = append(manager.players, player)
-        s.Push("PlayerSystem.LoginSuccess", &ResPlayerLogin)
-    }
-    
-    // run slow task in new gorontine
-    go func() {
-        player, err := db.QueryPlayer(msg.PlayerId) // ignore error in demo
-        // handle result in main logical gorontine
-        nano.Invoke(func(){ onDBResult(player) })
-    }
-    return nil
-}
-```
-
-## Documents
-
-- English
-    + [How to build your first nano application](./docs/get_started.md)
-    + [Route compression](./docs/route_compression.md)
-    + [Communication protocol](./docs/communication_protocol.md)
-    + [Design patterns](./docs/design_patterns.md)
-    + [API Reference(Server)](https://godoc.org/github.com/lonnng/nano)
-    + [How to integrate `Lua` into `Nano` component(incomplete)](.)
-
-- 简体中文
-    + [如何构建你的第一个nano应用](./docs/get_started_zh_CN.md)
-    + [路由压缩](./docs/route_compression_zh_CN.md)
-    + [通信协议](./docs/communication_protocol_zh_CN.md)
-    + [API参考(服务器)](https://godoc.org/github.com/lonnng/nano)
-    + [如何将`lua`脚本集成到`nano`组件中(未完成)](.)
-
-## Resources
-
-- Javascript
-  + [nano-websocket-client](https://github.com/lonnng/nano-websocket-client)
-  + [nano-egret-client](https://github.com/lonnng/nano-egret-client)
-
-- Demo
-  + [Implement a chat room in 100 lines with nano and WebSocket](./examples/demo/chat)
-  + [Tadpole demo](./examples/demo/tadpole)
-  + [四川麻将, 血战到底(三人模式/四人模式)完整项目实例](https://github.com/lonnng/nanoserver)
-
-## Community
-
-- QQGroup: [289680347](https://jq.qq.com/?_wv=1027&k=4EMMaha)
-- Reddit: [nanolabs](https://www.reddit.com/r/nanolabs/)
-
-## Successful cases
-
-- [空来血战](https://fir.im/tios)
-
-## Go version
-
-`> go1.8`
-
-## Installation
-
-```shell
-go get github.com/lonng/nano
-
-# dependencies
-go get -u github.com/golang/protobuf
-go get -u github.com/gorilla/websocket
-```
-
-## Benchmark
-
-```shell
-# Case:   PingPong
-# OS:     Windows 10
-# Device: i5-6500 3.2GHz 4 Core/1000-Concurrent   => IOPS 11W(Average)
-# Other:  ...
-
-cd $GOPATH/src/github.com/lonng/nano/benchmark/io
-go test -v -tags "benchmark"
-```
-
-## License
-
-[MIT License](./LICENSE)
+# Nano [![Build Status][1]][2] [![GoDoc][3]][4] [![Go Report Card][5]][6] [![MIT licensed][7]][8] 
+
+[1]: https://travis-ci.org/lonng/nano.svg?branch=master
+[2]: https://travis-ci.org/lonng/nano
+[3]: https://godoc.org/github.com/lonng/nano?status.svg
+[4]: https://godoc.org/github.com/lonng/nano
+[5]: https://goreportcard.com/badge/github.com/lonng/nano
+[6]: https://goreportcard.com/report/github.com/lonng/nano
+[7]: https://img.shields.io/badge/license-MIT-blue.svg
+[8]: LICENSE
+
+Nano is an easy to use, fast, lightweight game server networking library for Go.
+It provides a core network architecture and a series of tools and libraries that
+can help developers eliminate boring duplicate work for common underlying logic.
+The goal of nano is to improve development efficiency by eliminating the need to
+spend time on repetitious network related programming.
+
+Nano was designed for server-side applications like real-time games, social games,
+mobile games, etc of all sizes.
+
+## How to build a system with `Nano`
+
+#### What does a `Nano` application look like?
+
+The simplest "nano" application as shown in the following figure, you can make powerful applications by combining different components.
+
+![Application](media/application.png)
+
+In fact, the `nano` application is a collection of  [Component ](./docs/get_started.md#component) , and a component is a bundle of  [Handler](./docs/get_started.md#handler), once you register a component to nano, nano will register all methods that can be converted to `Handler` to nano service container. Service was accessed by `Component.Handler`, and the handler will be called while client request. The handler will receive two parameters while handling a message:
+  - `*session.Session`: corresponding a client that apply this request or notify.
+  - `*protocol.FooBar`: the payload of the request.
+
+While you had processed your logic, you can response or push message to the client by `session.Response(payload)` and `session.Push('eventName', payload)`, or returns error when some unexpected data received.
+
+#### How to build distributed system with `Nano`
+
+Nano has no built-in distributed system components, but you can easily implement it with `gRPC` and `smux` . Here we take grpc as an example.
+
+- First of all, you need to define a remote component
+```go
+type RemoteComponent struct {
+	rpcClients []*grpc.ClientConn
+}
+```
+
+- Second, fetch all grpc servers infomation from services like `etcd` or `consul`  in `nano` lifetime hooks
+```go
+type ServerInfo struct {
+	Host string `json:"host"`
+	Port int    `json:"port"`
+}
+
+// lifetime callback
+func (r *RemoteComponent) Init() {
+	// fetch server list from etcd
+	resp, err := http.Get("http://your_etcd_server/backend/server_list/area/10023")
+	if err != nil {
+		panic(err)
+	}
+	
+	servers := []ServerInfo{}
+	if err := json.NewDecoder(resp.Body).Decode(&servers); err != nil {
+		panic(err)
+	}
+	
+	for i := range servers {
+		server := servers[i]
+		client, err := grpc.Dial(fmt.Sprintf("%s:%d", server.Host, server.Post), options)
+		if err != nil {
+			panic(err)
+		}
+		r.rpcClients = append(r.rpcClients, client)
+	}
+}
+
+func (r *RemoteComponent) client(s *session.Session) *grpc.ClientConn {
+	// load balance
+	return r.rpcClients[s.UID() % len(s.rpcClients)]
+}
+
+// Your handler, accessed by:
+// nanoClient.Request("RemoteComponent.DemoHandler", &pb.DemoMsg{/*...*/})
+func (r *RemoteComponent) DemoHandler(s *session.Session, msg *pb.DemoMsg) error {
+	client := r.client(s)
+	// do something with client
+	// ....
+	// ...
+	return nil
+}
+```
+
+The Nano will remain simple, but you can perform any operations in the component and get the desired goals. You can startup a group of `Nano` application as agent to dispatch message to backend servers.
+
+#### How to execute the asynchronous task
+
+```go
+func (manager *PlayerManager) Login(s *session.Session, msg *ReqPlayerLogin) error {
+    var onDBResult = func(player *Player) {
+        manager.players = append(manager.players, player)
+        s.Push("PlayerSystem.LoginSuccess", &ResPlayerLogin)
+    }
+    
+    // run slow task in new gorontine
+    go func() {
+        player, err := db.QueryPlayer(msg.PlayerId) // ignore error in demo
+        // handle result in main logical gorontine
+        nano.Invoke(func(){ onDBResult(player) })
+    }
+    return nil
+}
+```
+
+## Documents
+
+- English
+    + [How to build your first nano application](./docs/get_started.md)
+    + [Route compression](./docs/route_compression.md)
+    + [Communication protocol](./docs/communication_protocol.md)
+    + [Design patterns](./docs/design_patterns.md)
+    + [API Reference(Server)](https://godoc.org/github.com/lonnng/nano)
+    + [How to integrate `Lua` into `Nano` component(incomplete)](.)
+
+- 简体中文
+    + [如何构建你的第一个nano应用](./docs/get_started_zh_CN.md)
+    + [路由压缩](./docs/route_compression_zh_CN.md)
+    + [通信协议](./docs/communication_protocol_zh_CN.md)
+    + [API参考(服务器)](https://godoc.org/github.com/lonnng/nano)
+    + [如何将`lua`脚本集成到`nano`组件中(未完成)](.)
+
+## Resources
+
+- Javascript
+  + [nano-websocket-client](https://github.com/lonnng/nano-websocket-client)
+  + [nano-egret-client](https://github.com/lonnng/nano-egret-client)
+
+- Demo
+  + [Implement a chat room in 100 lines with nano and WebSocket](./examples/demo/chat)
+  + [Tadpole demo](./examples/demo/tadpole)
+  + [四川麻将, 血战到底(三人模式/四人模式)完整项目实例](https://github.com/lonnng/nanoserver)
+
+## Community
+
+- QQGroup: [289680347](https://jq.qq.com/?_wv=1027&k=4EMMaha)
+- Reddit: [nanolabs](https://www.reddit.com/r/nanolabs/)
+
+## Successful cases
+
+- [空来血战](https://fir.im/tios)
+
+## Go version
+
+`> go1.8`
+
+## Installation
+
+```shell
+go get github.com/lonng/nano
+
+# dependencies
+go get -u github.com/golang/protobuf
+go get -u github.com/gorilla/websocket
+```
+
+## Benchmark
+
+```shell
+# Case:   PingPong
+# OS:     Windows 10
+# Device: i5-6500 3.2GHz 4 Core/1000-Concurrent   => IOPS 11W(Average)
+# Other:  ...
+
+cd $GOPATH/src/github.com/lonng/nano/benchmark/io
+go test -v -tags "benchmark"
+```
+
+## License
+
+[MIT License](./LICENSE)
diff --git a/app.go b/app.go
index c61c29f5..d757278e 100644
--- a/app.go
+++ b/app.go
@@ -22,139 +22,64 @@ package nano
 
 import (
 	"fmt"
-	"net"
-	"net/http"
 	"os"
 	"os/signal"
+	"sync/atomic"
 	"syscall"
 
-	"github.com/gorilla/websocket"
-	"strings"
-	"time"
-	"sync/atomic"
+	"github.com/lonng/nano/cluster"
+	"github.com/lonng/nano/component"
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
+	"github.com/lonng/nano/scheduler"
 )
 
 var running int32
 
-func listen(addr string, isWs bool, opts ...Option) {
-	listenTLS(addr, isWs, "", "", opts...);
-}
-
-func listenTLS(addr string, isWs bool, certificate string, key string, opts ...Option) {
-	// mark application running
+func run(addr string, isWs bool, certificate string, key string, opts ...Option) {
 	if atomic.AddInt32(&running, 1) != 1 {
-		logger.Println("Nano has running")
+		log.Println("Nano has running")
 		return
 	}
 
-	for _, opt := range opts {
-		opt(handler.options)
+	opt := &options{
+		components: &component.Components{},
+	}
+	for _, option := range opts {
+		option(opt)
 	}
 
-	// cache heartbeat data
-	hbdEncode()
-
-	// initial all components
-	startupComponents()
-
-	// create global ticker instance, timer precision could be customized
-	// by SetTimerPrecision
-	globalTicker = time.NewTicker(timerPrecision)
-
-	// startup logic dispatcher
-	go handler.dispatch()
-
-	go func() {
-		if isWs {
-			if len(certificate) != 0 {
-				listenAndServeWSTLS(addr, certificate, key)
-			} else {
-				listenAndServeWS(addr)
-			}
-		} else {
-			listenAndServe(addr)
-		}
-	}()
+	node := &cluster.Node{
+		IsMaster:       opt.isMaster,
+		AdvertiseAddr:  opt.advertiseAddr,
+		MemberAddr:     opt.memberAddr,
+		ServerAddr:     addr,
+		Components:     opt.components,
+		IsWebsocket:    isWs,
+		TSLCertificate: certificate,
+		TSLKey:         key,
+		Pipeline:       opt.pipeline,
+	}
+	err := node.Startup()
+	if err != nil {
+		log.Fatalf("Node startup failed: %v", err)
+	}
 
-	logger.Println(fmt.Sprintf("starting application %s, listen at %s", app.name, addr))
+	log.Println(fmt.Sprintf("Nano server %s started, listen at %s", app.name, addr))
+	scheduler.Sched()
 	sg := make(chan os.Signal)
 	signal.Notify(sg, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGKILL, syscall.SIGTERM)
 
-	// stop server
 	select {
-	case <-env.die:
-		logger.Println("The app will shutdown in a few seconds")
+	case <-env.Die:
+		log.Println("The app will shutdown in a few seconds")
 	case s := <-sg:
-		logger.Println("got signal", s)
+		log.Println("Nano server got signal", s)
 	}
 
-	logger.Println("server is stopping...")
+	log.Println("Nano server is stopping...")
 
-	// shutdown all components registered by application, that
-	// call by reverse order against register
-	shutdownComponents()
+	node.Shutdown()
+	scheduler.Close()
 	atomic.StoreInt32(&running, 0)
 }
-
-// Enable current server accept connection
-func listenAndServe(addr string) {
-	listener, err := net.Listen("tcp", addr)
-	if err != nil {
-		logger.Fatal(err.Error())
-	}
-
-	defer listener.Close()
-	for {
-		conn, err := listener.Accept()
-		if err != nil {
-			logger.Println(err.Error())
-			continue
-		}
-
-		go handler.handle(conn)
-	}
-}
-
-func listenAndServeWS(addr string) {
-	var upgrader = websocket.Upgrader{
-		ReadBufferSize:  1024,
-		WriteBufferSize: 1024,
-		CheckOrigin:     env.checkOrigin,
-	}
-
-	http.HandleFunc("/"+strings.TrimPrefix(env.wsPath, "/"), func(w http.ResponseWriter, r *http.Request) {
-		conn, err := upgrader.Upgrade(w, r, nil)
-		if err != nil {
-			logger.Println(fmt.Sprintf("Upgrade failure, URI=%s, Error=%s", r.RequestURI, err.Error()))
-			return
-		}
-
-		handler.handleWS(conn)
-	})
-
-	if err := http.ListenAndServe(addr, nil); err != nil {
-		logger.Fatal(err.Error())
-	}
-}
-
-func listenAndServeWSTLS(addr string, certificate string, key string) {
-	var upgrader = websocket.Upgrader{
-		ReadBufferSize:  1024,
-		WriteBufferSize: 1024,
-		CheckOrigin:     env.checkOrigin,
-	}
-
-	http.HandleFunc("/"+strings.TrimPrefix(env.wsPath, "/"), func(w http.ResponseWriter, r *http.Request) {
-		conn, err := upgrader.Upgrade(w, r, nil)
-		if err != nil {
-			logger.Println(fmt.Sprintf("Upgrade failure, URI=%s, Error=%s", r.RequestURI, err.Error()))
-			return
-		}
-
-		handler.handleWS(conn)
-	})
-
-	if err := http.ListenAndServeTLS(addr, certificate, key, nil); err != nil {
-		logger.Fatal(err.Error())
-	}
-}
diff --git a/agent.go b/cluster/agent.go
similarity index 72%
rename from agent.go
rename to cluster/agent.go
index 9c2f92ec..0e81de4d 100644
--- a/agent.go
+++ b/cluster/agent.go
@@ -18,7 +18,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-package nano
+package cluster
 
 import (
 	"errors"
@@ -29,8 +29,12 @@ import (
 	"time"
 
 	"github.com/lonng/nano/internal/codec"
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
 	"github.com/lonng/nano/internal/message"
 	"github.com/lonng/nano/internal/packet"
+	"github.com/lonng/nano/pipeline"
+	"github.com/lonng/nano/scheduler"
 	"github.com/lonng/nano/session"
 )
 
@@ -50,15 +54,15 @@ type (
 	// Agent corresponding a user, used for store raw conn information
 	agent struct {
 		// regular agent member
-		session *session.Session    // session
-		conn    net.Conn            // low-level conn fd
-		lastMid uint                // last message id
-		state   int32               // current agent state
-		chDie   chan struct{}       // wait for close
-		chSend  chan pendingMessage // push message queue
-		lastAt  int64               // last heartbeat unix time stamp
-		decoder *codec.Decoder      // binary decoder
-		options *options
+		session  *session.Session    // session
+		conn     net.Conn            // low-level conn fd
+		lastMid  uint                // last message id
+		state    int32               // current agent state
+		chDie    chan struct{}       // wait for close
+		chSend   chan pendingMessage // push message queue
+		lastAt   int64               // last heartbeat unix time stamp
+		decoder  *codec.Decoder      // binary decoder
+		pipeline pipeline.Pipeline
 
 		srv reflect.Value // cached session reflect.Value
 	}
@@ -72,15 +76,15 @@ type (
 )
 
 // Create new agent instance
-func newAgent(conn net.Conn, options *options) *agent {
+func newAgent(conn net.Conn, pipeline pipeline.Pipeline) *agent {
 	a := &agent{
-		conn:    conn,
-		state:   statusStart,
-		chDie:   make(chan struct{}),
-		lastAt:  time.Now().Unix(),
-		chSend:  make(chan pendingMessage, agentWriteBacklog),
-		decoder: codec.NewDecoder(),
-		options: options,
+		conn:     conn,
+		state:    statusStart,
+		chDie:    make(chan struct{}),
+		lastAt:   time.Now().Unix(),
+		chSend:   make(chan pendingMessage, agentWriteBacklog),
+		decoder:  codec.NewDecoder(),
+		pipeline: pipeline,
 	}
 
 	// binding session
@@ -115,13 +119,13 @@ func (a *agent) Push(route string, v interface{}) error {
 		return ErrBufferExceed
 	}
 
-	if env.debug {
+	if env.Debug {
 		switch d := v.(type) {
 		case []byte:
-			logger.Println(fmt.Sprintf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%dbytes",
+			log.Println(fmt.Sprintf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%dbytes",
 				a.session.ID(), a.session.UID(), route, len(d)))
 		default:
-			logger.Println(fmt.Sprintf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%+v",
+			log.Println(fmt.Sprintf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%+v",
 				a.session.ID(), a.session.UID(), route, v))
 		}
 	}
@@ -150,13 +154,13 @@ func (a *agent) ResponseMID(mid uint, v interface{}) error {
 		return ErrBufferExceed
 	}
 
-	if env.debug {
+	if env.Debug {
 		switch d := v.(type) {
 		case []byte:
-			logger.Println(fmt.Sprintf("Type=Response, ID=%d, UID=%d, MID=%d, Data=%dbytes",
+			log.Println(fmt.Sprintf("Type=Response, ID=%d, UID=%d, MID=%d, Data=%dbytes",
 				a.session.ID(), a.session.UID(), mid, len(d)))
 		default:
-			logger.Println(fmt.Sprintf("Type=Response, ID=%d, UID=%d, MID=%d, Data=%+v",
+			log.Println(fmt.Sprintf("Type=Response, ID=%d, UID=%d, MID=%d, Data=%+v",
 				a.session.ID(), a.session.UID(), mid, v))
 		}
 	}
@@ -173,8 +177,8 @@ func (a *agent) Close() error {
 	}
 	a.setStatus(statusClosed)
 
-	if env.debug {
-		logger.Println(fmt.Sprintf("Session closed, ID=%d, UID=%d, IP=%s",
+	if env.Debug {
+		log.Println(fmt.Sprintf("Session closed, ID=%d, UID=%d, IP=%s",
 			a.session.ID(), a.session.UID(), a.conn.RemoteAddr()))
 	}
 
@@ -184,7 +188,7 @@ func (a *agent) Close() error {
 		// expect
 	default:
 		close(a.chDie)
-		handler.chCloseSession <- a.session
+		scheduler.PushTask(func() { session.Lifetime.Close(a.session) })
 	}
 
 	return a.conn.Close()
@@ -210,7 +214,7 @@ func (a *agent) setStatus(state int32) {
 }
 
 func (a *agent) write() {
-	ticker := time.NewTicker(env.heartbeat)
+	ticker := time.NewTicker(env.Heartbeat)
 	chWrite := make(chan []byte, agentWriteBacklog)
 	// clean func
 	defer func() {
@@ -218,8 +222,8 @@ func (a *agent) write() {
 		close(a.chSend)
 		close(chWrite)
 		a.Close()
-		if env.debug {
-			logger.Println(fmt.Sprintf("Session write goroutine exit, SessionID=%d, UID=%d", a.session.ID(), a.session.UID()))
+		if env.Debug {
+			log.Println(fmt.Sprintf("Session write goroutine exit, SessionID=%d, UID=%d", a.session.ID(), a.session.UID()))
 		}
 	}()
 
@@ -228,7 +232,7 @@ func (a *agent) write() {
 		case <-ticker.C:
 			deadline := time.Now().Add(-2 * env.heartbeat).Unix()
 			if atomic.LoadInt64(&a.lastAt) < deadline {
-				logger.Println(fmt.Sprintf("Session heartbeat timeout, LastTime=%d, Deadline=%d", atomic.LoadInt64(&a.lastAt), deadline))
+				log.Println(fmt.Sprintf("Session heartbeat timeout, LastTime=%d, Deadline=%d", atomic.LoadInt64(&a.lastAt), deadline))
 				return
 			}
 			chWrite <- hbd
@@ -236,18 +240,18 @@ func (a *agent) write() {
 		case data := <-chWrite:
 			// close agent while low-level conn broken
 			if _, err := a.conn.Write(data); err != nil {
-				logger.Println(err.Error())
+				log.Println(err.Error())
 				return
 			}
 
 		case data := <-a.chSend:
-			payload, err := serializeOrRaw(data.payload)
+			payload, err := message.Serialize(data.payload)
 			if err != nil {
 				switch data.typ {
 				case message.Push:
-					logger.Println(fmt.Sprintf("Push: %s error: %s", data.route, err.Error()))
+					log.Println(fmt.Sprintf("Push: %s error: %s", data.route, err.Error()))
 				case message.Response:
-					logger.Println(fmt.Sprintf("Response message(id: %d) error: %s", data.mid, err.Error()))
+					log.Println(fmt.Sprintf("Response message(id: %d) error: %s", data.mid, err.Error()))
 				default:
 					// expect
 				}
@@ -261,24 +265,24 @@ func (a *agent) write() {
 				Route: data.route,
 				ID:    data.mid,
 			}
-			if pipe := a.options.pipeline; pipe != nil {
-				err := pipe.Outbound().Process(a.session, Message{m})
+			if pipe := a.pipeline; pipe != nil {
+				err := pipe.Outbound().Process(a.session, m)
 				if err != nil {
-					logger.Println("broken pipeline", err.Error())
+					log.Println("broken pipeline", err.Error())
 					break
 				}
 			}
 
 			em, err := m.Encode()
 			if err != nil {
-				logger.Println(err.Error())
+				log.Println(err.Error())
 				break
 			}
 
 			// packet encode
 			p, err := codec.Encode(packet.Data, em)
 			if err != nil {
-				logger.Println(err)
+				log.Println(err)
 				break
 			}
 			chWrite <- p
@@ -286,7 +290,7 @@ func (a *agent) write() {
 		case <-a.chDie: // agent closed signal
 			return
 
-		case <-env.die: // application quit
+		case <-env.Die: // application quit
 			return
 		}
 	}
diff --git a/cluster/cluster.go b/cluster/cluster.go
index 6bb6e6b0..94c0e709 100644
--- a/cluster/cluster.go
+++ b/cluster/cluster.go
@@ -1,12 +1,46 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
 package cluster
 
-// Cluster represents a nano cluster, which contains a bunch of nano nodes
+import (
+	"context"
+
+	"github.com/lonng/nano/cluster/clusterpb"
+)
+
+// cluster represents a nano cluster, which contains a bunch of nano nodes
 // and each of them provide a group of different services. All services requests
 // from client will send to gate firstly and be forwarded to appropriate node.
-type Cluster struct {
+type cluster struct {
 	nodes []*Node
 }
 
-func (c *Cluster) Nodes() []*Node {
+func newCluster() *cluster {
+	return &cluster{}
+}
+
+func (c *cluster) Nodes() []*Node {
 	return c.nodes
 }
+
+func (c *cluster) RegisterNode(context.Context, *clusterpb.RegisterNodeRequest) (*clusterpb.RegisterNodeResponse, error) {
+	panic("implement me")
+}
diff --git a/cluster/connpool.go b/cluster/connpool.go
index a95c2684..67675842 100644
--- a/cluster/connpool.go
+++ b/cluster/connpool.go
@@ -1,3 +1,23 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
 package cluster
 
 import (
diff --git a/const.go b/cluster/const.go
similarity index 98%
rename from const.go
rename to cluster/const.go
index cb9dc8ff..3b265c0d 100644
--- a/const.go
+++ b/cluster/const.go
@@ -18,7 +18,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-package nano
+package cluster
 
 const (
 	_ int32 = iota
diff --git a/serialize.go b/cluster/errors.go
similarity index 75%
rename from serialize.go
rename to cluster/errors.go
index 0774c355..c4a4d65f 100644
--- a/serialize.go
+++ b/cluster/errors.go
@@ -18,18 +18,12 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-package nano
+package cluster
 
-import (
-	"github.com/lonng/nano/serialize"
-	"github.com/lonng/nano/serialize/protobuf"
-)
-
-// Default serializer
-var serializer serialize.Serializer = protobuf.NewSerializer()
+import "errors"
 
-// SetSerializer customize application serializer, which automatically Marshal
-// and UnMarshal handler payload
-func SetSerializer(seri serialize.Serializer) {
-	serializer = seri
-}
+// Errors that could be occurred during message handling.
+var (
+	ErrSessionOnNotify    = errors.New("current session working on notify mode")
+	ErrCloseClosedSession = errors.New("close closed session")
+)
diff --git a/cluster/handler.go b/cluster/handler.go
new file mode 100644
index 00000000..fb5f5170
--- /dev/null
+++ b/cluster/handler.go
@@ -0,0 +1,251 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package cluster
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"reflect"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/lonng/nano/component"
+	"github.com/lonng/nano/internal/codec"
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
+	"github.com/lonng/nano/internal/message"
+	"github.com/lonng/nano/internal/packet"
+	"github.com/lonng/nano/pipeline"
+	"github.com/lonng/nano/scheduler"
+)
+
+var (
+	// cached serialized data
+	hrd []byte // handshake response data
+	hbd []byte // heartbeat packet data
+)
+
+func cache() {
+	data, err := json.Marshal(map[string]interface{}{
+		"code": 200,
+		"sys":  map[string]float64{"heartbeat": env.Heartbeat.Seconds()},
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	hrd, err = codec.Encode(packet.Handshake, data)
+	if err != nil {
+		panic(err)
+	}
+
+	hbd, err = codec.Encode(packet.Heartbeat, nil)
+	if err != nil {
+		panic(err)
+	}
+}
+
+type (
+	handler struct {
+		services map[string]*component.Service // all registered service
+		handlers map[string]*component.Handler // all handler method
+		pipeline pipeline.Pipeline
+	}
+)
+
+func newHandler(pipeline pipeline.Pipeline) *handler {
+	h := &handler{
+		services: make(map[string]*component.Service),
+		handlers: make(map[string]*component.Handler),
+		pipeline: pipeline,
+	}
+
+	return h
+}
+
+func (h *handler) register(comp component.Component, opts []component.Option) error {
+	s := component.NewService(comp, opts)
+
+	if _, ok := h.services[s.Name]; ok {
+		return fmt.Errorf("handler: service already defined: %s", s.Name)
+	}
+
+	if err := s.ExtractHandler(); err != nil {
+		return err
+	}
+
+	// register all handlers
+	h.services[s.Name] = s
+	for name, handler := range s.Handlers {
+		h.handlers[fmt.Sprintf("%s.%s", s.Name, name)] = handler
+	}
+	return nil
+}
+
+func (h *handler) handle(conn net.Conn) {
+	// create a client agent and startup write gorontine
+	agent := newAgent(conn, h.pipeline)
+
+	// startup write goroutine
+	go agent.write()
+
+	if env.Debug {
+		log.Println(fmt.Sprintf("New session established: %s", agent.String()))
+	}
+
+	// guarantee agent related resource be destroyed
+	defer func() {
+		agent.Close()
+		if env.Debug {
+			log.Println(fmt.Sprintf("Session read goroutine exit, SessionID=%d, UID=%d", agent.session.ID(), agent.session.UID()))
+		}
+	}()
+
+	// read loop
+	buf := make([]byte, 2048)
+	for {
+		n, err := conn.Read(buf)
+		if err != nil {
+			log.Println(fmt.Sprintf("Read message error: %s, session will be closed immediately", err.Error()))
+			return
+		}
+
+		// TODO(warning): decoder use slice for performance, packet data should be copy before next Decode
+		packets, err := agent.decoder.Decode(buf[:n])
+		if err != nil {
+			log.Println(err.Error())
+			return
+		}
+
+		if len(packets) < 1 {
+			continue
+		}
+
+		// process all packet
+		for i := range packets {
+			if err := h.processPacket(agent, packets[i]); err != nil {
+				log.Println(err.Error())
+				return
+			}
+		}
+	}
+}
+
+func (h *handler) processPacket(agent *agent, p *packet.Packet) error {
+	switch p.Type {
+	case packet.Handshake:
+		if _, err := agent.conn.Write(hrd); err != nil {
+			return err
+		}
+
+		agent.setStatus(statusHandshake)
+		if env.Debug {
+			log.Println(fmt.Sprintf("Session handshake Id=%d, Remote=%s", agent.session.ID(), agent.conn.RemoteAddr()))
+		}
+
+	case packet.HandshakeAck:
+		agent.setStatus(statusWorking)
+		if env.Debug {
+			log.Println(fmt.Sprintf("Receive handshake ACK Id=%d, Remote=%s", agent.session.ID(), agent.conn.RemoteAddr()))
+		}
+
+	case packet.Data:
+		if agent.status() < statusWorking {
+			return fmt.Errorf("receive data on socket which not yet ACK, session will be closed immediately, remote=%s",
+				agent.conn.RemoteAddr().String())
+		}
+
+		msg, err := message.Decode(p.Data)
+		if err != nil {
+			return err
+		}
+		h.processMessage(agent, msg)
+
+	case packet.Heartbeat:
+		// expected
+	}
+
+	agent.lastAt = time.Now().Unix()
+	return nil
+}
+
+func (h *handler) processMessage(agent *agent, msg *message.Message) {
+	var lastMid uint
+	switch msg.Type {
+	case message.Request:
+		lastMid = msg.ID
+	case message.Notify:
+		lastMid = 0
+	}
+
+	handler, ok := h.handlers[msg.Route]
+	if !ok {
+		log.Println(fmt.Sprintf("nano/handler: %s not found(forgot registered?)", msg.Route))
+		return
+	}
+
+	if pipe := h.pipeline; pipe != nil {
+		err := pipe.Inbound().Process(agent.session, msg)
+		if err != nil {
+			log.Println("Pipeline process failed: " + err.Error())
+			return
+		}
+	}
+
+	var payload = msg.Data
+	var data interface{}
+	if handler.IsRawArg {
+		data = payload
+	} else {
+		data = reflect.New(handler.Type.Elem()).Interface()
+		err := env.Serializer.Unmarshal(payload, data)
+		if err != nil {
+			log.Println("Deserialize failed: " + err.Error())
+			return
+		}
+	}
+
+	if env.Debug {
+		log.Println(fmt.Sprintf("UID=%d, Message={%s}, Data=%+v", agent.session.UID(), msg.String(), data))
+	}
+
+	args := []reflect.Value{handler.Receiver, agent.srv, reflect.ValueOf(data)}
+	scheduler.PushTask(func() {
+		agent.lastMid = lastMid
+		result := handler.Method.Func.Call(args)
+		// TODO: send error message to client
+		if len(result) > 0 {
+			if err := result[0].Interface(); err != nil {
+				log.Println(err.(error).Error())
+			}
+		}
+	})
+}
+
+func (h *handler) handleWS(conn *websocket.Conn) {
+	c, err := newWSConn(conn)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	h.handle(c)
+}
diff --git a/cluster/member.go b/cluster/member.go
new file mode 100644
index 00000000..a07626e9
--- /dev/null
+++ b/cluster/member.go
@@ -0,0 +1,24 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package cluster
+
+type Member struct {
+}
diff --git a/cluster/node.go b/cluster/node.go
index bb1ea34e..105319c6 100644
--- a/cluster/node.go
+++ b/cluster/node.go
@@ -1,13 +1,198 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
 package cluster
 
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/websocket"
+	"github.com/lonng/nano/cluster/clusterpb"
+	"github.com/lonng/nano/component"
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
+	"github.com/lonng/nano/pipeline"
+	"google.golang.org/grpc"
+)
+
 // Node represents a node in nano cluster, which will contains a group of services.
 // All services will register to cluster and messages will be forwarded to the node
 // which provides respective service
 type Node struct {
-	isMaster bool
+	IsMaster       bool
+	AdvertiseAddr  string
+	MemberAddr     string
+	ServerAddr     string
+	Components     *component.Components
+	IsWebsocket    bool
+	TSLCertificate string
+	TSLKey         string
+	Pipeline       pipeline.Pipeline
+
+	cluster    *cluster
+	grpcServer *grpc.Server
+	handler    *handler
+}
+
+func (n *Node) Startup() error {
+	n.cluster = newCluster()
+	n.handler = newHandler(n.Pipeline)
+
+	components := n.Components.List()
+	for _, c := range components {
+		err := n.handler.register(c.Comp, c.Opts)
+		if err != nil {
+			return err
+		}
+	}
+
+	cache()
+
+	// Bootstrap cluster if either current is master or advertise address is not empty
+	// - Current node is master
+	// - Current node is cluster member
+	if n.IsMaster {
+		if n.AdvertiseAddr == "" {
+			return errors.New("advertise address cannot be empty in master node")
+		}
+		listener, err := net.Listen("tcp", n.AdvertiseAddr)
+		if err != nil {
+			return err
+		}
+		n.grpcServer = grpc.NewServer()
+		clusterpb.RegisterClusterServer(n.grpcServer, n.cluster)
+		go func() {
+			err := n.grpcServer.Serve(listener)
+			if err != nil {
+				log.Println("Start master node failed: " + err.Error())
+			}
+		}()
+	} else if n.AdvertiseAddr != "" {
+		// TODO: connect to master node
+	}
+
+	// Initialize all components
+	for _, c := range components {
+		c.Comp.Init()
+	}
+	for _, c := range components {
+		c.Comp.AfterInit()
+	}
+
+	go func() {
+		if n.IsWebsocket {
+			if len(n.TSLCertificate) != 0 {
+				n.listenAndServeWSTLS()
+			} else {
+				n.listenAndServeWS()
+			}
+		} else {
+			n.listenAndServe()
+		}
+	}()
+	return nil
 }
 
-// IsMaster returns a boolean to indicate whether the node is a master node
-func (n *Node) IsMaster() bool {
-	return n.isMaster
+// Shutdowns all components registered by application, that
+// call by reverse order against register
+func (n *Node) Shutdown() {
+	// reverse call `BeforeShutdown` hooks
+	components := n.Components.List()
+	length := len(components)
+	for i := length - 1; i >= 0; i-- {
+		components[i].Comp.BeforeShutdown()
+	}
+
+	// reverse call `Shutdown` hooks
+	for i := length - 1; i >= 0; i-- {
+		components[i].Comp.Shutdown()
+	}
+
+	if n.grpcServer != nil {
+		n.grpcServer.GracefulStop()
+	}
+}
+
+// Enable current server accept connection
+func (n *Node) listenAndServe() {
+	listener, err := net.Listen("tcp", n.ServerAddr)
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	defer listener.Close()
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			log.Println(err.Error())
+			continue
+		}
+
+		go n.handler.handle(conn)
+	}
+}
+
+func (n *Node) listenAndServeWS() {
+	var upgrader = websocket.Upgrader{
+		ReadBufferSize:  1024,
+		WriteBufferSize: 1024,
+		CheckOrigin:     env.CheckOrigin,
+	}
+
+	http.HandleFunc("/"+strings.TrimPrefix(env.WSPath, "/"), func(w http.ResponseWriter, r *http.Request) {
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			log.Println(fmt.Sprintf("Upgrade failure, URI=%s, Error=%s", r.RequestURI, err.Error()))
+			return
+		}
+
+		n.handler.handleWS(conn)
+	})
+
+	if err := http.ListenAndServe(n.ServerAddr, nil); err != nil {
+		log.Fatal(err.Error())
+	}
+}
+
+func (n *Node) listenAndServeWSTLS() {
+	var upgrader = websocket.Upgrader{
+		ReadBufferSize:  1024,
+		WriteBufferSize: 1024,
+		CheckOrigin:     env.CheckOrigin,
+	}
+
+	http.HandleFunc("/"+strings.TrimPrefix(env.WSPath, "/"), func(w http.ResponseWriter, r *http.Request) {
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			log.Println(fmt.Sprintf("Upgrade failure, URI=%s, Error=%s", r.RequestURI, err.Error()))
+			return
+		}
+
+		n.handler.handleWS(conn)
+	})
+
+	if err := http.ListenAndServeTLS(n.ServerAddr, n.TSLCertificate, n.TSLKey, nil); err != nil {
+		log.Fatal(err.Error())
+	}
 }
diff --git a/ws.go b/cluster/ws.go
similarity index 96%
rename from ws.go
rename to cluster/ws.go
index 3da6b7ac..4cba87ff 100644
--- a/ws.go
+++ b/cluster/ws.go
@@ -18,7 +18,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-package nano
+package cluster
 
 import (
 	"io"
@@ -135,12 +135,3 @@ func (c *wsConn) SetReadDeadline(t time.Time) error {
 func (c *wsConn) SetWriteDeadline(t time.Time) error {
 	return c.conn.SetWriteDeadline(t)
 }
-
-func (h *handlerService) handleWS(conn *websocket.Conn) {
-	c, err := newWSConn(conn)
-	if err != nil {
-		logger.Println(err)
-		return
-	}
-	h.handle(c)
-}
diff --git a/component.go b/component/hub.go
similarity index 58%
rename from component.go
rename to component/hub.go
index 6c5e7423..bec879d2 100644
--- a/component.go
+++ b/component/hub.go
@@ -18,51 +18,23 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-package nano
+package component
 
-import (
-	"github.com/lonng/nano/component"
-)
-
-var (
-	comps = make([]regComp, 0)
-)
-
-type regComp struct {
-	comp component.Component
-	opts []component.Option
+type CompWithOptions struct {
+	Comp Component
+	Opts []Option
 }
 
-func startupComponents() {
-	// component initialize hooks
-	for _, c := range comps {
-		c.comp.Init()
-	}
-
-	// component after initialize hooks
-	for _, c := range comps {
-		c.comp.AfterInit()
-	}
-
-	// register all components
-	for _, c := range comps {
-		if err := handler.register(c.comp, c.opts); err != nil {
-			logger.Println(err.Error())
-		}
-	}
-
-	handler.DumpServices()
+type Components struct {
+	comps []CompWithOptions
 }
 
-func shutdownComponents() {
-	// reverse call `BeforeShutdown` hooks
-	length := len(comps)
-	for i := length - 1; i >= 0; i-- {
-		comps[i].comp.BeforeShutdown()
-	}
+// Register registers a component to hub with options
+func (cs *Components) Register(c Component, options ...Option) {
+	cs.comps = append(cs.comps, CompWithOptions{c, options})
+}
 
-	// reverse call `Shutdown` hooks
-	for i := length - 1; i >= 0; i-- {
-		comps[i].comp.Shutdown()
-	}
+// List returns all components with it's options
+func (cs *Components) List() []CompWithOptions {
+	return cs.comps
 }
diff --git a/component/options.go b/component/options.go
index adc50579..a9c83528 100644
--- a/component/options.go
+++ b/component/options.go
@@ -1,3 +1,23 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
 package component
 
 type (
diff --git a/config.go b/config.go
index ef7ee612..b0b3f7bf 100644
--- a/config.go
+++ b/config.go
@@ -21,15 +21,16 @@
 package nano
 
 import (
-	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
 	"time"
+
+	"github.com/lonng/nano/internal/env"
 )
 
 // VERSION returns current nano version
-var VERSION = "0.0.1"
+var VERSION = "0.5.0"
 
 var (
 	// app represents the current server process
@@ -37,17 +38,6 @@ var (
 		name    string    // current application name
 		startAt time.Time // startup time
 	}{}
-
-	// env represents the environment of the current process, includes
-	// work path and config path etc.
-	env = &struct {
-		wd          string                   // working path
-		die         chan bool                // wait for end application
-		heartbeat   time.Duration            // heartbeat internal
-		checkOrigin func(*http.Request) bool // check origin when websocket enabled
-		debug       bool                     // enable debug
-		wsPath      string                   // WebSocket path(eg: ws://127.0.0.1/wsPath)
-	}{}
 )
 
 // init default configs
@@ -60,11 +50,6 @@ func init() {
 	if wd, err := os.Getwd(); err != nil {
 		panic(err)
 	} else {
-		env.wd, _ = filepath.Abs(wd)
+		env.Wd, _ = filepath.Abs(wd)
 	}
-
-	env.die = make(chan bool)
-	env.heartbeat = 30 * time.Second
-	env.debug = false
-	env.checkOrigin = func(_ *http.Request) bool { return true }
 }
diff --git a/errors.go b/errors.go
index b59ad33c..826c003e 100644
--- a/errors.go
+++ b/errors.go
@@ -24,10 +24,8 @@ import "errors"
 
 // Errors that could be occurred during message handling.
 var (
-	ErrSessionOnNotify    = errors.New("current session working on notify mode")
 	ErrCloseClosedGroup   = errors.New("close closed group")
 	ErrClosedGroup        = errors.New("group closed")
 	ErrMemberNotFound     = errors.New("member not found in the group")
-	ErrCloseClosedSession = errors.New("close closed session")
 	ErrSessionDuplication = errors.New("session has existed in the current group")
 )
diff --git a/examples/demo/chat/main.go b/examples/demo/chat/main.go
index 3e2de54c..0fc3f2f1 100644
--- a/examples/demo/chat/main.go
+++ b/examples/demo/chat/main.go
@@ -4,13 +4,15 @@ import (
 	"fmt"
 	"log"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/lonng/nano"
 	"github.com/lonng/nano/component"
+	"github.com/lonng/nano/pipeline"
+	"github.com/lonng/nano/scheduler"
 	"github.com/lonng/nano/serialize/json"
 	"github.com/lonng/nano/session"
-	"strings"
 )
 
 type (
@@ -21,7 +23,7 @@ type (
 	// RoomManager represents a component that contains a bundle of room
 	RoomManager struct {
 		component.Base
-		timer *nano.Timer
+		timer *scheduler.Timer
 		rooms map[int]*Room
 	}
 
@@ -49,24 +51,24 @@ type (
 
 	stats struct {
 		component.Base
-		timer         *nano.Timer
+		timer         *scheduler.Timer
 		outboundBytes int
 		inboundBytes  int
 	}
 )
 
-func (stats *stats) outbound(s *session.Session, msg nano.Message) error {
+func (stats *stats) outbound(s *session.Session, msg pipeline.Message) error {
 	stats.outboundBytes += len(msg.Data)
 	return nil
 }
 
-func (stats *stats) inbound(s *session.Session, msg nano.Message) error {
+func (stats *stats) inbound(s *session.Session, msg pipeline.Message) error {
 	stats.inboundBytes += len(msg.Data)
 	return nil
 }
 
 func (stats *stats) AfterInit() {
-	stats.timer = nano.NewTimer(time.Minute, func() {
+	stats.timer = scheduler.NewTimer(time.Minute, func() {
 		println("OutboundBytes", stats.outboundBytes)
 		println("InboundBytes", stats.outboundBytes)
 	})
@@ -92,7 +94,7 @@ func (mgr *RoomManager) AfterInit() {
 		room := s.Value(roomIDKey).(*Room)
 		room.group.Leave(s)
 	})
-	mgr.timer = nano.NewTimer(time.Minute, func() {
+	mgr.timer = scheduler.NewTimer(time.Minute, func() {
 		for roomId, room := range mgr.rooms {
 			println(fmt.Sprintf("UserCount: RoomID=%d, Time=%s, Count=%d",
 				roomId, time.Now().String(), room.group.Count()))
@@ -143,7 +145,7 @@ func main() {
 	)
 
 	// traffic stats
-	pipeline := nano.NewPipeline()
+	pipeline := pipeline.New()
 	var stats = &stats{}
 	pipeline.Outbound().PushBack(stats.outbound)
 	pipeline.Inbound().PushBack(stats.inbound)
diff --git a/go.mod b/go.mod
index 147a0582..5e4c1a89 100644
--- a/go.mod
+++ b/go.mod
@@ -18,7 +18,7 @@ require (
 	golang.org/x/image v0.0.0-20190507092727-e4e5bf290fec // indirect
 	golang.org/x/lint v0.0.0-20190409202823-959b441ac422 // indirect
 	golang.org/x/mobile v0.0.0-20190509164839-32b2708ab171 // indirect
-	golang.org/x/net v0.0.0-20190509222800-a4d6f7feada5 // indirect
+	golang.org/x/net v0.0.0-20190509222800-a4d6f7feada5
 	golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a // indirect
 	golang.org/x/sys v0.0.0-20190509141414-a5b02f93d862 // indirect
 	golang.org/x/text v0.3.2 // indirect
@@ -26,6 +26,6 @@ require (
 	golang.org/x/tools v0.0.0-20190511041617-99f201b6807e // indirect
 	google.golang.org/api v0.5.0 // indirect
 	google.golang.org/genproto v0.0.0-20190508193815-b515fa19cec8 // indirect
-	google.golang.org/grpc v1.20.1 // indirect
+	google.golang.org/grpc v1.20.1
 	honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a // indirect
 )
diff --git a/group.go b/group.go
index 1ffacae3..0377a3a1 100644
--- a/group.go
+++ b/group.go
@@ -25,6 +25,9 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
+	"github.com/lonng/nano/internal/message"
 	"github.com/lonng/nano/session"
 )
 
@@ -74,7 +77,7 @@ func (c *Group) Members() []int64 {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 
-	members := []int64{}
+	var members []int64
 	for _, s := range c.sessions {
 		members = append(members, s.UID())
 	}
@@ -88,13 +91,13 @@ func (c *Group) Multicast(route string, v interface{}, filter SessionFilter) err
 		return ErrClosedGroup
 	}
 
-	data, err := serializeOrRaw(v)
+	data, err := message.Serialize(v)
 	if err != nil {
 		return err
 	}
 
-	if env.debug {
-		logger.Println(fmt.Sprintf("Type=Multicast Route=%s, Data=%+v", route, v))
+	if env.Debug {
+		log.Println(fmt.Sprintf("Multicast %s, Data=%+v", route, v))
 	}
 
 	c.mu.RLock()
@@ -105,7 +108,7 @@ func (c *Group) Multicast(route string, v interface{}, filter SessionFilter) err
 			continue
 		}
 		if err = s.Push(route, data); err != nil {
-			logger.Println(err.Error())
+			log.Println(err.Error())
 		}
 	}
 
@@ -118,13 +121,13 @@ func (c *Group) Broadcast(route string, v interface{}) error {
 		return ErrClosedGroup
 	}
 
-	data, err := serializeOrRaw(v)
+	data, err := message.Serialize(v)
 	if err != nil {
 		return err
 	}
 
-	if env.debug {
-		logger.Println(fmt.Sprintf("Type=Broadcast Route=%s, Data=%+v", route, v))
+	if env.Debug {
+		log.Println(fmt.Sprintf("Broadcast %s, Data=%+v", route, v))
 	}
 
 	c.mu.RLock()
@@ -132,7 +135,7 @@ func (c *Group) Broadcast(route string, v interface{}) error {
 
 	for _, s := range c.sessions {
 		if err = s.Push(route, data); err != nil {
-			logger.Println(fmt.Sprintf("Session push message error, ID=%d, UID=%d, Error=%s", s.ID(), s.UID(), err.Error()))
+			log.Println(fmt.Sprintf("Session push message error, ID=%d, UID=%d, Error=%s", s.ID(), s.UID(), err.Error()))
 		}
 	}
 
@@ -151,8 +154,8 @@ func (c *Group) Add(session *session.Session) error {
 		return ErrClosedGroup
 	}
 
-	if env.debug {
-		logger.Println(fmt.Sprintf("Add session to group %s, ID=%d, UID=%d", c.name, session.ID(), session.UID()))
+	if env.Debug {
+		log.Println(fmt.Sprintf("Add session to group %s, ID=%d, UID=%d", c.name, session.ID(), session.UID()))
 	}
 
 	c.mu.Lock()
@@ -174,8 +177,8 @@ func (c *Group) Leave(s *session.Session) error {
 		return ErrClosedGroup
 	}
 
-	if env.debug {
-		logger.Println(fmt.Sprintf("Remove session from group %s, UID=%d", c.name, s.UID()))
+	if env.Debug {
+		log.Println(fmt.Sprintf("Remove session from group %s, UID=%d", c.name, s.UID()))
 	}
 
 	c.mu.Lock()
@@ -224,4 +227,4 @@ func (c *Group) Close() error {
 	// release all reference
 	c.sessions = make(map[int64]*session.Session)
 	return nil
-}
\ No newline at end of file
+}
diff --git a/handler.go b/handler.go
deleted file mode 100644
index f9261031..00000000
--- a/handler.go
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright (c) nano Author. All Rights Reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package nano
-
-import (
-	"encoding/json"
-	"fmt"
-	"net"
-	"reflect"
-	"sync/atomic"
-	"time"
-
-	"github.com/lonng/nano/component"
-	"github.com/lonng/nano/internal/codec"
-	"github.com/lonng/nano/internal/message"
-	"github.com/lonng/nano/internal/packet"
-	"github.com/lonng/nano/session"
-)
-
-// Unhandled message buffer size
-const packetBacklog = 1024
-const funcBacklog = 1 << 8
-
-var (
-	// handler service singleton
-	handler = newHandlerService()
-
-	// serialized data
-	hrd []byte // handshake response data
-	hbd []byte // heartbeat packet data
-)
-
-func hbdEncode() {
-	data, err := json.Marshal(map[string]interface{}{
-		"code": 200,
-		"sys":  map[string]float64{"heartbeat": env.heartbeat.Seconds()},
-	})
-	if err != nil {
-		panic(err)
-	}
-
-	hrd, err = codec.Encode(packet.Handshake, data)
-	if err != nil {
-		panic(err)
-	}
-
-	hbd, err = codec.Encode(packet.Heartbeat, nil)
-	if err != nil {
-		panic(err)
-	}
-}
-
-type (
-	handlerService struct {
-		services       map[string]*component.Service // all registered service
-		handlers       map[string]*component.Handler // all handler method
-		chLocalProcess chan unhandledMessage         // packets that process locally
-		chCloseSession chan *session.Session         // closed session
-		chFunction     chan func()                   // function that called in logic gorontine
-		options        *options
-	}
-
-	unhandledMessage struct {
-		agent   *agent
-		lastMid uint
-		handler reflect.Method
-		args    []reflect.Value
-	}
-)
-
-func newHandlerService() *handlerService {
-	h := &handlerService{
-		services:       make(map[string]*component.Service),
-		handlers:       make(map[string]*component.Handler),
-		chLocalProcess: make(chan unhandledMessage, packetBacklog),
-		chCloseSession: make(chan *session.Session, packetBacklog),
-		chFunction:     make(chan func(), funcBacklog),
-		options:        &options{},
-	}
-
-	return h
-}
-
-// call handler with protected
-func pcall(method reflect.Method, args []reflect.Value) {
-	defer func() {
-		if err := recover(); err != nil {
-			logger.Println(fmt.Sprintf("nano/dispatch: %v", err))
-			println(stack())
-		}
-	}()
-
-	if r := method.Func.Call(args); len(r) > 0 {
-		if err := r[0].Interface(); err != nil {
-			logger.Println(err.(error).Error())
-		}
-	}
-}
-
-// call handler with protected
-func pinvoke(fn func()) {
-	defer func() {
-		if err := recover(); err != nil {
-			logger.Println(fmt.Sprintf("nano/invoke: %v", err))
-			println(stack())
-		}
-	}()
-
-	fn()
-}
-
-func onSessionClosed(s *session.Session) {
-	defer func() {
-		if err := recover(); err != nil {
-			logger.Println(fmt.Sprintf("nano/onSessionClosed: %v", err))
-			println(stack())
-		}
-	}()
-
-	session.Lifetime.Close(s)
-}
-
-// dispatch message to corresponding logic handler
-func (h *handlerService) dispatch() {
-	// close chLocalProcess & chCloseSession when application quit
-	defer func() {
-		if err := recover(); err != nil {
-			logger.Println(fmt.Sprintf("Dispatcher exit unexpected: %v", err))
-			println(stack())
-		}
-		close(h.chLocalProcess)
-		close(h.chCloseSession)
-		globalTicker.Stop()
-		logger.Println("Main logic loop exit")
-	}()
-
-	// handle packet that sent to chLocalProcess
-	for {
-		select {
-		case m := <-h.chLocalProcess: // logic dispatch
-			m.agent.lastMid = m.lastMid
-			pcall(m.handler, m.args)
-
-		case s := <-h.chCloseSession: // session closed callback
-			onSessionClosed(s)
-
-		case fn := <-h.chFunction:
-			pinvoke(fn)
-
-		case <-globalTicker.C: // execute cron task
-			cron()
-
-		case <-env.die: // application quit signal
-			logger.Println("Got exit instruction, break logic loop")
-			return
-		}
-	}
-}
-
-func (h *handlerService) register(comp component.Component, opts []component.Option) error {
-	s := component.NewService(comp, opts)
-
-	if _, ok := h.services[s.Name]; ok {
-		return fmt.Errorf("handler: service already defined: %s", s.Name)
-	}
-
-	if err := s.ExtractHandler(); err != nil {
-		return err
-	}
-
-	// register all handlers
-	h.services[s.Name] = s
-	for name, handler := range s.Handlers {
-		h.handlers[fmt.Sprintf("%s.%s", s.Name, name)] = handler
-	}
-	return nil
-}
-
-func (h *handlerService) handle(conn net.Conn) {
-	// create a client agent and startup write gorontine
-	agent := newAgent(conn, h.options)
-
-	// startup write goroutine
-	go agent.write()
-
-	if env.debug {
-		logger.Println(fmt.Sprintf("New session established: %s", agent.String()))
-	}
-
-	// guarantee agent related resource be destroyed
-	defer func() {
-		agent.Close()
-		if env.debug {
-			logger.Println(fmt.Sprintf("Session read goroutine exit, SessionID=%d, UID=%d", agent.session.ID(), agent.session.UID()))
-		}
-	}()
-
-	// read loop
-	buf := make([]byte, 2048)
-	for {
-		n, err := conn.Read(buf)
-		if err != nil {
-			logger.Println(fmt.Sprintf("Read message error: %s, session will be closed immediately", err.Error()))
-			return
-		}
-
-		// TODO(warning): decoder use slice for performance, packet data should be copy before next Decode
-		packets, err := agent.decoder.Decode(buf[:n])
-		if err != nil {
-			logger.Println(err.Error())
-			return
-		}
-
-		if len(packets) < 1 {
-			continue
-		}
-
-		// process all packet
-		for i := range packets {
-			if err := h.processPacket(agent, packets[i]); err != nil {
-				logger.Println(err.Error())
-				return
-			}
-		}
-	}
-}
-
-func (h *handlerService) processPacket(agent *agent, p *packet.Packet) error {
-	switch p.Type {
-	case packet.Handshake:
-		if _, err := agent.conn.Write(hrd); err != nil {
-			return err
-		}
-
-		agent.setStatus(statusHandshake)
-		if env.debug {
-			logger.Println(fmt.Sprintf("Session handshake Id=%d, Remote=%s", agent.session.ID(), agent.conn.RemoteAddr()))
-		}
-
-	case packet.HandshakeAck:
-		agent.setStatus(statusWorking)
-		if env.debug {
-			logger.Println(fmt.Sprintf("Receive handshake ACK Id=%d, Remote=%s", agent.session.ID(), agent.conn.RemoteAddr()))
-		}
-
-	case packet.Data:
-		if agent.status() < statusWorking {
-			return fmt.Errorf("receive data on socket which not yet ACK, session will be closed immediately, remote=%s",
-				agent.conn.RemoteAddr().String())
-		}
-
-		msg, err := message.Decode(p.Data)
-		if err != nil {
-			return err
-		}
-		h.processMessage(agent, msg)
-
-	case packet.Heartbeat:
-		// expected
-	}
-
-	atomic.StoreInt64(&agent.lastAt, time.Now().Unix())
-	return nil
-}
-
-func (h *handlerService) processMessage(agent *agent, msg *message.Message) {
-	var lastMid uint
-	switch msg.Type {
-	case message.Request:
-		lastMid = msg.ID
-	case message.Notify:
-		lastMid = 0
-	}
-
-	handler, ok := h.handlers[msg.Route]
-	if !ok {
-		logger.Println(fmt.Sprintf("nano/handler: %s not found(forgot registered?)", msg.Route))
-		return
-	}
-
-	if pipe := h.options.pipeline; pipe != nil {
-		err := pipe.Inbound().Process(agent.session, Message{msg})
-		if err != nil {
-			logger.Println("broken pipeline", err.Error())
-			return
-		}
-	}
-
-	var payload = msg.Data
-	var data interface{}
-	if handler.IsRawArg {
-		data = payload
-	} else {
-		data = reflect.New(handler.Type.Elem()).Interface()
-		err := serializer.Unmarshal(payload, data)
-		if err != nil {
-			logger.Println("deserialize error", err.Error())
-			return
-		}
-	}
-
-	if env.debug {
-		logger.Println(fmt.Sprintf("UID=%d, Message={%s}, Data=%+v", agent.session.UID(), msg.String(), data))
-	}
-
-	args := []reflect.Value{handler.Receiver, agent.srv, reflect.ValueOf(data)}
-	h.chLocalProcess <- unhandledMessage{agent, lastMid, handler.Method, args}
-}
-
-// DumpServices outputs all registered services
-func (h *handlerService) DumpServices() {
-	for name := range h.handlers {
-		logger.Println("registered service", name)
-	}
-}
diff --git a/handler_test.go b/handler_test.go
deleted file mode 100644
index a4686bd8..00000000
--- a/handler_test.go
+++ /dev/null
@@ -1,219 +0,0 @@
-package nano
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/lonng/nano/component"
-	"github.com/lonng/nano/internal/message"
-	"github.com/lonng/nano/serialize/json"
-	"github.com/lonng/nano/serialize/protobuf"
-	"github.com/lonng/nano/session"
-)
-
-func BenchmarkPointerReflectNewValue(b *testing.B) {
-	type T struct {
-		Code    int
-		Message string
-		Payload string
-	}
-
-	t := reflect.TypeOf(&T{})
-
-	for i := 0; i < b.N; i++ {
-		reflect.New(t.Elem())
-	}
-
-	b.ReportAllocs()
-}
-
-func BenchmarkPointerReflectNewInterface(b *testing.B) {
-	type T struct {
-		Code    int
-		Message string
-		Payload string
-	}
-
-	t := reflect.TypeOf(&T{})
-
-	for i := 0; i < b.N; i++ {
-		reflect.New(t.Elem()).Interface()
-	}
-
-	b.ReportAllocs()
-}
-func BenchmarkReflectNewValue(b *testing.B) {
-	type T struct {
-		Code    int
-		Message string
-		Payload string
-	}
-
-	t := reflect.TypeOf(T{})
-
-	for i := 0; i < b.N; i++ {
-		reflect.New(t)
-	}
-
-	b.ReportAllocs()
-}
-
-func BenchmarkReflectNewInterface(b *testing.B) {
-	type T struct {
-		Code    int
-		Message string
-		Payload string
-	}
-
-	t := reflect.TypeOf(T{})
-
-	for i := 0; i < b.N; i++ {
-		reflect.New(t).Interface()
-	}
-
-	b.ReportAllocs()
-}
-
-// Test types
-type (
-	TestComp struct {
-		component.Base
-	}
-
-	JSONMessage struct {
-		Code int    `json:"code"`
-		Data string `json:"data"`
-	}
-
-	ProtoMessage struct {
-		Data *string `protobuf:"bytes,1,name=data"`
-	}
-)
-
-func (m *ProtoMessage) Reset()         { *m = ProtoMessage{} }
-func (m *ProtoMessage) String() string { return proto.CompactTextString(m) }
-func (*ProtoMessage) ProtoMessage()    {}
-
-func (t *TestComp) HandleJSON(s *session.Session, m *JSONMessage) error {
-	return nil
-}
-
-func (t *TestComp) HandleProto(s *session.Session, m *ProtoMessage) error {
-	return nil
-}
-
-func (t *TestComp) RawData(s *session.Session, _ []byte) error {
-	return nil
-}
-
-func TestHandlerCallJSON(t *testing.T) {
-	SetSerializer(json.NewSerializer())
-	handler.register(&TestComp{}, nil)
-
-	m := JSONMessage{Code: 1, Data: "hello world"}
-	data, err := serializeOrRaw(m)
-	if err != nil {
-		t.Fail()
-	}
-
-	msg := message.New()
-	msg.Route = "TestComp.HandleJSON"
-	msg.Type = message.Request
-	msg.Data = data
-
-	agent := newAgent(nil, &options{})
-	handler.processMessage(agent, msg)
-}
-
-func TestHandlerCallProtobuf(t *testing.T) {
-	SetSerializer(protobuf.NewSerializer())
-	handler.register(&TestComp{}, nil)
-
-	m := &ProtoMessage{Data: proto.String("hello world")}
-	data, err := serializeOrRaw(m)
-	if err != nil {
-		t.Error(err)
-	}
-
-	msg := message.New()
-	msg.Route = "TestComp.HandleProto"
-	msg.Type = message.Request
-	msg.Data = data
-
-	agent := newAgent(nil, &options{})
-	handler.processMessage(agent, msg)
-}
-
-func BenchmarkHandlerCallJSON(b *testing.B) {
-	SetSerializer(json.NewSerializer())
-	handler.register(&TestComp{}, nil)
-
-	m := JSONMessage{Code: 1, Data: "hello world"}
-	data, err := serializeOrRaw(m)
-	if err != nil {
-		b.Fail()
-	}
-
-	msg := message.New()
-	msg.Route = "TestComp.HandleJSON"
-	msg.Type = message.Request
-	msg.Data = data
-
-	agent := newAgent(nil, &options{})
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		handler.processMessage(agent, msg)
-	}
-
-	b.ReportAllocs()
-}
-
-func BenchmarkHandlerCallProtobuf(b *testing.B) {
-	SetSerializer(protobuf.NewSerializer())
-	handler.register(&TestComp{}, nil)
-
-	m := &ProtoMessage{Data: proto.String("hello world")}
-	data, err := serializeOrRaw(m)
-	if err != nil {
-		b.Fail()
-	}
-
-	msg := message.New()
-	msg.Route = "TestComp.HandleProto"
-	msg.Type = message.Request
-	msg.Data = data
-
-	agent := newAgent(nil, &options{})
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		handler.processMessage(agent, msg)
-	}
-	b.ReportAllocs()
-}
-
-func BenchmarkHandlerCallRawData(b *testing.B) {
-	SetSerializer(protobuf.NewSerializer())
-	handler.register(&TestComp{}, nil)
-
-	m := &ProtoMessage{Data: proto.String("hello world")}
-	data, err := serializeOrRaw(m)
-	if err != nil {
-		b.Fail()
-	}
-
-	msg := message.New()
-	msg.Route = "TestComp.RawData"
-	msg.Type = message.Request
-	msg.Data = data
-
-	agent := newAgent(nil, &options{})
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		handler.processMessage(agent, msg)
-	}
-	b.ReportAllocs()
-}
diff --git a/interface.go b/interface.go
index 8703f7da..bcc86d3d 100644
--- a/interface.go
+++ b/interface.go
@@ -21,64 +21,37 @@
 package nano
 
 import (
-	"net/http"
-	"time"
-
-	"github.com/lonng/nano/component"
-	"github.com/lonng/nano/internal/message"
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
 )
 
 // Listen listens on the TCP network address addr
 // and then calls Serve with handler to handle requests
 // on incoming connections.
 func Listen(addr string, opts ...Option) {
-	listen(addr, false, opts...)
+	run(addr, false, "", "", opts...)
 }
 
 // ListenWS listens on the TCP network address addr
 // and then upgrades the HTTP server connection to the WebSocket protocol
 // to handle requests on incoming connections.
 func ListenWS(addr string, opts ...Option) {
-	listen(addr, true, opts...)
+	run(addr, true, "", "", opts...)
 }
 
 // ListenWS listens on the TCP network address addr
 // and then upgrades the HTTP server connection to the WebSocket protocol
 // to handle requests on incoming connections.
 func ListenWSTLS(addr string, certificate string, key string, opts ...Option) {
-	listenTLS(addr, true, certificate, key, opts...)
-}
-
-// Register register a component with options
-func Register(c component.Component, options ...component.Option) {
-	comps = append(comps, regComp{c, options})
-}
-
-// SetHeartbeatInterval set heartbeat time interval
-func SetHeartbeatInterval(d time.Duration) {
-	env.heartbeat = d
-}
-
-// SetCheckOriginFunc set the function that check `Origin` in http headers
-func SetCheckOriginFunc(fn func(*http.Request) bool) {
-	env.checkOrigin = fn
+	run(addr, true, certificate, key, opts...)
 }
 
 // Shutdown send a signal to let 'nano' shutdown itself.
 func Shutdown() {
-	close(env.die)
-}
-
-// EnableDebug let 'nano' to run under debug mode.
-func EnableDebug() {
-	env.debug = true
-}
-
-// SetDictionary set routes map, TODO(warning): set dictionary in runtime would be a dangerous operation!!!!!!
-func SetDictionary(dict map[string]uint16) {
-	message.SetDictionary(dict)
+	close(env.Die)
 }
 
-func SetWSPath(path string) {
-	env.wsPath = path
+// SetLogger rewrites the default logger
+func SetLogger(l log.Logger) {
+	log.SetLogger(l)
 }
diff --git a/internal/env/env.go b/internal/env/env.go
new file mode 100644
index 00000000..adeb0882
--- /dev/null
+++ b/internal/env/env.go
@@ -0,0 +1,57 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// env represents the environment of the current process, includes
+// work path and config path etc.
+package env
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/lonng/nano/serialize"
+	"github.com/lonng/nano/serialize/protobuf"
+)
+
+var (
+	Wd          string                   // working path
+	Die         chan bool                // wait for end application
+	Heartbeat   time.Duration            // Heartbeat internal
+	CheckOrigin func(*http.Request) bool // check origin when websocket enabled
+	Debug       bool                     // enable Debug
+	WSPath      string                   // WebSocket path(eg: ws://127.0.0.1/WSPath)
+
+	// timerPrecision indicates the precision of timer, default is time.Second
+	TimerPrecision = time.Second
+
+	// globalTicker represents global ticker that all cron job will be executed
+	// in globalTicker.
+	GlobalTicker *time.Ticker
+
+	Serializer serialize.Serializer
+)
+
+func init() {
+	Die = make(chan bool)
+	Heartbeat = 30 * time.Second
+	Debug = false
+	CheckOrigin = func(_ *http.Request) bool { return true }
+	Serializer = protobuf.NewSerializer()
+}
diff --git a/internal/log/logger.go b/internal/log/logger.go
new file mode 100644
index 00000000..b726577e
--- /dev/null
+++ b/internal/log/logger.go
@@ -0,0 +1,33 @@
+package log
+
+import (
+	"log"
+	"os"
+)
+
+// Logger represents  the log interface
+type Logger interface {
+	Println(v ...interface{})
+	Fatal(v ...interface{})
+	Fatalf(format string, v ...interface{})
+}
+
+func init() {
+	SetLogger(log.New(os.Stderr, "", log.LstdFlags|log.Lshortfile))
+}
+
+var (
+	Println func(v ...interface{})
+	Fatal   func(v ...interface{})
+	Fatalf  func(format string, v ...interface{})
+)
+
+// SetLogger rewrites the default logger
+func SetLogger(logger Logger) {
+	if logger == nil {
+		return
+	}
+	Println = logger.Println
+	Fatal = logger.Fatal
+	Fatalf = logger.Fatalf
+}
diff --git a/internal/message/message.go b/internal/message/message.go
index 3568ecaf..72cb1a57 100644
--- a/internal/message/message.go
+++ b/internal/message/message.go
@@ -24,8 +24,9 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"log"
 	"strings"
+
+	"github.com/lonng/nano/internal/log"
 )
 
 // Type represents the type of message, which could be Request/Notify/Response/Push
@@ -221,11 +222,11 @@ func SetDictionary(dict map[string]uint16) {
 
 		// duplication check
 		if _, ok := routes[r]; ok {
-			log.Printf("duplicated route(route: %s, code: %d)\n", r, code)
+			log.Println(fmt.Sprintf("duplicated route(route: %s, code: %d)", r, code))
 		}
 
 		if _, ok := codes[code]; ok {
-			log.Printf("duplicated route(route: %s, code: %d)\n", r, code)
+			log.Println(fmt.Sprintf("duplicated route(route: %s, code: %d)", r, code))
 		}
 
 		// update map, using last value when key duplicated
diff --git a/utils.go b/internal/message/util.go
similarity index 57%
rename from utils.go
rename to internal/message/util.go
index 403bd045..c7a59b21 100644
--- a/utils.go
+++ b/internal/message/util.go
@@ -18,60 +18,17 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-package nano
+package message
 
-import (
-	"bytes"
-	"encoding/gob"
-	"os"
-	"runtime"
-	"strings"
-)
+import "github.com/lonng/nano/internal/env"
 
-func serializeOrRaw(v interface{}) ([]byte, error) {
+func Serialize(v interface{}) ([]byte, error) {
 	if data, ok := v.([]byte); ok {
 		return data, nil
 	}
-	data, err := serializer.Marshal(v)
+	data, err := env.Serializer.Marshal(v)
 	if err != nil {
 		return nil, err
 	}
 	return data, nil
 }
-
-func gobEncode(args ...interface{}) ([]byte, error) {
-	buf := bytes.NewBuffer([]byte(nil))
-	if err := gob.NewEncoder(buf).Encode(args); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-func gobDecode(reply interface{}, data []byte) error {
-	return gob.NewDecoder(bytes.NewReader(data)).Decode(reply)
-}
-
-func fileExists(filename string) bool {
-	_, err := os.Stat(filename)
-	return err == nil || os.IsExist(err)
-}
-
-func stack() string {
-	buf := make([]byte, 10000)
-	n := runtime.Stack(buf, false)
-	buf = buf[:n]
-
-	s := string(buf)
-
-	// skip nano frames lines
-	const skip = 7
-	count := 0
-	index := strings.IndexFunc(s, func(c rune) bool {
-		if c != '\n' {
-			return false
-		}
-		count++
-		return count == skip
-	})
-	return s[index+1:]
-}
diff --git a/invoke.go b/invoke.go
deleted file mode 100644
index be2a8ec7..00000000
--- a/invoke.go
+++ /dev/null
@@ -1,6 +0,0 @@
-package nano
-
-// Invoke invokes function in main logic goroutine
-func Invoke(fn func()) {
-	handler.chFunction <- fn
-}
diff --git a/logger.go b/logger.go
deleted file mode 100644
index 244c544a..00000000
--- a/logger.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package nano
-
-import (
-	"log"
-	"os"
-)
-
-//Logger represents  the log interface
-type Logger interface {
-	Println(v ...interface{})
-	Fatal(v ...interface{})
-}
-
-// Default logger
-var logger Logger = log.New(os.Stderr, "", log.LstdFlags|log.Llongfile)
-
-// SetLogger rewrites the default logger
-func SetLogger(l Logger) {
-	if l != nil {
-		logger = l
-	}
-}
diff --git a/application.png b/media/application.png
similarity index 100%
rename from application.png
rename to media/application.png
diff --git a/options.go b/options.go
index 8d448107..3d47dfb9 100644
--- a/options.go
+++ b/options.go
@@ -1,19 +1,31 @@
 package nano
 
-import "google.golang.org/grpc"
+import (
+	"net/http"
+	"time"
+
+	"github.com/lonng/nano/component"
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/message"
+	"github.com/lonng/nano/pipeline"
+	"github.com/lonng/nano/serialize"
+	"google.golang.org/grpc"
+)
 
 type (
 	options struct {
-		pipeline      Pipeline
+		pipeline      pipeline.Pipeline
 		advertiseAddr string
+		memberAddr    string
 		isMaster      bool
 		grpcOptions   []grpc.DialOption
+		components    *component.Components
 	}
 
 	Option func(*options)
 )
 
-func WithPipeline(pipeline Pipeline) Option {
+func WithPipeline(pipeline pipeline.Pipeline) Option {
 	return func(opt *options) {
 		opt.pipeline = pipeline
 	}
@@ -27,15 +39,86 @@ func WithAdvertiseAddr(addr string) Option {
 	}
 }
 
-// WithMaster sets the option whether current node is master node
+// WithMemberAddr sets the listen address which is used to establish connection between
+// cluster members. Will select an available port automatically if no member address
+// setting and panic if no available port
+func WithMemberAddr(addr string) Option {
+	return func(opt *options) {
+		opt.memberAddr = addr
+	}
+}
+
+// WithMaster sets the option to indicate whether the current node is master node
 func WithMaster() Option {
 	return func(opt *options) {
 		opt.isMaster = true
 	}
 }
 
+// WithGrpcOptions sets the grpc dial options
 func WithGrpcOptions(opts ...grpc.DialOption) Option {
 	return func(opt *options) {
 		opt.grpcOptions = opts
 	}
 }
+
+// WithComponents sets the components
+func WithComponents(components *component.Components) Option {
+	return func(opt *options) {
+		opt.components = components
+	}
+}
+
+// WithHeartbeatInterval sets Heartbeat time interval
+func WithHeartbeatInterval(d time.Duration) Option {
+	return func(_ *options) {
+		env.Heartbeat = d
+	}
+}
+
+// WithCheckOriginFunc sets the function that check `Origin` in http headers
+func WithCheckOriginFunc(fn func(*http.Request) bool) Option {
+	return func(opt *options) {
+		env.CheckOrigin = fn
+	}
+}
+
+// WithDebugMode let 'nano' to run under Debug mode.
+func WithDebugMode() Option {
+	return func(_ *options) {
+		env.Debug = true
+	}
+}
+
+// SetDictionary sets routes map
+func WithDictionary(dict map[string]uint16) Option {
+	return func(_ *options) {
+		message.SetDictionary(dict)
+	}
+}
+
+func WithWSPath(path string) Option {
+	return func(_ *options) {
+		env.WSPath = path
+	}
+}
+
+// SetTimerPrecision set the ticker precision, and time precision can not less
+// than a Millisecond, and can not change after application running. The default
+// precision is time.Second
+func WithTimerPrecision(precision time.Duration) Option {
+	if precision < time.Millisecond {
+		panic("time precision can not less than a Millisecond")
+	}
+	return func(_ *options) {
+		env.TimerPrecision = precision
+	}
+}
+
+// WithSerializer customizes application serializer, which automatically Marshal
+// and UnMarshal handler payload
+func WithSerializer(serializer serialize.Serializer) Option {
+	return func(opt *options) {
+		env.Serializer = serializer
+	}
+}
diff --git a/pipeline.go b/pipeline.go
deleted file mode 100644
index 687d188e..00000000
--- a/pipeline.go
+++ /dev/null
@@ -1,79 +0,0 @@
-package nano
-
-import (
-	"fmt"
-	"github.com/lonng/nano/internal/message"
-	"github.com/lonng/nano/session"
-	"sync/atomic"
-)
-
-type (
-	Message struct {
-		*message.Message
-	}
-
-	PipelineFunc func(s *session.Session, msg Message) error
-
-	Pipeline interface {
-		Outbound() PipelineChannel
-		Inbound() PipelineChannel
-	}
-
-	pipeline struct {
-		outbound, inbound *pipelineChannel
-	}
-
-	PipelineChannel interface {
-		PushFront(h PipelineFunc)
-		PushBack(h PipelineFunc)
-		Process(s *session.Session, msg Message) error
-	}
-
-	pipelineChannel struct {
-		handlers []PipelineFunc
-	}
-)
-
-func NewPipeline() Pipeline {
-	return &pipeline{
-		outbound: &pipelineChannel{},
-		inbound:  &pipelineChannel{},
-	}
-}
-
-func (p *pipeline) Outbound() PipelineChannel { return p.outbound }
-func (p *pipeline) Inbound() PipelineChannel  { return p.inbound }
-
-// PushFront should not be used after nano running
-func (p *pipelineChannel) PushFront(h PipelineFunc) {
-	if atomic.LoadInt32(&running) > 0 {
-		logger.Println("PushFront should not be used after Nano running")
-		return
-	}
-	handlers := make([]PipelineFunc, len(p.handlers)+1)
-	handlers[0] = h
-	copy(handlers[1:], p.handlers)
-	p.handlers = handlers
-}
-
-// PushBack should not be used after nano running
-func (p *pipelineChannel) PushBack(h PipelineFunc) {
-	if atomic.LoadInt32(&running) > 0 {
-		logger.Println("PushFront should not be used after Nano running")
-		return
-	}
-	p.handlers = append(p.handlers, h)
-}
-
-func (p *pipelineChannel) Process(s *session.Session, msg Message) error {
-	if len(p.handlers) < 1 {
-		return nil
-	}
-	for _, h := range p.handlers {
-		if err := h(s, msg); err != nil {
-			logger.Println(fmt.Sprintf("nano/handler: broken pipeline: %s", err.Error()))
-			return err
-		}
-	}
-	return nil
-}
diff --git a/pipeline/pipeline.go b/pipeline/pipeline.go
new file mode 100644
index 00000000..21b7503f
--- /dev/null
+++ b/pipeline/pipeline.go
@@ -0,0 +1,75 @@
+package pipeline
+
+import (
+	"sync"
+
+	"github.com/lonng/nano/internal/message"
+	"github.com/lonng/nano/session"
+)
+
+type (
+	Func func(s *session.Session, msg *message.Message) error
+
+	Pipeline interface {
+		Outbound() Channel
+		Inbound() Channel
+	}
+
+	pipeline struct {
+		outbound, inbound *pipelineChannel
+	}
+
+	Channel interface {
+		PushFront(h Func)
+		PushBack(h Func)
+		Process(s *session.Session, msg *message.Message) error
+	}
+
+	pipelineChannel struct {
+		mu       sync.RWMutex
+		handlers []Func
+	}
+)
+
+func New() Pipeline {
+	return &pipeline{
+		outbound: &pipelineChannel{},
+		inbound:  &pipelineChannel{},
+	}
+}
+
+func (p *pipeline) Outbound() Channel { return p.outbound }
+func (p *pipeline) Inbound() Channel  { return p.inbound }
+
+// PushFront push a function to the front of the pipeline
+func (p *pipelineChannel) PushFront(h Func) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	handlers := make([]Func, len(p.handlers)+1)
+	handlers[0] = h
+	copy(handlers[1:], p.handlers)
+	p.handlers = handlers
+}
+
+// PushFront push a function to the end of the pipeline
+func (p *pipelineChannel) PushBack(h Func) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.handlers = append(p.handlers, h)
+}
+
+// Process process message with all pipeline functions
+func (p *pipelineChannel) Process(s *session.Session, msg *message.Message) error {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	if len(p.handlers) < 1 {
+		return nil
+	}
+	for _, h := range p.handlers {
+		err := h(s, msg)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/scheduler/scheduler.go b/scheduler/scheduler.go
new file mode 100644
index 00000000..04555765
--- /dev/null
+++ b/scheduler/scheduler.go
@@ -0,0 +1,95 @@
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package scheduler
+
+import (
+	"fmt"
+	"runtime/debug"
+	"sync/atomic"
+	"time"
+
+	"github.com/lonng/nano/internal/env"
+	"github.com/lonng/nano/internal/log"
+)
+
+const (
+	messageQueueBacklog = 1 << 10
+	sessionCloseBacklog = 1 << 8
+)
+
+type Task func()
+
+type Hook func()
+
+var (
+	chDie   = make(chan struct{})
+	chExit  = make(chan struct{})
+	chTasks = make(chan Task, 1<<8)
+	started int32
+	closed  int32
+)
+
+func try(f func()) {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Println(fmt.Sprintf("%v\n%s", err, debug.Stack()))
+		}
+	}()
+	f()
+}
+
+func Sched() {
+	if atomic.AddInt32(&started, 1) != 1 {
+		return
+	}
+
+	ticker := time.NewTicker(env.TimerPrecision)
+	defer func() {
+		ticker.Stop()
+		close(chExit)
+	}()
+
+	for {
+		select {
+		case <-ticker.C:
+			cron()
+
+		case f := <-chTasks:
+			try(f)
+
+		case <-chDie:
+			return
+		}
+	}
+}
+
+func Close() {
+	if atomic.AddInt32(&closed, 1) != 1 {
+		return
+	}
+	close(chDie)
+	<-chExit
+	log.Println("Scheduler stopped")
+}
+
+func PushTask(task Task) {
+	chTasks <- task
+}
diff --git a/timer.go b/scheduler/timer.go
similarity index 78%
rename from timer.go
rename to scheduler/timer.go
index c28cd9c1..194358bd 100644
--- a/timer.go
+++ b/scheduler/timer.go
@@ -1,16 +1,37 @@
-package nano
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package scheduler
 
 import (
 	"fmt"
 	"log"
 	"math"
+	"runtime/debug"
 	"sync"
 	"sync/atomic"
 	"time"
 )
 
 const (
-	loopForever = -1
+	infinite = -1
 )
 
 var (
@@ -24,13 +45,6 @@ var (
 		muCreatedTimer sync.RWMutex
 		createdTimer   []*Timer
 	}{}
-
-	// timerPrecision indicates the precision of timer, default is time.Second
-	timerPrecision = time.Second
-
-	// globalTicker represents global ticker that all cron job will be executed
-	// in globalTicker.
-	globalTicker *time.Ticker
 )
 
 type (
@@ -79,8 +93,7 @@ func (t *Timer) Stop() {
 func safecall(id int64, fn TimerFunc) {
 	defer func() {
 		if err := recover(); err != nil {
-			log.Println(fmt.Sprintf("Call timer function error, TimerID=%d, Error=%v", id, err))
-			println(stack())
+			log.Println(fmt.Sprintf("Call timer function error, TimerID=%d, Error=%v\n%s", id, err, debug.Stack()))
 		}
 	}()
 
@@ -104,7 +117,7 @@ func cron() {
 	now := time.Now()
 	unn := now.UnixNano()
 	for id, t := range timerManager.timers {
-		if t.counter == loopForever || t.counter > 0 {
+		if t.counter == infinite || t.counter > 0 {
 			// condition timer
 			if t.condition != nil {
 				if t.condition.Check(now) {
@@ -119,7 +132,7 @@ func cron() {
 				t.elapse += int64(t.interval)
 
 				// update timer counter
-				if t.counter != loopForever && t.counter > 0 {
+				if t.counter != infinite && t.counter > 0 {
 					t.counter--
 				}
 			}
@@ -131,7 +144,6 @@ func cron() {
 			timerManager.muClosingTimer.Unlock()
 			continue
 		}
-
 	}
 
 	if len(timerManager.closingTimer) > 0 {
@@ -150,7 +162,7 @@ func cron() {
 // The duration d must be greater than zero; if not, NewTimer will panic.
 // Stop the timer to release associated resources.
 func NewTimer(interval time.Duration, fn TimerFunc) *Timer {
-	return NewCountTimer(interval, loopForever, fn)
+	return NewCountTimer(interval, infinite, fn)
 }
 
 // NewCountTimer returns a new Timer containing a function that will be called
@@ -198,18 +210,8 @@ func NewCondTimer(condition TimerCondition, fn TimerFunc) *Timer {
 		panic("nano/timer: nil condition")
 	}
 
-	t := NewCountTimer(time.Duration(math.MaxInt64), loopForever, fn)
+	t := NewCountTimer(time.Duration(math.MaxInt64), infinite, fn)
 	t.condition = condition
 
 	return t
 }
-
-// SetTimerPrecision set the ticker precision, and time precision can not less
-// than a Millisecond, and can not change after application running. The default
-// precision is time.Second
-func SetTimerPrecision(precision time.Duration) {
-	if precision < time.Millisecond {
-		panic("time precision can not less than a Millisecond")
-	}
-	timerPrecision = precision
-}
diff --git a/timer_test.go b/scheduler/timer_test.go
similarity index 61%
rename from timer_test.go
rename to scheduler/timer_test.go
index 12c83583..537cb65d 100644
--- a/timer_test.go
+++ b/scheduler/timer_test.go
@@ -1,4 +1,24 @@
-package nano
+// Copyright (c) nano Author. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package scheduler
 
 import (
 	"sync/atomic"
diff --git a/utils_test.go b/utils_test.go
deleted file mode 100644
index 71308972..00000000
--- a/utils_test.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package nano
-
-import "testing"
-
-func null(key, value int) int {
-	key += value
-	return key
-}
-
-func test1(m map[int]int) {
-	if len(m) < 1 {
-		return
-	}
-	for k, v := range m {
-		null(k, v)
-	}
-}
-
-func BenchmarkEmptyMap1(b *testing.B) {
-	b.ReportAllocs()
-
-	m := map[int]int{}
-	for i := 0; i < b.N; i++ {
-		test1(m)
-	}
-}
-
-func test2(m map[int]int) {
-	for k, v := range m {
-		null(k, v)
-	}
-}
-
-func BenchmarkEmptyMap2(b *testing.B) {
-	b.ReportAllocs()
-
-	m := map[int]int{}
-	for i := 0; i < b.N; i++ {
-		test2(m)
-	}
-}