func (p *ProtocolV2) REQ(client *ClientV2, params [][]byte) ([]byte, error) { state := atomic.LoadInt32(&client.State) if state != nsq.StateSubscribed && state != nsq.StateClosing { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot REQ in current state") } if len(params) < 3 { return nil, util.NewFatalClientErr(nil, "E_INVALID", "REQ insufficient number of params") } id := *(*nsq.MessageID)(unsafe.Pointer(¶ms[1][0])) timeoutMs, err := util.ByteToBase10(params[2]) if err != nil { return nil, util.NewFatalClientErr(err, "E_INVALID", fmt.Sprintf("REQ could not parse timeout %s", params[2])) } timeoutDuration := time.Duration(timeoutMs) * time.Millisecond if timeoutDuration < 0 || timeoutDuration > maxTimeout { return nil, util.NewFatalClientErr(nil, "E_INVALID", fmt.Sprintf("REQ timeout %d out of range 0-%d", timeoutDuration, maxTimeout)) } err = client.Channel.RequeueMessage(client.ID, id, timeoutDuration) if err != nil { return nil, util.NewClientErr(err, "E_REQ_FAILED", fmt.Sprintf("REQ %s failed %s", id, err.Error())) } client.RequeuedMessage() return nil, nil }
func (p *ProtocolV2) RDY(client *ClientV2, params [][]byte) ([]byte, error) { state := atomic.LoadInt32(&client.State) if state == nsq.StateClosing { // just ignore ready changes on a closing channel log.Printf("PROTOCOL(V2): [%s] ignoring RDY after CLS in state ClientStateV2Closing", client) return nil, nil } if state != nsq.StateSubscribed { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot RDY in current state") } count := int64(1) if len(params) > 1 { b10, err := util.ByteToBase10(params[1]) if err != nil { return nil, util.NewFatalClientErr(err, "E_INVALID", fmt.Sprintf("RDY could not parse count %s", params[1])) } count = int64(b10) } if count < 0 || count > p.context.nsqd.options.maxRdyCount { // this needs to be a fatal error otherwise clients would have // inconsistent state return nil, util.NewFatalClientErr(nil, "E_INVALID", fmt.Sprintf("RDY count %d out of range 0-%d", count, p.context.nsqd.options.maxRdyCount)) } client.SetReadyCount(count) return nil, nil }
func (p *ProtocolV2) Exec(client *ClientV2, params [][]byte) ([]byte, error) { switch { case bytes.Equal(params[0], []byte("FIN")): return p.FIN(client, params) case bytes.Equal(params[0], []byte("RDY")): return p.RDY(client, params) case bytes.Equal(params[0], []byte("REQ")): return p.REQ(client, params) case bytes.Equal(params[0], []byte("PUB")): return p.PUB(client, params) case bytes.Equal(params[0], []byte("MPUB")): return p.MPUB(client, params) case bytes.Equal(params[0], []byte("NOP")): return p.NOP(client, params) case bytes.Equal(params[0], []byte("TOUCH")): return p.TOUCH(client, params) case bytes.Equal(params[0], []byte("IDENTIFY")): return p.IDENTIFY(client, params) case bytes.Equal(params[0], []byte("SUB")): return p.SUB(client, params) case bytes.Equal(params[0], []byte("CLS")): return p.CLS(client, params) } return nil, util.NewFatalClientErr(nil, "E_INVALID", fmt.Sprintf("invalid command %s", params[0])) }
func (p *LookupProtocolV1) REGISTER(client *ClientV1, reader *bufio.Reader, params []string) ([]byte, error) { if client.peerInfo == nil { return nil, util.NewFatalClientErr(nil, "E_INVALID", "client must IDENTIFY") } topic, channel, err := getTopicChan("REGISTER", params) if err != nil { return nil, err } if channel != "" { key := Registration{"channel", topic, channel} if p.context.nsqlookupd.DB.AddProducer(key, &Producer{peerInfo: client.peerInfo}) { log.Printf("DB: client(%s) REGISTER category:%s key:%s subkey:%s", client, "channel", topic, channel) } } key := Registration{"topic", topic, ""} if p.context.nsqlookupd.DB.AddProducer(key, &Producer{peerInfo: client.peerInfo}) { log.Printf("DB: client(%s) REGISTER category:%s key:%s subkey:%s", client, "topic", topic, "") } return []byte("OK"), nil }
func (p *ProtocolV2) CLS(client *ClientV2, params [][]byte) ([]byte, error) { if atomic.LoadInt32(&client.State) != nsq.StateSubscribed { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot CLS in current state") } client.StartClose() return []byte("CLOSE_WAIT"), nil }
func (p *ProtocolV2) TOUCH(client *ClientV2, params [][]byte) ([]byte, error) { state := atomic.LoadInt32(&client.State) if state != nsq.StateSubscribed && state != nsq.StateClosing { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot TOUCH in current state") } if len(params) < 2 { return nil, util.NewFatalClientErr(nil, "E_INVALID", "TOUCH insufficient number of params") } id := *(*nsq.MessageID)(unsafe.Pointer(¶ms[1][0])) err := client.Channel.TouchMessage(client.ID, id) if err != nil { return nil, util.NewClientErr(err, "E_TOUCH_FAILED", fmt.Sprintf("TOUCH %s failed %s", id, err.Error())) } return nil, nil }
func getTopicChan(command string, params []string) (string, string, error) { if len(params) == 0 { return "", "", util.NewFatalClientErr(nil, "E_INVALID", fmt.Sprintf("%s insufficient number of params", command)) } topicName := params[0] var channelName string if len(params) >= 2 { channelName = params[1] } if !nsq.IsValidTopicName(topicName) { return "", "", util.NewFatalClientErr(nil, "E_BAD_TOPIC", fmt.Sprintf("%s topic name '%s' is not valid", command, topicName)) } if channelName != "" && !nsq.IsValidChannelName(channelName) { return "", "", util.NewFatalClientErr(nil, "E_BAD_CHANNEL", fmt.Sprintf("%s channel name '%s' is not valid", command, channelName)) } return topicName, channelName, nil }
func (p *LookupProtocolV1) Exec(client *ClientV1, reader *bufio.Reader, params []string) ([]byte, error) { switch params[0] { case "PING": return p.PING(client, params) case "IDENTIFY": return p.IDENTIFY(client, reader, params[1:]) case "REGISTER": return p.REGISTER(client, reader, params[1:]) case "UNREGISTER": return p.UNREGISTER(client, reader, params[1:]) } return nil, util.NewFatalClientErr(nil, "E_INVALID", fmt.Sprintf("invalid command %s", params[0])) }
func (p *ProtocolV2) SUB(client *ClientV2, params [][]byte) ([]byte, error) { if atomic.LoadInt32(&client.State) != nsq.StateInit { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot SUB in current state") } if client.HeartbeatInterval < 0 { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot SUB with heartbeats disabled") } if len(params) < 3 { return nil, util.NewFatalClientErr(nil, "E_INVALID", "SUB insufficient number of parameters") } topicName := string(params[1]) if !nsq.IsValidTopicName(topicName) { return nil, util.NewFatalClientErr(nil, "E_BAD_TOPIC", fmt.Sprintf("SUB topic name '%s' is not valid", topicName)) } channelName := string(params[2]) if !nsq.IsValidChannelName(channelName) { return nil, util.NewFatalClientErr(nil, "E_BAD_CHANNEL", fmt.Sprintf("SUB channel name '%s' is not valid", channelName)) } topic := p.context.nsqd.GetTopic(topicName) channel := topic.GetChannel(channelName) channel.AddClient(client.ID, client) atomic.StoreInt32(&client.State, nsq.StateSubscribed) client.Channel = channel // update message pump client.SubEventChan <- channel return okBytes, nil }
func (p *LookupProtocolV1) UNREGISTER(client *ClientV1, reader *bufio.Reader, params []string) ([]byte, error) { if client.peerInfo == nil { return nil, util.NewFatalClientErr(nil, "E_INVALID", "client must IDENTIFY") } topic, channel, err := getTopicChan("UNREGISTER", params) if err != nil { return nil, err } if channel != "" { key := Registration{"channel", topic, channel} removed, left := p.context.nsqlookupd.DB.RemoveProducer(key, client.peerInfo.id) if removed { log.Printf("DB: client(%s) UNREGISTER category:%s key:%s subkey:%s", client, "channel", topic, channel) } // for ephemeral channels, remove the channel as well if it has no producers if left == 0 && strings.HasSuffix(channel, "#ephemeral") { p.context.nsqlookupd.DB.RemoveRegistration(key) } } else { // no channel was specified so this is a topic unregistration // remove all of the channel registrations... // normally this shouldn't happen which is why we print a warning message // if anything is actually removed registrations := p.context.nsqlookupd.DB.FindRegistrations("channel", topic, "*") for _, r := range registrations { if removed, _ := p.context.nsqlookupd.DB.RemoveProducer(r, client.peerInfo.id); removed { log.Printf("WARNING: client(%s) unexpected UNREGISTER category:%s key:%s subkey:%s", client, "channel", topic, r.SubKey) } } key := Registration{"topic", topic, ""} if removed, _ := p.context.nsqlookupd.DB.RemoveProducer(key, client.peerInfo.id); removed { log.Printf("DB: client(%s) UNREGISTER category:%s key:%s subkey:%s", client, "topic", topic, "") } } return []byte("OK"), nil }
func (p *ProtocolV2) PUB(client *ClientV2, params [][]byte) ([]byte, error) { var err error if len(params) < 2 { return nil, util.NewFatalClientErr(nil, "E_INVALID", "PUB insufficient number of parameters") } topicName := string(params[1]) if !nsq.IsValidTopicName(topicName) { return nil, util.NewFatalClientErr(nil, "E_BAD_TOPIC", fmt.Sprintf("PUB topic name '%s' is not valid", topicName)) } bodyLen, err := readLen(client.Reader, client.lenSlice) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_MESSAGE", "PUB failed to read message body size") } if bodyLen <= 0 { return nil, util.NewFatalClientErr(nil, "E_BAD_MESSAGE", fmt.Sprintf("PUB invalid message body size %d", bodyLen)) } if int64(bodyLen) > p.context.nsqd.options.maxMessageSize { return nil, util.NewFatalClientErr(nil, "E_BAD_MESSAGE", fmt.Sprintf("PUB message too big %d > %d", bodyLen, p.context.nsqd.options.maxMessageSize)) } messageBody := make([]byte, bodyLen) _, err = io.ReadFull(client.Reader, messageBody) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_MESSAGE", "PUB failed to read message body") } topic := p.context.nsqd.GetTopic(topicName) msg := nsq.NewMessage(<-p.context.nsqd.idChan, messageBody) err = topic.PutMessage(msg) if err != nil { return nil, util.NewFatalClientErr(err, "E_PUB_FAILED", "PUB failed "+err.Error()) } return okBytes, nil }
func (p *ProtocolV2) MPUB(client *ClientV2, params [][]byte) ([]byte, error) { var err error if len(params) < 2 { return nil, util.NewFatalClientErr(nil, "E_INVALID", "MPUB insufficient number of parameters") } topicName := string(params[1]) if !nsq.IsValidTopicName(topicName) { return nil, util.NewFatalClientErr(nil, "E_BAD_TOPIC", fmt.Sprintf("E_BAD_TOPIC MPUB topic name '%s' is not valid", topicName)) } bodyLen, err := readLen(client.Reader, client.lenSlice) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "MPUB failed to read body size") } if bodyLen <= 0 { return nil, util.NewFatalClientErr(nil, "E_BAD_BODY", fmt.Sprintf("MPUB invalid body size %d", bodyLen)) } if int64(bodyLen) > p.context.nsqd.options.maxBodySize { return nil, util.NewFatalClientErr(nil, "E_BAD_BODY", fmt.Sprintf("MPUB body too big %d > %d", bodyLen, p.context.nsqd.options.maxBodySize)) } messages, err := readMPUB(client.Reader, client.lenSlice, p.context.nsqd.idChan, p.context.nsqd.options.maxMessageSize) if err != nil { return nil, err } topic := p.context.nsqd.GetTopic(topicName) // if we've made it this far we've validated all the input, // the only possible error is that the topic is exiting during // this next call (and no messages will be queued in that case) err = topic.PutMessages(messages) if err != nil { return nil, util.NewFatalClientErr(err, "E_MPUB_FAILED", "MPUB failed "+err.Error()) } return okBytes, nil }
func readMPUB(r io.Reader, tmp []byte, idChan chan nsq.MessageID, maxMessageSize int64) ([]*nsq.Message, error) { numMessages, err := readLen(r, tmp) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "MPUB failed to read message count") } if numMessages <= 0 { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", fmt.Sprintf("MPUB invalid message count %d", numMessages)) } messages := make([]*nsq.Message, 0, numMessages) for i := int32(0); i < numMessages; i++ { messageSize, err := readLen(r, tmp) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_MESSAGE", fmt.Sprintf("MPUB failed to read message(%d) body size", i)) } if messageSize <= 0 { return nil, util.NewFatalClientErr(nil, "E_BAD_MESSAGE", fmt.Sprintf("MPUB invalid message(%d) body size %d", i, messageSize)) } if int64(messageSize) > maxMessageSize { return nil, util.NewFatalClientErr(nil, "E_BAD_MESSAGE", fmt.Sprintf("MPUB message too big %d > %d", messageSize, maxMessageSize)) } msgBody := make([]byte, messageSize) _, err = io.ReadFull(r, msgBody) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_MESSAGE", "MPUB failed to read message body") } messages = append(messages, nsq.NewMessage(<-idChan, msgBody)) } return messages, nil }
func (p *ProtocolV2) IDENTIFY(client *ClientV2, params [][]byte) ([]byte, error) { var err error if atomic.LoadInt32(&client.State) != nsq.StateInit { return nil, util.NewFatalClientErr(nil, "E_INVALID", "cannot IDENTIFY in current state") } bodyLen, err := readLen(client.Reader, client.lenSlice) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY failed to read body size") } if int64(bodyLen) > p.context.nsqd.options.maxBodySize { return nil, util.NewFatalClientErr(nil, "E_BAD_BODY", fmt.Sprintf("IDENTIFY body too big %d > %d", bodyLen, p.context.nsqd.options.maxBodySize)) } body := make([]byte, bodyLen) _, err = io.ReadFull(client.Reader, body) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY failed to read body") } // body is a json structure with producer information fmt.Println(string(body)) var identifyData IdentifyDataV2 err = json.Unmarshal(body, &identifyData) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY failed to decode JSON body") } err = client.Identify(identifyData) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY "+err.Error()) } // bail out early if we're not negotiating features if !identifyData.FeatureNegotiation { return okBytes, nil } tlsv1 := p.context.nsqd.tlsConfig != nil && identifyData.TLSv1 deflate := p.context.nsqd.options.deflateEnabled && identifyData.Deflate deflateLevel := 0 if deflate { if identifyData.DeflateLevel <= 0 { deflateLevel = 6 } deflateLevel = int(math.Min(float64(deflateLevel), float64(p.context.nsqd.options.maxDeflateLevel))) } snappy := p.context.nsqd.options.snappyEnabled && identifyData.Snappy if deflate && snappy { return nil, util.NewFatalClientErr(nil, "E_IDENTIFY_FAILED", "cannot enable both deflate and snappy compression") } resp, err := json.Marshal(struct { MaxRdyCount int64 `json:"max_rdy_count"` Version string `json:"version"` MaxMsgTimeout int64 `json:"max_msg_timeout"` MsgTimeout int64 `json:"msg_timeout"` TLSv1 bool `json:"tls_v1"` Deflate bool `json:"deflate"` DeflateLevel int `json:"deflate_level"` MaxDeflateLevel int `json:"max_deflate_level"` Snappy bool `json:"snappy"` SampleRate int32 `json:"sample_rate"` }{ MaxRdyCount: p.context.nsqd.options.maxRdyCount, Version: util.BINARY_VERSION, MaxMsgTimeout: int64(p.context.nsqd.options.maxMsgTimeout / time.Millisecond), MsgTimeout: int64(p.context.nsqd.options.msgTimeout / time.Millisecond), TLSv1: tlsv1, Deflate: deflate, DeflateLevel: deflateLevel, MaxDeflateLevel: p.context.nsqd.options.maxDeflateLevel, Snappy: snappy, SampleRate: client.SampleRate, }) if err != nil { panic("should never happen") } err = p.Send(client, nsq.FrameTypeResponse, resp) if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } if tlsv1 { log.Printf("PROTOCOL(V2): [%s] upgrading connection to TLS", client) err = client.UpgradeTLS() if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } err = p.Send(client, nsq.FrameTypeResponse, okBytes) if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } } if snappy { log.Printf("PROTOCOL(V2): [%s] upgrading connection to snappy", client) err = client.UpgradeSnappy() if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } err = p.Send(client, nsq.FrameTypeResponse, okBytes) if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } } if deflate { log.Printf("PROTOCOL(V2): [%s] upgrading connection to deflate", client) err = client.UpgradeDeflate(deflateLevel) if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } err = p.Send(client, nsq.FrameTypeResponse, okBytes) if err != nil { return nil, util.NewFatalClientErr(err, "E_IDENTIFY_FAILED", "IDENTIFY failed "+err.Error()) } } return nil, nil }
func (p *LookupProtocolV1) IDENTIFY(client *ClientV1, reader *bufio.Reader, params []string) ([]byte, error) { var err error if client.peerInfo != nil { return nil, util.NewFatalClientErr(err, "E_INVALID", "cannot IDENTIFY again") } var bodyLen int32 err = binary.Read(reader, binary.BigEndian, &bodyLen) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY failed to read body size") } body := make([]byte, bodyLen) _, err = io.ReadFull(reader, body) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY failed to read body") } // body is a json structure with producer information peerInfo := PeerInfo{id: client.RemoteAddr().String()} err = json.Unmarshal(body, &peerInfo) if err != nil { return nil, util.NewFatalClientErr(err, "E_BAD_BODY", "IDENTIFY failed to decode JSON body") } peerInfo.RemoteAddress = client.RemoteAddr().String() //TODO: remove this check for 1.0 if peerInfo.BroadcastAddress == "" { peerInfo.BroadcastAddress = peerInfo.Address } // require all fields if peerInfo.BroadcastAddress == "" || peerInfo.TcpPort == 0 || peerInfo.HttpPort == 0 || peerInfo.Version == "" { return nil, util.NewFatalClientErr(nil, "E_BAD_BODY", "IDENTIFY missing fields") } peerInfo.lastUpdate = time.Now() log.Printf("CLIENT(%s): IDENTIFY Address:%s TCP:%d HTTP:%d Version:%s", client, peerInfo.BroadcastAddress, peerInfo.TcpPort, peerInfo.HttpPort, peerInfo.Version) client.peerInfo = &peerInfo if p.context.nsqlookupd.DB.AddProducer(Registration{"client", "", ""}, &Producer{peerInfo: client.peerInfo}) { log.Printf("DB: client(%s) REGISTER category:%s key:%s subkey:%s", client, "client", "", "") } // build a response data := make(map[string]interface{}) data["tcp_port"] = p.context.nsqlookupd.tcpAddr.Port data["http_port"] = p.context.nsqlookupd.httpAddr.Port data["version"] = util.BINARY_VERSION hostname, err := os.Hostname() if err != nil { log.Fatalf("ERROR: unable to get hostname %s", err.Error()) } data["address"] = hostname //TODO: remove for 1.0 data["broadcast_address"] = p.context.nsqlookupd.broadcastAddress data["hostname"] = hostname response, err := json.Marshal(data) if err != nil { log.Printf("ERROR: marshaling %v", data) return []byte("OK"), nil } return response, nil }