nsqd: add support for configurable max-defer-delay for DPUB

apps/nsqd/options.go

@@ -159,6 +159,7 @@ func nsqdFlagSet(opts *nsqd.Options) *flag.FlagSet {
 	flagSet.Int64("max-msg-size", opts.MaxMsgSize, "maximum size of a single message in bytes")
 	flagSet.Duration("max-req-timeout", opts.MaxReqTimeout, "maximum requeuing timeout for a message")
 	flagSet.Int64("max-body-size", opts.MaxBodySize, "maximum size of a single command body")
+	flagSet.Duration("max-defer-delay", opts.MaxDeferDelay, "maximum duration when deferring a message")
 
 	// client overridable configuration options
 	flagSet.Duration("max-heartbeat-interval", opts.MaxHeartbeatInterval, "maximum client configurable duration of time between client heartbeats")

nsqd/http.go

@@ -241,7 +241,7 @@ func (s *httpServer) doPUB(w http.ResponseWriter, req *http.Request, ps httprout
 			return nil, http_api.Err{400, "INVALID_DEFER"}
 		}
 		deferred = time.Duration(di) * time.Millisecond
-		if deferred < 0 || deferred > s.nsqd.getOpts().MaxReqTimeout {
+		if deferred < 0 || deferred > s.nsqd.getOpts().MaxDeferDelay {
 			return nil, http_api.Err{400, "INVALID_DEFER"}
 		}
 	}

nsqd/options.go

@@ -51,6 +51,7 @@ type Options struct {
 	MaxBodySize   int64         `flag:"max-body-size"`
 	MaxReqTimeout time.Duration `flag:"max-req-timeout"`
 	ClientTimeout time.Duration
+	MaxDeferDelay time.Duration `flag:"max-defer-delay"`
 
 	// client overridable configuration options
 	MaxHeartbeatInterval   time.Duration `flag:"max-heartbeat-interval"`
@@ -133,6 +134,7 @@ func NewOptions() *Options {
 		MaxBodySize:   5 * 1024 * 1024,
 		MaxReqTimeout: 1 * time.Hour,
 		ClientTimeout: 60 * time.Second,
+		MaxDeferDelay: 1 * time.Hour,
 
 		MaxHeartbeatInterval:   60 * time.Second,
 		MaxRdyCount:            2500,

nsqd/protocol_v2.go

@@ -878,17 +878,17 @@ func (p *protocolV2) DPUB(client *clientV2, params [][]byte) ([]byte, error) {
 			fmt.Sprintf("DPUB topic name %q is not valid", topicName))
 	}
 
-	timeoutMs, err := protocol.ByteToBase10(params[2])
+	delayMs, err := protocol.ByteToBase10(params[2])
 	if err != nil {
 		return nil, protocol.NewFatalClientErr(err, "E_INVALID",
-			fmt.Sprintf("DPUB could not parse timeout %s", params[2]))
+			fmt.Sprintf("DPUB could not parse defer delay %s", params[2]))
 	}
-	timeoutDuration := time.Duration(timeoutMs) * time.Millisecond
+	delayDuration := time.Duration(delayMs) * time.Millisecond
 
-	if timeoutDuration < 0 || timeoutDuration > p.nsqd.getOpts().MaxReqTimeout {
+	if delayDuration < 0 || delayDuration > p.nsqd.getOpts().MaxDeferDelay {
 		return nil, protocol.NewFatalClientErr(nil, "E_INVALID",
-			fmt.Sprintf("DPUB timeout %d out of range 0-%d",
-				timeoutMs, p.nsqd.getOpts().MaxReqTimeout/time.Millisecond))
+			fmt.Sprintf("DPUB defer delay %d out of range 0-%d",
+				delayMs, p.nsqd.getOpts().MaxDeferDelay/time.Millisecond))
 	}
 
 	bodyLen, err := readLen(client.Reader, client.lenSlice)
@@ -918,7 +918,7 @@ func (p *protocolV2) DPUB(client *clientV2, params [][]byte) ([]byte, error) {
 
 	topic := p.nsqd.GetTopic(topicName)
 	msg := NewMessage(topic.GenerateID(), messageBody)
-	msg.deferred = timeoutDuration
+	msg.deferred = delayDuration
 	err = topic.PutMessage(msg)
 	if err != nil {
 		return nil, protocol.NewFatalClientErr(err, "E_DPUB_FAILED", "DPUB failed "+err.Error())

nsqd/protocol_v2_test.go

@@ -596,12 +596,12 @@ func TestDPUB(t *testing.T) {
 	test.Equal(t, 1, int(atomic.LoadUint64(&ch.messageCount)))
 
 	// duration out of range
-	nsq.DeferredPublish(topicName, opts.MaxReqTimeout+100*time.Millisecond, make([]byte, 100)).WriteTo(conn)
+	nsq.DeferredPublish(topicName, opts.MaxDeferDelay+100*time.Millisecond, make([]byte, 100)).WriteTo(conn)
 	resp, _ = nsq.ReadResponse(conn)
 	frameType, data, _ = nsq.UnpackResponse(resp)
 	t.Logf("frameType: %d, data: %s", frameType, data)
 	test.Equal(t, frameTypeError, frameType)
-	test.Equal(t, "E_INVALID DPUB timeout 3600100 out of range 0-3600000", string(data))
+	test.Equal(t, "E_INVALID DPUB defer delay 3600100 out of range 0-3600000", string(data))
 }
 
 func TestTouch(t *testing.T) {

nsqd/protocol_v2_unixsocket_test.go

@@ -531,12 +531,12 @@ func TestUnixSocketDPUB(t *testing.T) {
 	test.Equal(t, 1, int(atomic.LoadUint64(&ch.messageCount)))
 
 	// duration out of range
-	nsq.DeferredPublish(topicName, opts.MaxReqTimeout+100*time.Millisecond, make([]byte, 100)).WriteTo(conn)
+	nsq.DeferredPublish(topicName, opts.MaxDeferDelay+100*time.Millisecond, make([]byte, 100)).WriteTo(conn)
 	resp, _ = nsq.ReadResponse(conn)
 	frameType, data, _ = nsq.UnpackResponse(resp)
 	t.Logf("frameType: %d, data: %s", frameType, data)
 	test.Equal(t, frameTypeError, frameType)
-	test.Equal(t, "E_INVALID DPUB timeout 3600100 out of range 0-3600000", string(data))
+	test.Equal(t, "E_INVALID DPUB defer delay 3600100 out of range 0-3600000", string(data))
 }
 
 func TestUnixSocketTouch(t *testing.T) {