yuxh/gearman-go
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity

go fmt

Browse Source
This commit is contained in:
Xing Xing 2015-01-06 11:45:18 +08:00
parent a003eac543
commit ad9b3cb988
5 changed files with 57 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/client/client.go
View File

@ -3,8 +3,8 @@ package main
import (
"github.com/mikespook/gearman-go/client"
"log"
"sync"
"os"
"sync"
)
func main() {

4
example/worker/worker.go
View File

@ -4,10 +4,10 @@ import (
"github.com/mikespook/gearman-go/worker"
"github.com/mikespook/golib/signal"
"log"
"net"
"os"
"strings"
"time"
"net"
)
func ToUpper(job worker.Job) ([]byte, error) {
@ -41,7 +41,7 @@ func main() {
w.ErrorHandler = func(e error) {
log.Println(e)
if opErr, ok := e.(*net.OpError); ok {
if ! opErr.Temporary() {
if !opErr.Temporary() {
proc, err := os.FindProcess(os.Getpid())
if err != nil {
log.Println(err)

26
worker/agent.go
View File

@ -4,9 +4,9 @@ import (
"bufio"
"bytes"
"encoding/binary"
"io"
"net"
"sync"
"io"
)
// The agent of job server.
@ -59,14 +59,14 @@ func (a *agent) work() {
if opErr, ok := err.(*net.OpError); ok {
if opErr.Temporary() {
continue
}else{
} else {
a.disconnect_error(err)
// else - we're probably dc'ing due to a Close()
break
}
} else if( err == io.EOF ){
} else if err == io.EOF {
a.disconnect_error(err)
break
}
@ -104,11 +104,11 @@ func (a *agent) work() {
}
}
func (a * agent) disconnect_error( err error ){
if( a.conn != nil ){
func (a *agent) disconnect_error(err error) {
if a.conn != nil {
err = &WorkerDisconnectError{
err : err,
agent : a,
err: err,
agent: a,
}
a.worker.err(err)
}
@ -129,7 +129,7 @@ func (a *agent) Grab() {
a.grab()
}
func (a *agent) grab(){
func (a *agent) grab() {
outpack := getOutPack()
outpack.dataType = dtGrabJobUniq
a.write(outpack)
@ -143,16 +143,16 @@ func (a *agent) PreSleep() {
a.write(outpack)
}
func (a *agent) reconnect() (error){
a.Lock()
func (a *agent) reconnect() error {
a.Lock()
defer a.Unlock()
conn, err := net.Dial(a.net, a.addr)
if err != nil {
return err;
return err
}
a.conn = conn
a.rw = bufio.NewReadWriter(bufio.NewReader(a.conn),
bufio.NewWriter(a.conn))
bufio.NewWriter(a.conn))
a.grab()
a.worker.reRegisterFuncsForAgent(a)

33
worker/worker_disconnect_test.go
View File

@ -50,8 +50,8 @@ func run_gearman() {
panic(`Unable to start gearman aborting test`)
}
gearman_ready <- true
<- kill_gearman
<-kill_gearman
}
func check_gearman_present() bool {
@ -134,14 +134,14 @@ func TestBasicDisconnect(t *testing.T) {
send_client_request()
select {
case <- done:
case <-done:
t.Error("Client request handled (somehow), did we magically reconnect?")
case <-timeout:
t.Error("Test timed out waiting for the error handler")
case <-c_error:
// error was handled!
if ! was_dc_err {
t.Error( "Disconnect didn't manifest as a net.OpError?")
if !was_dc_err {
t.Error("Disconnect didn't manifest as a net.OpError?")
}
}
worker.Close()
@ -175,24 +175,23 @@ func TestDcRc(t *testing.T) {
worker.ErrorHandler = func(e error) {
wdc, wdcok := e.(*WorkerDisconnectError)
if( wdcok){
if wdcok {
log.Println("Reconnecting!")
reconnected := false
for tries := 20 ; ! reconnected && tries > 0; tries -- {
for tries := 20; !reconnected && tries > 0; tries-- {
rcerr := wdc.Reconnect()
if rcerr != nil{
if rcerr != nil {
time.Sleep(250 * time.Millisecond)
} else{
reconnected = true;
} else {
reconnected = true
}
}
} else{
} else {
panic("Some other kind of error " + e.Error())
}
}
go func() {
@ -219,9 +218,9 @@ func TestDcRc(t *testing.T) {
}
send_client_request()
select {
case <- done:
case <-done:
case <-timeout:
t.Error("Test timed out")
}

50
worker/worker_test.go
View File

@ -139,7 +139,7 @@ func TestWorkerClose(t *testing.T) {
worker.Close()
}
func TestWorkWithoutReady(t * testing.T){
func TestWorkWithoutReady(t *testing.T) {
other_worker := New(Unlimited)
if err := other_worker.AddServer(Network, "127.0.0.1:4730"); err != nil {
@ -148,15 +148,15 @@ func TestWorkWithoutReady(t * testing.T){
if err := other_worker.AddFunc("gearman-go-workertest", foobar, 0); err != nil {
t.Error(err)
}
timeout := make(chan bool, 1)
done := make( chan bool, 1)
other_worker.JobHandler = func( j Job ) error {
if( ! other_worker.ready ){
t.Error("Worker not ready as expected");
timeout := make(chan bool, 1)
done := make(chan bool, 1)
other_worker.JobHandler = func(j Job) error {
if !other_worker.ready {
t.Error("Worker not ready as expected")
}
done <-true
done <- true
return nil
}
go func() {
@ -164,15 +164,15 @@ func TestWorkWithoutReady(t * testing.T){
timeout <- true
}()
go func(){
other_worker.Work();
go func() {
other_worker.Work()
}()
// With the all-in-one Work() we don't know if the
// With the all-in-one Work() we don't know if the
// worker is ready at this stage so we may have to wait a sec:
go func(){
go func() {
tries := 5
for( tries > 0 ){
for tries > 0 {
if other_worker.ready {
other_worker.Echo([]byte("Hello"))
break
@ -183,24 +183,24 @@ func TestWorkWithoutReady(t * testing.T){
tries--
}
}()
// determine if we've finished or timed out:
select{
case <- timeout:
select {
case <-timeout:
t.Error("Test timed out waiting for the worker")
case <- done:
case <-done:
}
}
func TestWorkWithoutReadyWithPanic(t * testing.T){
func TestWorkWithoutReadyWithPanic(t *testing.T) {
other_worker := New(Unlimited)
timeout := make(chan bool, 1)
done := make( chan bool, 1)
done := make(chan bool, 1)
// Going to work with no worker setup.
// when Work (hopefully) calls Ready it will get an error which should cause it to panic()
go func(){
go func() {
defer func() {
if err := recover(); err != nil {
done <- true
@ -209,17 +209,17 @@ func TestWorkWithoutReadyWithPanic(t * testing.T){
t.Error("Work should raise a panic.")
done <- true
}()
other_worker.Work();
other_worker.Work()
}()
go func() {
time.Sleep(2 * time.Second)
timeout <- true
}()
select{
case <- timeout:
select {
case <-timeout:
t.Error("Test timed out waiting for the worker")
case <- done:
case <-done:
}
}