Merge branch 'release-0.1.1'

README.md

@@ -5,8 +5,9 @@ A daemon package for use with Go (golang) services
 
 [![GoDoc](https://godoc.org/github.com/takama/daemon?status.svg)](https://godoc.org/github.com/takama/daemon)
 
-### Example
+### Examples
 
+Simplest example (just install self as daemon):
 ```go
 package main
 
@@ -30,11 +31,141 @@ func main() {
 }
 ```
 
+Real example:
+```go
+// Example of the daemon with echo service
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/takama/daemon"
+)
+
+const (
+
+	// name of the service, match with executable file name
+	name        = "myservice"
+	description = "Some explanation of the service purpose"
+
+	// port which daemon should be listen
+	port = ":9977"
+)
+
+type Service struct {
+	daemon.Daemon
+}
+
+func (service *Service) Manage() (string, error) {
+
+	usage := "Usage: myservice install | remove | start | stop | status"
+
+	// if received any kind of command, do it
+	if len(os.Args) > 1 {
+		command := os.Args[1]
+		switch command {
+		case "install":
+			return service.Install()
+		case "remove":
+			return service.Remove()
+		case "start":
+			return service.Start()
+		case "stop":
+			return service.Stop()
+		case "status":
+			return service.Status()
+		default:
+			return usage, nil
+		}
+	}
+
+	// Do something, call your goroutines, etc
+
+	// Set up channel on which to send signal notifications.
+	// We must use a buffered channel or risk missing the signal
+	// if we're not ready to receive when the signal is sent.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)
+
+	// Set up listener for defined host and port
+	listener, err := net.Listen("tcp", port)
+	if err != nil {
+		return "Possibly was a problem with the port binding", err
+	}
+
+	// set up channel on which to send accepted connections
+	listen := make(chan net.Conn, 100)
+	go acceptConnection(listener, listen)
+
+	// loop work cycle with accept connections or interrupt
+	// by system signal
+	for {
+		select {
+		case conn := <-listen:
+			go handleClient(conn)
+		case killSignal := <-interrupt:
+			log.Println("Got signal:", killSignal)
+			log.Println("Stoping listening on ", listener.Addr())
+			listener.Close()
+			if killSignal == os.Interrupt {
+				return "Daemon was interruped by system signal", nil
+			}
+			return "Daemon was killed", nil
+		}
+	}
+
+	// never happen, but need to complete code
+	return usage, nil
+}
+
+// Accept a client connection and collect it in a channel
+func acceptConnection(listener net.Listener, listen chan<- net.Conn) {
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			continue
+		}
+		listen <- conn
+	}
+}
+
+func handleClient(client net.Conn) {
+	for {
+		buf := make([]byte, 4096)
+		numbytes, err := client.Read(buf)
+		if numbytes == 0 || err != nil {
+			return
+		}
+		client.Write(buf)
+	}
+}
+
+func main() {
+	srv, err := daemon.New(name, description)
+	if err != nil {
+		fmt.Println("Error: ", err)
+		os.Exit(1)
+	}
+	service := &Service{srv}
+	status, err := service.Manage()
+	if err != nil {
+		fmt.Println(status, "\nError: ", err)
+		os.Exit(1)
+	}
+	fmt.Println(status)
+
+}
+```
+
 ## Author
 
 [Igor Dolzhikov](https://github.com/takama)
 
-
 ## License
 
 [MIT Public License](https://github.com/takama/daemon/blob/master/LICENSE)

daemon.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package daemon 0.1.0 for use with Go (golang) services.
+// Package daemon 0.1.1 for use with Go (golang) services.
 //
 // Package daemon provides primitives for daemonization of golang services.
 // This package is not provide implementation of user daemon,
@@ -11,24 +11,38 @@
 //
 // Example:
 //
+//	//Example of the daemon with echo service
 //	package main
 //
 //	import (
-// 		"fmt"
+//		"fmt"
+//		"log"
+//		"net"
 //		"os"
+//		"os/signal"
+//		"syscall"
+//
 //		"github.com/takama/daemon"
 //	)
 //
 //	const (
+//
+//		// name of the service, match with executable file name
 //		name        = "myservice"
-//		description = "Some explanation of the service purpose"
+//		description = ""My Echo Service"
+//
+//		// port which daemon should be listen
+//		port = ":9977"
 //	)
 //
 //	type Service struct {
 //		daemon.Daemon
 //	}
 //
 //	func (service *Service) Manage() (string, error) {
+//
+//		usage := "Usage: myservice install | remove | start | stop | status"
+//
 //		// if received any kind of command, do it
 //		if len(os.Args) > 1 {
 //			command := os.Args[1]
@@ -43,12 +57,70 @@
 //				return service.Stop()
 //			case "status":
 //				return service.Status()
+//			default:
+//				return usage, nil
 //			}
 //		}
 //
 //		// Do something, call your goroutines, etc
 //
-//		return "Usage: myservice install | remove | start | stop | status", nil
+//		// Set up channel on which to send signal notifications.
+//		// We must use a buffered channel or risk missing the signal
+//		// if we're not ready to receive when the signal is sent.
+//		interrupt := make(chan os.Signal, 1)
+//		signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)
+//
+//		// Set up listener for defined host and port
+//		listener, err := net.Listen("tcp", port)
+//		if err != nil {
+//			return "Possibly was a problem with the port binding", err
+//		}
+//
+//		// set up channel on which to send accepted connections
+//		listen := make(chan net.Conn, 100)
+//		go acceptConnection(listener, listen)
+//
+//		// loop work cycle with accept connections or interrupt
+//		// by system signal
+//		for {
+//			select {
+//			case conn := <-listen:
+//				go handleClient(conn)
+//			case killSignal := <-interrupt:
+//				log.Println("Got signal:", killSignal)
+//				log.Println("Stoping listening on ", listener.Addr())
+//				listener.Close()
+//				if killSignal == os.Interrupt {
+//					return "Daemon was interruped by system signal", nil
+//				}
+//				return "Daemon was killed", nil
+//			}
+//		}
+//
+//		// never happen, but need to complete code
+//		return usage, nil
+//	}
+//
+//	// Accept a client connection and collect it in a channel
+//	func acceptConnection(listener net.Listener, listen chan<- net.Conn) {
+//		for {
+//			conn, err := listener.Accept()
+//			if err != nil {
+//				continue
+//			}
+//			listen <- conn
+//		}
+//	}
+//
+//	func handleClient(client net.Conn) {
+//		for {
+//			buf := make([]byte, 4096)
+//			numbytes, err := client.Read(buf)
+//			if numbytes == 0 || err != nil {
+//				return
+//			}
+//			client.Write(buf)
+//		}
 //	}
 //
 //	func main() {
@@ -103,7 +175,7 @@ type Daemon interface {
 
 // New - Create a new daemon
 //
-// name: name ot the service, must be match with executable file name;
+// name: name of the service, match with executable file name;
 // description: any explanation, what is the service, its purpose
 func New(name, description string) (Daemon, error) {
 	return newDaemon(name, description)

darwin.go

@@ -113,7 +113,7 @@ func (darwin *DarwinRecord) Remove() (string, error) {
 	}
 
 	if darwin.checkInstalled() == false {
-		return removeAction + failed, errors.New(darwin.description + " not installed")
+		return removeAction + failed, errors.New(darwin.description + " is not installed")
 	}
 
 	if err := os.Remove(darwin.servicePath()); err != nil {
@@ -132,7 +132,7 @@ func (darwin *DarwinRecord) Start() (string, error) {
 	}
 
 	if darwin.checkInstalled() == false {
-		return startAction + failed, errors.New(darwin.description + " not installed")
+		return startAction + failed, errors.New(darwin.description + " is not installed")
 	}
 
 	if _, status := darwin.checkRunning(); status == true {
@@ -155,7 +155,7 @@ func (darwin *DarwinRecord) Stop() (string, error) {
 	}
 
 	if darwin.checkInstalled() == false {
-		return stopAction + failed, errors.New(darwin.description + " not installed")
+		return stopAction + failed, errors.New(darwin.description + " is not installed")
 	}
 
 	if _, status := darwin.checkRunning(); status == false {
@@ -177,7 +177,7 @@ func (darwin *DarwinRecord) Status() (string, error) {
 	}
 
 	if darwin.checkInstalled() == false {
-		return "Status could not defined", errors.New(darwin.description + " not installed")
+		return "Status could not defined", errors.New(darwin.description + " is not installed")
 	}
 
 	statusAction, _ := darwin.checkRunning()