// connect to all services
func (p *service_pool) connect_all(directory string) {
client := p.client_pool.Get().(*etcd.Client)
defer func() {
p.client_pool.Put(client)
}()
// get the keys under directory
log.Info("connecting services under:", directory)
resp, err := client.Get(directory, true, true)
if err != nil {
log.Error(err)
return
}
// validation check
if !resp.Node.Dir {
log.Error("not a directory")
return
}
for _, node := range resp.Node.Nodes {
if node.Dir { // service directory
for _, service := range node.Nodes {
p.add_service(service.Key, service.Value)
}
} else {
log.Warning("malformed service directory:", node.Key)
}
}
log.Info("services add complete")
}
//---------------------------------------------------------- 读取GridFS文件
func LoadFile(filename string) (ok bool, content []byte) {
ms := _global_ms.Copy()
defer ms.Close()
buf := &bytes.Buffer{}
file, err := ms.DB("").GridFS("fs").Open(filename)
if err != nil {
log.Warning("gridfs", filename, err)
return false, nil
}
n, err := io.Copy(buf, file)
if err != nil {
log.Error("gridfs", filename, n, err)
return false, nil
}
err = file.Close()
if err != nil {
log.Error("gridfs", filename, err)
return false, nil
}
log.Trace("gridfs", filename, "load from GridFS!!")
return true, buf.Bytes()
}
// stream receiver
func (s *server) recv(stream GameService_StreamServer) chan *Game_Frame {
ch := make(chan *Game_Frame, 1)
go func() {
for {
in, err := stream.Recv()
if err == io.EOF { // client closed
close(ch)
return
}
if err != nil {
log.Critical(err)
close(ch)
return
}
select {
case ch <- in:
case <-time.After(RECV_TIMEOUT):
log.Warning("recv deliver timeout")
close(ch)
return
}
}
}()
return ch
}
func (s *server) dump(db *bolt.DB, changes map[uint64]bool) {
for k := range changes {
// marshal
var rs *RankSet
s.lock_read(func() {
rs = s.ranks[k]
})
if rs == nil {
log.Warning("empty rankset:", k)
continue
}
// serialization and save
bin, err := rs.Marshal()
if err != nil {
log.Critical("cannot marshal:", err)
os.Exit(-1)
}
db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(BOLTDB_BUCKET))
err := b.Put([]byte(fmt.Sprint(k)), bin)
return err
})
}
}
// collect & publish to statsd
func collect() {
tag := ""
if hostname, err := os.Hostname(); err == nil {
tag += hostname
} else {
log.Warning(SERVICE, err)
}
// executable name
if exe_name, err := os.Readlink("/proc/self/exe"); err == nil {
tag += "." + path.Base(exe_name)
} else {
tag += fmt.Sprintf(".%v", os.Getpid())
log.Warning(SERVICE, err)
}
memstats := &runtime.MemStats{}
runtime.ReadMemStats(memstats)
_statter.Counter(1.0, tag+".NumGoroutine", int(runtime.NumGoroutine()))
_statter.Counter(1.0, tag+".NumCgoCall", int(runtime.NumCgoCall()))
if memstats.NumGC > 0 {
_statter.Counter(1.0, tag+".NumGC", int(memstats.NumGC))
_statter.Timing(1.0, tag+".PauseTotal", time.Duration(memstats.PauseTotalNs))
_statter.Timing(1.0, tag+".LastPause", time.Duration(memstats.PauseNs[(memstats.NumGC+255)%256]))
_statter.Counter(1.0, tag+".Alloc", int(memstats.Alloc))
_statter.Counter(1.0, tag+".TotalAlloc", int(memstats.TotalAlloc))
_statter.Counter(1.0, tag+".Sys", int(memstats.Sys))
_statter.Counter(1.0, tag+".Lookups", int(memstats.Lookups))
_statter.Counter(1.0, tag+".Mallocs", int(memstats.Mallocs))
_statter.Counter(1.0, tag+".Frees", int(memstats.Frees))
_statter.Counter(1.0, tag+".HeapAlloc", int(memstats.HeapAlloc))
_statter.Counter(1.0, tag+".HeapSys", int(memstats.HeapSys))
_statter.Counter(1.0, tag+".HeapIdle", int(memstats.HeapIdle))
_statter.Counter(1.0, tag+".HeapInuse", int(memstats.HeapInuse))
_statter.Counter(1.0, tag+".HeapReleased", int(memstats.HeapReleased))
_statter.Counter(1.0, tag+".HeapObjects", int(memstats.HeapObjects))
_statter.Counter(1.0, tag+".StackInuse", int(memstats.StackInuse))
_statter.Counter(1.0, tag+".StackSys", int(memstats.StackSys))
_statter.Counter(1.0, tag+".MSpanInuse", int(memstats.MSpanInuse))
_statter.Counter(1.0, tag+".MSpanSys", int(memstats.MSpanSys))
_statter.Counter(1.0, tag+".MCacheInuse", int(memstats.MCacheInuse))
_statter.Counter(1.0, tag+".MCacheSys", int(memstats.MCacheSys))
_statter.Counter(1.0, tag+".BuckHashSys", int(memstats.BuckHashSys))
_statter.Counter(1.0, tag+".GCSys", int(memstats.GCSys))
_statter.Counter(1.0, tag+".OtherSys", int(memstats.OtherSys))
}
}
func main() {
// to catch all uncaught panic
defer utils.PrintPanicStack()
// open profiling
go func() {
log.Info(http.ListenAndServe("0.0.0.0:6060", nil))
}()
// set log prefix
log.SetPrefix(SERVICE)
// resolve address & start listening
tcpAddr, err := net.ResolveTCPAddr("tcp4", _port)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
log.Info("listening on:", listener.Addr())
// startup
startup()
LOOP:
// loop accepting
for {
conn, err := listener.AcceptTCP()
if err != nil {
log.Warning("accept failed:", err)
continue
}
go handleClient(conn) // start a goroutine for every incoming connection for reading
// check server close signal
select {
case <-die:
listener.Close()
break LOOP
default:
}
}
// server closed, wait forever
// other options:
// select{} -- may cause deadlock detected error, not tested yet
for {
<-time.After(time.Second)
}
}
//---------------------------------------------------------- 删除GridFS文件
func RemoveFile(filename string) bool {
ms := _global_ms.Copy()
defer ms.Close()
gridfs := ms.DB("").GridFS("fs")
// 删除同名文件
err := gridfs.Remove(filename)
if err != nil {
log.Warning("gridfs", filename, err)
return false
}
log.Trace("gridfs", filename, "removed from GridFS!!")
return true
}
func main() {
defer utils.PrintPanicStack()
go func() {
log.Info(http.ListenAndServe("0.0.0.0:6060", nil))
}()
log.SetPrefix(SERVICE)
// resolve
tcpAddr, err := net.ResolveTCPAddr("tcp4", _port)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
log.Info("listening on:", listener.Addr())
// init services
sp.Init()
// startup
startup()
// loop accepting
LOOP:
for {
conn, err := listener.AcceptTCP()
if err != nil {
log.Warning("accept failed:", err)
continue
}
go handleClient(conn)
// check server close signal
select {
case <-die:
listener.Close()
break LOOP
default:
}
}
// server closed, wait forever
for {
<-time.After(time.Second)
}
}