Browse Source

Merge pull request #5 from tendermint/develop

Reset() and SIGHUP for AutoFiles
pull/1842/head
Jae Kwon 8 years ago
committed by GitHub
parent
commit
1c62bb6dad
3 changed files with 158 additions and 7 deletions
  1. +64
    -4
      os.go
  2. +64
    -0
      os_test.go
  3. +30
    -3
      service.go

+ 64
- 4
os.go View File

@ -8,6 +8,7 @@ import (
"os/signal"
"strings"
"sync"
"syscall"
"time"
)
@ -15,6 +16,10 @@ var (
GoPath = os.Getenv("GOPATH")
)
func init() {
initAFSIGHUPWatcher()
}
func TrapSignal(cb func()) {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
@ -134,6 +139,7 @@ const autoFileOpenDuration = 1000 * time.Millisecond
// Automatically closes and re-opens file for writing.
// This is useful for using a log file with the logrotate tool.
type AutoFile struct {
ID string
Path string
ticker *time.Ticker
mtx sync.Mutex
@ -142,6 +148,7 @@ type AutoFile struct {
func OpenAutoFile(path string) (af *AutoFile, err error) {
af = &AutoFile{
ID: RandStr(12) + ":" + path,
Path: path,
ticker: time.NewTicker(autoFileOpenDuration),
}
@ -149,14 +156,14 @@ func OpenAutoFile(path string) (af *AutoFile, err error) {
return
}
go af.processTicks()
autoFileWatchers.addAutoFile(af)
return
}
func (af *AutoFile) Close() error {
af.ticker.Stop()
af.mtx.Lock()
err := af.closeFile()
af.mtx.Unlock()
autoFileWatchers.removeAutoFile(af)
return err
}
@ -166,13 +173,14 @@ func (af *AutoFile) processTicks() {
if !ok {
return // Done.
}
af.mtx.Lock()
af.closeFile()
af.mtx.Unlock()
}
}
func (af *AutoFile) closeFile() (err error) {
af.mtx.Lock()
defer af.mtx.Unlock()
file := af.file
if file == nil {
return nil
@ -201,6 +209,56 @@ func (af *AutoFile) openFile() error {
return nil
}
//--------------------------------------------------------------------------------
var autoFileWatchers *afSIGHUPWatcher
func initAFSIGHUPWatcher() {
autoFileWatchers = newAFSIGHUPWatcher()
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGHUP)
go func() {
for _ = range c {
autoFileWatchers.closeAll()
}
}()
}
type afSIGHUPWatcher struct {
mtx sync.Mutex
autoFiles map[string]*AutoFile
}
func newAFSIGHUPWatcher() *afSIGHUPWatcher {
return &afSIGHUPWatcher{
autoFiles: make(map[string]*AutoFile, 10),
}
}
func (afw *afSIGHUPWatcher) addAutoFile(af *AutoFile) {
afw.mtx.Lock()
afw.autoFiles[af.ID] = af
afw.mtx.Unlock()
}
func (afw *afSIGHUPWatcher) removeAutoFile(af *AutoFile) {
afw.mtx.Lock()
delete(afw.autoFiles, af.ID)
afw.mtx.Unlock()
}
func (afw *afSIGHUPWatcher) closeAll() {
afw.mtx.Lock()
for _, af := range afw.autoFiles {
af.closeFile()
}
afw.mtx.Unlock()
}
//--------------------------------------------------------------------------------
func Tempfile(prefix string) (*os.File, string) {
file, err := ioutil.TempFile("", prefix)
if err != nil {
@ -209,6 +267,8 @@ func Tempfile(prefix string) (*os.File, string) {
return file, file.Name()
}
//--------------------------------------------------------------------------------
func Prompt(prompt string, defaultValue string) (string, error) {
fmt.Print(prompt)
reader := bufio.NewReader(os.Stdin)


+ 64
- 0
os_test.go View File

@ -0,0 +1,64 @@
package common
import (
"os"
"syscall"
"testing"
)
func TestSIGHUP(t *testing.T) {
// First, create an AutoFile writing to a tempfile dir
file, name := Tempfile("sighup_test")
err := file.Close()
if err != nil {
t.Fatalf("Error creating tempfile: %v", err)
}
// Here is the actual AutoFile
af, err := OpenAutoFile(name)
if err != nil {
t.Fatalf("Error creating autofile: %v", err)
}
// Write to the file.
_, err = af.Write([]byte("Line 1\n"))
if err != nil {
t.Fatalf("Error writing to autofile: %v", err)
}
_, err = af.Write([]byte("Line 2\n"))
if err != nil {
t.Fatalf("Error writing to autofile: %v", err)
}
// Send SIGHUP to self.
syscall.Kill(syscall.Getpid(), syscall.SIGHUP)
// Move the file over
err = os.Rename(name, name+"_old")
if err != nil {
t.Fatalf("Error moving autofile: %v", err)
}
// Write more to the file.
_, err = af.Write([]byte("Line 3\n"))
if err != nil {
t.Fatalf("Error writing to autofile: %v", err)
}
_, err = af.Write([]byte("Line 4\n"))
if err != nil {
t.Fatalf("Error writing to autofile: %v", err)
}
err = af.Close()
if err != nil {
t.Fatalf("Error closing autofile")
}
// Both files should exist
if body := MustReadFile(name + "_old"); string(body) != "Line 1\nLine 2\n" {
t.Errorf("Unexpected body %s", body)
}
if body := MustReadFile(name); string(body) != "Line 3\nLine 4\n" {
t.Errorf("Unexpected body %s", body)
}
}

+ 30
- 3
service.go View File

@ -1,12 +1,13 @@
/*
Classical-inheritance-style service declarations.
Services can be started, then stopped.
Services can be started, then stopped, then optionally restarted.
Users can override the OnStart/OnStop methods.
These methods are guaranteed to be called at most once.
By default, these methods are guaranteed to be called at most once.
A call to Reset will panic, unless OnReset is overwritten, allowing OnStart/OnStop to be called again.
Caller must ensure that Start() and Stop() are not called concurrently.
It is ok to call Stop() without calling Start() first.
Services cannot be re-started unless otherwise documented.
Services cannot be re-started unless OnReset is overwritten to allow it.
Typical usage:
@ -51,6 +52,9 @@ type Service interface {
Stop() bool
OnStop()
Reset() (bool, error)
OnReset() error
IsRunning() bool
String() string
@ -119,6 +123,29 @@ func (bs *BaseService) Stop() bool {
// Implements Service
func (bs *BaseService) OnStop() {}
// Implements Service
func (bs *BaseService) Reset() (bool, error) {
if atomic.CompareAndSwapUint32(&bs.stopped, 1, 0) {
// whether or not we've started, we can reset
atomic.CompareAndSwapUint32(&bs.started, 1, 0)
return true, bs.impl.OnReset()
} else {
if bs.log != nil {
bs.log.Debug(Fmt("Can't reset %v. Not stopped", bs.name), "impl", bs.impl)
}
return false, nil
}
// never happens
return false, nil
}
// Implements Service
func (bs *BaseService) OnReset() error {
PanicSanity("The service cannot be reset")
return nil
}
// Implements Service
func (bs *BaseService) IsRunning() bool {
return atomic.LoadUint32(&bs.started) == 1 && atomic.LoadUint32(&bs.stopped) == 0


Loading…
Cancel
Save