func TestPause(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
_, _, nsqd := mustStartNSQD(NewNSQDOptions())
defer nsqd.Exit()
topicName := "test_topic_pause" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
err := topic.Pause()
assert.Equal(t, err, nil)
channel := topic.GetChannel("ch1")
assert.NotEqual(t, channel, nil)
msg := nsq.NewMessage(<-nsqd.idChan, []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaa"))
err = topic.PutMessage(msg)
assert.Equal(t, err, nil)
time.Sleep(15 * time.Millisecond)
assert.Equal(t, topic.Depth(), int64(1))
assert.Equal(t, channel.Depth(), int64(0))
err = topic.UnPause()
assert.Equal(t, err, nil)
time.Sleep(15 * time.Millisecond)
assert.Equal(t, topic.Depth(), int64(0))
assert.Equal(t, channel.Depth(), int64(1))
}
// Supress output of function to keep logs clean
func supressOutput(f func()) {
old := os.Stdout
oldErr := os.Stderr
r, w, _ := os.Pipe()
os.Stdout = w
os.Stderr = w
l.SetOutput(w)
f()
outC := make(chan string)
// copy the output in a separate goroutine so printing can't block indefinitely
go func() {
var buf bytes.Buffer
io.Copy(&buf, r)
o := buf.String()
log.Trace(o)
outC <- o
}()
// log to TRACE
// back to normal state
w.Close()
os.Stdout = old
os.Stderr = oldErr
l.SetOutput(old)
}
func BenchmarkTopicToChannelPut(b *testing.B) {
b.StopTimer()
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
topicName := "bench_topic_to_channel_put" + strconv.Itoa(b.N)
channelName := "bench"
options := NewNSQDOptions()
options.MemQueueSize = int64(b.N)
_, _, nsqd := mustStartNSQD(options)
defer nsqd.Exit()
channel := nsqd.GetTopic(topicName).GetChannel(channelName)
b.StartTimer()
for i := 0; i <= b.N; i++ {
topic := nsqd.GetTopic(topicName)
msg := nsq.NewMessage(<-nsqd.idChan, []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaa"))
topic.PutMessage(msg)
}
for {
if len(channel.memoryMsgChan) == b.N {
break
}
runtime.Gosched()
}
}
// exercise the basic operations of the V2 protocol
func TestBasicV2(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
options := NewNsqdOptions()
options.clientTimeout = 60 * time.Second
tcpAddr, _, nsqd := mustStartNSQd(options)
defer nsqd.Exit()
topicName := "test_v2" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
msg := nsq.NewMessage(<-nsqd.idChan, []byte("test body"))
topic.PutMessage(msg)
conn, err := mustConnectNSQd(tcpAddr)
assert.Equal(t, err, nil)
identify(t, conn)
sub(t, conn, topicName, "ch")
err = nsq.Ready(1).Write(conn)
assert.Equal(t, err, nil)
resp, err := nsq.ReadResponse(conn)
assert.Equal(t, err, nil)
frameType, data, err := nsq.UnpackResponse(resp)
msgOut, _ := nsq.DecodeMessage(data)
assert.Equal(t, frameType, nsq.FrameTypeMessage)
assert.Equal(t, msgOut.Id, msg.Id)
assert.Equal(t, msgOut.Body, msg.Body)
assert.Equal(t, msgOut.Attempts, uint16(1))
}
func TestStats(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
options := NewNsqdOptions()
tcpAddr, _, nsqd := mustStartNSQd(options)
defer nsqd.Exit()
topicName := "test_stats" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
msg := nsq.NewMessage(<-nsqd.idChan, []byte("test body"))
topic.PutMessage(msg)
conn, err := mustConnectNSQd(tcpAddr)
assert.Equal(t, err, nil)
identify(t, conn)
sub(t, conn, topicName, "ch")
stats := nsqd.getStats()
assert.Equal(t, len(stats), 1)
assert.Equal(t, len(stats[0].Channels), 1)
assert.Equal(t, len(stats[0].Channels[0].Clients), 1)
log.Printf("stats: %+v", stats)
}
func TestChunkedResponseHeaders(t *testing.T) {
log.SetOutput(ioutil.Discard) // is noisy otherwise
defer log.SetOutput(os.Stderr)
ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
w.Header().Set("Content-Length", "intentional gibberish") // we check that this is deleted
w.(Flusher).Flush()
fmt.Fprintf(w, "I am a chunked response.")
}))
defer ts.Close()
res, err := Get(ts.URL)
if err != nil {
t.Fatalf("Get error: %v", err)
}
if g, e := res.ContentLength, int64(-1); g != e {
t.Errorf("expected ContentLength of %d; got %d", e, g)
}
if g, e := res.TransferEncoding, []string{"chunked"}; !reflect.DeepEqual(g, e) {
t.Errorf("expected TransferEncoding of %v; got %v", e, g)
}
if _, haveCL := res.Header["Content-Length"]; haveCL {
t.Errorf("Unexpected Content-Length")
}
}
func main() {
flag.Parse()
if *jsonFlag {
doc, _ := registryEntry.JSON()
fmt.Println(string(doc))
os.Exit(0)
}
log.SetFlags(0)
if *debug {
log.SetOutput(os.Stdout)
} else {
log.SetOutput(ioutil.Discard)
}
validateArgs()
// Communication channels
inCh = make(chan bool)
outCh = make(chan bool)
exitCh = make(chan os.Signal, 1)
// Start the communication & processing logic
go mainLoop()
// Wait for the end...
signal.Notify(exitCh, os.Interrupt, syscall.SIGTERM)
<-exitCh
log.Println("Done")
}
func logIRC(irc map[string]string) {
if _, err := os.Stat("./logs"); err != nil {
if os.IsNotExist(err) {
color.Green("Creating directory logs")
os.Mkdir("./logs", 0766)
}
}
if strings.HasPrefix(irc["params"], "#") {
s := strings.Split(irc["params"], " ")
f, err := os.OpenFile("logs/"+s[0]+".log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatalf("Error opening logfile for %s: %v", irc["params"], err)
}
log.SetOutput(f)
log.Printf("%s %s %s %s\n", irc["prefix"], irc["command"], irc["params"], irc["trailing"])
defer f.Close()
} else {
f, err := os.OpenFile("logs/all.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatalf("Error opening logfile all: %v", err)
}
log.SetOutput(f)
log.Printf("%s %s %s %s %s\n", irc["tags"], irc["prefix"], irc["command"], irc["params"], irc["trailing"])
defer f.Close()
}
}
func main() {
flag.Parse() // called here in main() to allow other packages to set flags in their inits
caddy.AppName = appName
caddy.AppVersion = appVersion
// set up process log before anything bad happens
switch logfile {
case "stdout":
log.SetOutput(os.Stdout)
case "stderr":
log.SetOutput(os.Stderr)
case "":
log.SetOutput(ioutil.Discard)
default:
file, err := os.OpenFile(logfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
log.Fatalf("Error opening log file: %v", err)
}
log.SetOutput(file)
}
if version {
fmt.Printf("%s %s\n", caddy.AppName, caddy.AppVersion)
os.Exit(0)
}
if revoke != "" {
err := letsencrypt.Revoke(revoke)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Revoked certificate for %s\n", revoke)
os.Exit(0)
}
// Set CPU cap
err := setCPU(cpu)
if err != nil {
mustLogFatal(err)
}
// Get Caddyfile input
caddyfile, err := caddy.LoadCaddyfile(loadCaddyfile)
if err != nil {
mustLogFatal(err)
}
// Start your engines
err = caddy.Start(caddyfile)
if err != nil {
if caddy.IsRestart() {
log.Printf("[ERROR] Upon starting %s: %v", appName, err)
} else {
mustLogFatal(err)
}
}
// Twiddle your thumbs
caddy.Wait()
}
func TestSnagInit(t *testing.T) {
buf := bytes.NewBuffer(nil)
log.SetOutput(buf)
defer log.SetOutput(os.Stdout)
wd, tmpDir := tmpDirectory(t)
defer os.RemoveAll(tmpDir)
chdir(t, tmpDir)
defer os.Chdir(wd)
_, err := os.Stat(SnagFile)
assert.True(t, os.IsNotExist(err))
err = initSnag()
require.NoError(t, err)
assert.Contains(t, buf.String(), "Success")
_, err = os.Stat(SnagFile)
require.NoError(t, err)
err = initSnag()
require.Error(t, err)
assert.Contains(t, err.Error(), "file already exists")
}
func TestTombstonedNodes(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
tcpAddr, httpAddr := mustStartLookupd()
defer lookupd.Exit()
lookupd.inactiveProducerTimeout = 50 * time.Millisecond
lookupdHTTPAddrs := []string{fmt.Sprintf("%s", httpAddr)}
topicName := "inactive_nodes"
conn := mustConnectLookupd(t, tcpAddr)
identify(t, conn, "ip.address", 5000, 5555, "fake-version")
nsq.Register(topicName, "channel1").Write(conn)
_, err := nsq.ReadResponse(conn)
assert.Equal(t, err, nil)
producers, _ := lookuputil.GetLookupdProducers(lookupdHTTPAddrs)
assert.Equal(t, len(producers), 1)
assert.Equal(t, len(producers[0].Topics), 1)
assert.Equal(t, producers[0].Topics[0].Topic, topicName)
assert.Equal(t, producers[0].Topics[0].Tombstoned, false)
endpoint := fmt.Sprintf("http://%s/tombstone_topic_producer?topic=%s&node=%s", httpAddr, topicName, "ip.address:5555")
_, err = nsq.ApiRequest(endpoint)
assert.Equal(t, err, nil)
producers, _ = lookuputil.GetLookupdProducers(lookupdHTTPAddrs)
assert.Equal(t, len(producers), 1)
assert.Equal(t, len(producers[0].Topics), 1)
assert.Equal(t, producers[0].Topics[0].Topic, topicName)
assert.Equal(t, producers[0].Topics[0].Tombstoned, true)
}
func TestReverseProxyInsecureSkipVerify(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stderr)
var requestReceived bool
backend := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestReceived = true
w.Write([]byte("Hello, client"))
}))
defer backend.Close()
// set up proxy
p := &Proxy{
Upstreams: []Upstream{newFakeUpstream(backend.URL, true)},
}
// create request and response recorder
r, err := http.NewRequest("GET", "/", nil)
if err != nil {
t.Fatalf("Failed to create request: %v", err)
}
w := httptest.NewRecorder()
p.ServeHTTP(w, r)
if !requestReceived {
t.Error("Even with insecure HTTPS, expected backend to receive request, but it didn't")
}
}
func TestPutMessage(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
sb := NewScalingBloom(1000, 0.5, "testbloom.bin")
if sb == nil {
t.Fatalf("NewScalingBloom failed")
}
key := []byte("test")
if sb.Check(key) != false {
t.Fatalf("Check failed")
}
if sb.Add(key, 1) != true {
t.Fatalf("Add failed")
}
if sb.Check(key) != true {
t.Fatalf("'%s' not found", key)
}
if sb.Remove(key, 1) != true {
t.Fatalf("Remove failed")
}
if sb.Check(key) != false {
t.Fatalf("'%s' was found (after remove)", key)
}
}
func captureOutput(f func()) string {
var buf bytes.Buffer
log.SetOutput(&buf)
f()
log.SetOutput(os.Stderr)
return buf.String()
}
func Test_aggWorkerProcessOrForward(t *testing.T) {
saveFn := aggWorkerForwardACToNode
forward, fwErr := 0, error(nil)
aggWorkerForwardACToNode = func(ac *aggregator.Command, node *cluster.Node, snd chan *cluster.Msg) error {
forward++
return fwErr
}
ac := aggregator.NewCommand(aggregator.CmdAdd, "foo", 123)
agg := &fakeAggregatorer{}
aggDd := &distDatumAggregator{agg}
// cluster
clstr := &fakeCluster{}
md := make([]byte, 20)
md[0] = 1 // Ready
node := &cluster.Node{Node: &memberlist.Node{Meta: md, Name: "local"}}
clstr.nodesForDd = []*cluster.Node{node}
clstr.ln = node
// Test if we are LocalNode
aggWorkerProcessOrForward(ac, aggDd, clstr, nil)
aggWorkerProcessOrForward(ac, aggDd, clstr, nil)
if agg.pcCalled < 1 {
t.Errorf("aggWorkerProcessOrForward: agg.ProcessCmd() not called")
}
// Now test we are NOT LN, forward
remote := &cluster.Node{Node: &memberlist.Node{Meta: md, Name: "remote"}}
clstr.nodesForDd = []*cluster.Node{remote}
n := aggWorkerProcessOrForward(ac, aggDd, clstr, nil)
if forward != 1 {
t.Errorf("aggWorkerProcessOrForward: aggWorkerForwardDPToNode not called")
}
if n != 1 {
t.Errorf("aggWorkerProcessOrForward: return value != 1")
}
fl := &fakeLogger{}
log.SetOutput(fl)
defer func() {
// restore default output
log.SetOutput(os.Stderr)
}()
fwErr = fmt.Errorf("some error")
n = aggWorkerProcessOrForward(ac, aggDd, clstr, nil)
if n != 0 {
t.Errorf("aggWorkerProcessOrForward: return value != 0")
}
if !strings.Contains(string(fl.last), "some error") {
t.Errorf("aggWorkerProcessOrForward: aggWorkerForwardACToNode not logged")
}
fwErr = nil
// restore
aggWorkerForwardACToNode = saveFn
}
func TestChannelEmptyConsumer(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
options := NewNSQDOptions()
tcpAddr, _, nsqd := mustStartNSQD(options)
defer nsqd.Exit()
conn, _ := mustConnectNSQD(tcpAddr)
topicName := "test_channel_empty" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
channel := topic.GetChannel("channel")
client := NewClientV2(0, conn, &Context{nsqd})
client.SetReadyCount(25)
channel.AddClient(client.ID, client)
for i := 0; i < 25; i++ {
msg := nsq.NewMessage(<-nsqd.idChan, []byte("test"))
channel.StartInFlightTimeout(msg, 0, options.MsgTimeout)
client.SendingMessage()
}
for _, cl := range channel.clients {
stats := cl.Stats()
assert.Equal(t, stats.InFlightCount, int64(25))
}
channel.Empty()
for _, cl := range channel.clients {
stats := cl.Stats()
assert.Equal(t, stats.InFlightCount, int64(0))
}
}
func main() {
var faddr, baddr, cryptoMethod, secret, logTo string
var clientMode bool
flag.StringVar(&logTo, "logto", "stdout", "stdout or syslog")
flag.StringVar(&faddr, "listen", ":9001", "host:port qtunnel listen on")
flag.StringVar(&baddr, "backend", "127.0.0.1:6400", "host:port of the backend")
flag.StringVar(&cryptoMethod, "crypto", "rc4", "encryption method")
flag.StringVar(&secret, "secret", "secret", "password used to encrypt the data")
flag.BoolVar(&clientMode, "clientmode", false, "if running at client mode")
flag.Parse()
log.SetOutput(os.Stdout)
if logTo == "syslog" {
w, err := syslog.New(syslog.LOG_INFO, "qtunnel")
if err != nil {
log.Fatal(err)
}
log.SetOutput(w)
}
t := tunnel.NewTunnel(faddr, baddr, clientMode, cryptoMethod, secret, 4096)
log.Println("qtunnel started.")
go t.Start()
waitSignal()
}
func TestHTTPmput(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
_, httpAddr, nsqd := mustStartNSQd(NewNsqdOptions())
defer nsqd.Exit()
topicName := "test_http_mput" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
msg := []byte("test message")
msgs := make([][]byte, 0)
for i := 0; i < 4; i++ {
msgs = append(msgs, msg)
}
buf := bytes.NewBuffer(bytes.Join(msgs, []byte("\n")))
url := fmt.Sprintf("http://%s/mput?topic=%s", httpAddr, topicName)
resp, err := http.Post(url, "application/octet-stream", buf)
assert.Equal(t, err, nil)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
assert.Equal(t, string(body), "OK")
assert.Equal(t, topic.Depth(), int64(4))
}
// TLog changes the log package's output to log to t and returns a function
// to reset it back to stderr.
func TLog(t TB) func() {
// TODO(bradfitz): once we rely on Go 1.2, change this to take a testing.TB.
log.SetOutput(&twriter{t: t})
return func() {
log.SetOutput(os.Stderr)
}
}
func cammountTest(t *testing.T, fn func(env *mountEnv)) {
dupLog := io.MultiWriter(os.Stderr, testLog{t})
log.SetOutput(dupLog)
defer log.SetOutput(os.Stderr)
w := test.GetWorld(t)
mountPoint, err := ioutil.TempDir("", "fs-test-mount")
if err != nil {
t.Fatal(err)
}
verbose := "false"
var stderrDest io.Writer = ioutil.Discard
if v, _ := strconv.ParseBool(os.Getenv("VERBOSE_FUSE")); v {
verbose = "true"
stderrDest = testLog{t}
}
if v, _ := strconv.ParseBool(os.Getenv("VERBOSE_FUSE_STDERR")); v {
stderrDest = io.MultiWriter(stderrDest, os.Stderr)
}
mount := w.Cmd("cammount", "--debug="+verbose, mountPoint)
mount.Stderr = stderrDest
mount.Env = append(mount.Env, "CAMLI_TRACK_FS_STATS=1")
stdin, err := mount.StdinPipe()
if err != nil {
t.Fatal(err)
}
if err := mount.Start(); err != nil {
t.Fatal(err)
}
waitc := make(chan error, 1)
go func() { waitc <- mount.Wait() }()
defer func() {
log.Printf("Sending quit")
stdin.Write([]byte("q\n"))
select {
case <-time.After(5 * time.Second):
log.Printf("timeout waiting for cammount to finish")
mount.Process.Kill()
Unmount(mountPoint)
case err := <-waitc:
log.Printf("cammount exited: %v", err)
}
if !test.WaitFor(not(dirToBeFUSE(mountPoint)), 5*time.Second, 1*time.Second) {
// It didn't unmount. Try again.
Unmount(mountPoint)
}
}()
if !test.WaitFor(dirToBeFUSE(mountPoint), 5*time.Second, 100*time.Millisecond) {
t.Fatalf("error waiting for %s to be mounted", mountPoint)
}
fn(&mountEnv{
t: t,
mountPoint: mountPoint,
process: mount.Process,
})
}
func main() {
// options
var bind, backend, logTo string
var buffer uint
var daemon bool
flag.StringVar(&bind, "bind", ":8002", "locate ip and port")
flag.StringVar(&backend, "backend", "127.0.0.1:8003", "backend server ip and port")
flag.StringVar(&logTo, "logTo", "stdout", "stdout or syslog")
flag.UintVar(&buffer, "buffer", 4096, "buffer size")
flag.BoolVar(&daemon, "daemon", false, "run as daemon process")
flag.Parse()
log.SetOutput(os.Stdout)
if logTo == "syslog" {
w, err := syslog.New(syslog.LOG_INFO, "portproxy")
if err != nil {
log.Fatal(err)
}
log.SetOutput(w)
}
if daemon == true {
godaemon.MakeDaemon(&godaemon.DaemonAttr{})
}
p := New(bind, backend, uint32(buffer))
log.Println("portproxy started.")
go p.Start()
waitSignal()
}
func TestDiskQueueCorruption(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
dqName := "test_disk_queue_corruption" + strconv.Itoa(int(time.Now().Unix()))
dq := NewDiskQueue(dqName, os.TempDir(), 1000, 5)
msg := make([]byte, 123)
for i := 0; i < 25; i++ {
dq.Put(msg)
}
assert.Equal(t, dq.Depth(), int64(25))
// corrupt the 2nd file
dqFn := dq.(*DiskQueue).fileName(1)
os.Truncate(dqFn, 500)
for i := 0; i < 19; i++ {
assert.Equal(t, <-dq.ReadChan(), msg)
}
// corrupt the 4th (current) file
dqFn = dq.(*DiskQueue).fileName(3)
os.Truncate(dqFn, 100)
dq.Put(msg)
assert.Equal(t, <-dq.ReadChan(), msg)
}
func testChunkedResponseHeaders(t *testing.T, h2 bool) {
defer afterTest(t)
log.SetOutput(ioutil.Discard) // is noisy otherwise
defer log.SetOutput(os.Stderr)
cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
w.Header().Set("Content-Length", "intentional gibberish") // we check that this is deleted
w.(Flusher).Flush()
fmt.Fprintf(w, "I am a chunked response.")
}))
defer cst.close()
res, err := cst.c.Get(cst.ts.URL)
if err != nil {
t.Fatalf("Get error: %v", err)
}
defer res.Body.Close()
if g, e := res.ContentLength, int64(-1); g != e {
t.Errorf("expected ContentLength of %d; got %d", e, g)
}
wantTE := []string{"chunked"}
if h2 {
wantTE = nil
}
if !reflect.DeepEqual(res.TransferEncoding, wantTE) {
t.Errorf("TransferEncoding = %v; want %v", res.TransferEncoding, wantTE)
}
if got, haveCL := res.Header["Content-Length"]; haveCL {
t.Errorf("Unexpected Content-Length: %q", got)
}
}
func TestBuilder_Issue287(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stderr)
dr, _ := os.Getwd()
appGen, err := newAppGenerator("plainTexter", nil, nil, &GenOpts{
Spec: filepath.FromSlash("../fixtures/bugs/287/swagger.yml"),
IncludeModel: true,
IncludeValidator: true,
IncludeHandler: true,
IncludeParameters: true,
IncludeResponses: true,
IncludeMain: true,
APIPackage: "restapi",
ModelPackage: "model",
ServerPackage: "server",
ClientPackage: "client",
Target: dr,
})
if assert.NoError(t, err) {
op, err := appGen.makeCodegenApp()
if assert.NoError(t, err) {
buf := bytes.NewBuffer(nil)
err := builderTemplate.Execute(buf, op)
if assert.NoError(t, err) {
ff, err := formatGoFile("put_testing.go", buf.Bytes())
if assert.NoError(t, err) {
res := string(ff)
assertInCode(t, "case \"text/plain\":", res)
} else {
fmt.Println(buf.String())
}
}
}
}
}
func TestCandidateToLeader(t *testing.T) {
log.SetOutput(&bytes.Buffer{})
defer log.SetOutput(os.Stdout)
oldMin, oldMax := raft.ResetElectionTimeoutMs(25, 50)
defer raft.ResetElectionTimeoutMs(oldMin, oldMax)
noop := func([]byte) ([]byte, error) { return []byte{}, nil }
server := raft.NewServer(1, &bytes.Buffer{}, noop)
server.SetPeers(raft.MakePeers(nonresponsivePeer(1), approvingPeer(2), nonresponsivePeer(3)))
server.Start()
defer func() { server.Stop(); t.Logf("server stopped") }()
time.Sleep(raft.MaximumElectionTimeout())
cutoff := time.Now().Add(2 * raft.MaximumElectionTimeout())
backoff := raft.BroadcastInterval()
for {
if time.Now().After(cutoff) {
t.Fatal("failed to become Leader")
}
if state := server.State(); state != raft.Leader {
time.Sleep(backoff)
backoff *= 2
continue
}
t.Logf("became Leader")
break
}
}
func TestInFlightWorker(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
options := NewNSQDOptions()
options.MsgTimeout = 200 * time.Millisecond
nsqd := NewNSQD(options)
defer nsqd.Exit()
topicName := "test_in_flight_worker" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
channel := topic.GetChannel("channel")
for i := 0; i < 1000; i++ {
msg := nsq.NewMessage(<-nsqd.idChan, []byte("test"))
channel.StartInFlightTimeout(msg, 0)
}
assert.Equal(t, len(channel.inFlightMessages), 1000)
assert.Equal(t, len(channel.inFlightPQ), 1000)
// the in flight worker has a resolution of 100ms so we need to wait
// at least that much longer than our msgTimeout (in worst case)
time.Sleep(options.MsgTimeout + 100*time.Millisecond)
assert.Equal(t, len(channel.inFlightMessages), 0)
assert.Equal(t, len(channel.inFlightPQ), 0)
}
func TestInFlightWorker(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
options := NewNsqdOptions()
options.msgTimeout = 300 * time.Millisecond
nsqd = NewNSQd(1, options)
defer nsqd.Exit()
topicName := "test_in_flight_worker" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
channel := topic.GetChannel("channel")
for i := 0; i < 1000; i++ {
msg := nsq.NewMessage(<-nsqd.idChan, []byte("test"))
channel.StartInFlightTimeout(msg, NewClientV2(nil))
}
assert.Equal(t, len(channel.inFlightMessages), 1000)
assert.Equal(t, len(channel.inFlightPQ), 1000)
time.Sleep(350 * time.Millisecond)
assert.Equal(t, len(channel.inFlightMessages), 0)
assert.Equal(t, len(channel.inFlightPQ), 0)
}
func TestChannelEmpty(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
options := NewNSQDOptions()
_, _, nsqd := mustStartNSQD(options)
defer nsqd.Exit()
topicName := "test_channel_empty" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
channel := topic.GetChannel("channel")
msgs := make([]*nsq.Message, 0, 25)
for i := 0; i < 25; i++ {
msg := nsq.NewMessage(<-nsqd.idChan, []byte("test"))
channel.StartInFlightTimeout(msg, 0, options.MsgTimeout)
msgs = append(msgs, msg)
}
channel.RequeueMessage(0, msgs[len(msgs)-1].Id, 100*time.Millisecond)
assert.Equal(t, len(channel.inFlightMessages), 24)
assert.Equal(t, len(channel.inFlightPQ), 24)
assert.Equal(t, len(channel.deferredMessages), 1)
assert.Equal(t, len(channel.deferredPQ), 1)
channel.Empty()
assert.Equal(t, len(channel.inFlightMessages), 0)
assert.Equal(t, len(channel.inFlightPQ), 0)
assert.Equal(t, len(channel.deferredMessages), 0)
assert.Equal(t, len(channel.deferredPQ), 0)
assert.Equal(t, channel.Depth(), int64(0))
}
func init() {
hooks = hook.Hooks{}
flag.Parse()
log.SetPrefix("[webhook] ")
log.SetFlags(log.Ldate | log.Ltime)
if !*verbose {
log.SetOutput(ioutil.Discard)
}
log.Println("version " + version + " starting")
// load and parse hooks
log.Printf("attempting to load hooks from %s\n", *hooksFilePath)
err := hooks.LoadFromFile(*hooksFilePath)
if err != nil {
if !*verbose && !*noPanic {
log.SetOutput(os.Stdout)
log.Fatalf("couldn't load any hooks from file! %+v\naborting webhook execution since the -verbose flag is set to false.\nIf, for some reason, you want webhook to start without the hooks, either use -verbose flag, or -nopanic", err)
}
log.Printf("couldn't load hooks from file! %+v\n", err)
} else {
log.Printf("loaded %d hook(s) from file\n", len(hooks))
for _, hook := range hooks {
log.Printf("\t> %s\n", hook.ID)
}
}
}
func TestModulePingSend(t *testing.T) {
srv := CreateTestServerWithTwoMinions(t)
buf := bytes.NewBuffer(nil)
log.SetOutput(buf)
m := &PingModule{}
m.Init(srv)
m.PrivMsg(srv, &Message{
ReplyTo: "#test",
Body: "whygor: ping",
})
msgs := srv.FlushOutputQueue()
AssertIntEquals(t, len(msgs), 2)
AssertStringEquals(t, msgs[0].QueueURL, "http://sqs.us-east-1.amazonaws.com/000000000000/minion-pi1")
AssertStringHasPrefix(t, msgs[0].Body, "ping ")
AssertStringEquals(t, msgs[1].QueueURL, "http://sqs.us-east-1.amazonaws.com/000000000000/minion-pi2")
AssertStringHasPrefix(t, msgs[1].Body, "ping ")
m.MinionMsg(srv, &Message{
UserID: "UserID-pi1",
Args: []string{"1234567890000000000"},
})
msgs = srv.FlushOutputQueue()
AssertIntEquals(t, len(msgs), 0)
AssertStringContains(t, buf.String(), "got old ping response")
log.SetOutput(os.Stdout)
}