diff --git a/README.md b/README.md index 7a75e3a..37591f0 100644 --- a/README.md +++ b/README.md @@ -58,15 +58,13 @@ The `record` object must be a `map` or `struct`. Objects that implement the [`ms record := map[string]interface{}{ "Hello": "World", } -msg := protocol.NewMessage("tag", record) -err := c.Send(msg) +err := c.SendMessage("tag", record) ``` ### Send a byte-encoded message ```go -raw := protocol.RawMessage(myMessageBytes) -err := c.Send(raw) +err := c.SendRaw(myMessageBytes) ``` ### Message confirmation diff --git a/cmd/forward/main.go b/cmd/forward/main.go index 5a7be05..a281ed7 100644 --- a/cmd/forward/main.go +++ b/cmd/forward/main.go @@ -85,48 +85,31 @@ func main() { }, } - msg := protocol.NewMessage(tagVar, record) - mne := protocol.NewMessageExt(tagVar, record) - fwd := protocol.NewForwardMessage(tagVar, entries) - packedFwd, _ := protocol.NewPackedForwardMessage(tagVar+".packed", entries) - compressed, _ := protocol.NewCompressedPackedForwardMessage(tagVar+".compressed", - fwd.Entries) - - err = c.Send(msg) + err = c.SendMessage(tagVar, record) if err != nil { fmt.Println(err) os.Exit(1) } - err = c.Send(mne) + err = c.SendMessageExt(tagVar, record) if err != nil { fmt.Println(err) os.Exit(1) } - err = c.Send(fwd) + err = c.SendForward(tagVar, entries) if err != nil { fmt.Println(err) os.Exit(1) } - err = c.Send(packedFwd) + err = c.SendPacked(tagVar+".packed", entries) if err != nil { fmt.Println(err) os.Exit(1) } - err = c.Send(compressed) - if err != nil { - fmt.Println(err) - os.Exit(1) - } - - _, _ = compressed.Chunk() - b, _ := compressed.MarshalMsg(nil) - rm := protocol.RawMessage(b) - - err = c.Send(rm) + err = c.SendCompressed(tagVar+".compressed", entries) if err != nil { fmt.Println(err) os.Exit(1) diff --git a/fluent/client/client.go b/fluent/client/client.go index 0db579c..26e09e4 100644 --- a/fluent/client/client.go +++ b/fluent/client/client.go @@ -51,6 +51,13 @@ type MessageClient interface { Disconnect() (err error) Reconnect() error Send(e protocol.ChunkEncoder) error + SendCompressed(tag string, entries protocol.EntryList) error + SendCompressedFromBytes(tag string, entries []byte) error + SendForward(tag string, entries protocol.EntryList) error + SendMessage(tag string, record interface{}) error + SendMessageExt(tag string, record interface{}) error + SendPacked(tag string, entries protocol.EntryList) error + SendPackedFromBytes(tag string, entries []byte) error SendRaw(raw []byte) error } @@ -140,6 +147,62 @@ func (c *Client) connect() error { return nil } +// Handshake initiates handshake mode. Users must call this before attempting +// to send any messages when the server is configured with a shared key, otherwise +// the server will reject any message events. Successful completion of the +// handshake puts the connection into message (or forward) mode, at which time +// the client is free to send event messages. +func (c *Client) Handshake() error { + c.sessionLock.RLock() + defer c.sessionLock.RUnlock() + + if c.session == nil { + return errors.New("not connected") + } + + var helo protocol.Helo + + r := msgp.NewReader(c.session.Connection) + err := helo.DecodeMsg(r) + + if err != nil { + return err + } + + salt := make([]byte, 16) + + _, err = rand.Read(salt) + if err != nil { + return err + } + + ping, err := protocol.NewPing(c.Hostname, c.AuthInfo.SharedKey, salt, helo.Options.Nonce) + if err != nil { + return err + } + + err = msgp.Encode(c.session.Connection, ping) + if err != nil { + return err + } + + var pong protocol.Pong + + err = pong.DecodeMsg(r) + if err != nil { + return err + } + + if err := protocol.ValidatePongDigest(&pong, c.AuthInfo.SharedKey, + helo.Options.Nonce, salt); err != nil { + return err + } + + c.session.TransportPhase = true + + return nil +} + // Connect initializes the Session and Connection objects by opening // a client connect to the target configured in the ConnectionFactory func (c *Client) Connect() error { @@ -239,61 +302,69 @@ func (c *Client) Send(e protocol.ChunkEncoder) error { // is not yet in transport phase, an error is returned, // and no message is sent. func (c *Client) SendRaw(m []byte) error { - return c.Send(protocol.RawMessage(m)) -} - -// Handshake initiates handshake mode. Users must call this before attempting -// to send any messages when the server is configured with a shared key, otherwise -// the server will reject any message events. Successful completion of the -// handshake puts the connection into message (or forward) mode, at which time -// the client is free to send event messages. -func (c *Client) Handshake() error { c.sessionLock.RLock() defer c.sessionLock.RUnlock() if c.session == nil { - return errors.New("not connected") + return errors.New("no active session") } - var helo protocol.Helo + if !c.session.TransportPhase { + return errors.New("session handshake not completed") + } - r := msgp.NewReader(c.session.Connection) - err := helo.DecodeMsg(r) + _, err := c.session.Connection.Write(m) - if err != nil { - return err + return err +} + +func (c *Client) SendPacked(tag string, entries protocol.EntryList) error { + msg, err := protocol.NewPackedForwardMessage(tag, entries) + if err == nil { + err = c.Send(msg) } - salt := make([]byte, 16) + return err +} - _, err = rand.Read(salt) - if err != nil { - return err - } +func (c *Client) SendPackedFromBytes(tag string, entries []byte) error { + msg := protocol.NewPackedForwardMessageFromBytes(tag, entries) - ping, err := protocol.NewPing(c.Hostname, c.AuthInfo.SharedKey, salt, helo.Options.Nonce) - if err != nil { - return err - } + return c.Send(msg) +} - err = msgp.Encode(c.session.Connection, ping) - if err != nil { - return err - } +func (c *Client) SendMessage(tag string, record interface{}) error { + msg := protocol.NewMessage(tag, record) - var pong protocol.Pong + return c.Send(msg) +} - err = pong.DecodeMsg(r) - if err != nil { - return err - } +func (c *Client) SendMessageExt(tag string, record interface{}) error { + msg := protocol.NewMessageExt(tag, record) - if err := protocol.ValidatePongDigest(&pong, c.AuthInfo.SharedKey, - helo.Options.Nonce, salt); err != nil { - return err + return c.Send(msg) +} + +func (c *Client) SendForward(tag string, entries protocol.EntryList) error { + msg := protocol.NewForwardMessage(tag, entries) + + return c.Send(msg) +} + +func (c *Client) SendCompressed(tag string, entries protocol.EntryList) error { + msg, err := protocol.NewCompressedPackedForwardMessage(tag, entries) + if err == nil { + err = c.Send(msg) } - c.session.TransportPhase = true + return err +} - return nil +func (c *Client) SendCompressedFromBytes(tag string, entries []byte) error { + msg, err := protocol.NewCompressedPackedForwardMessageFromBytes(tag, entries) + if err == nil { + err = c.Send(msg) + } + + return err } diff --git a/fluent/client/client_test.go b/fluent/client/client_test.go index 5aa5721..ab981c9 100644 --- a/fluent/client/client_test.go +++ b/fluent/client/client_test.go @@ -258,24 +258,48 @@ var _ = Describe("Client", func() { <-done }) }) - }) - Describe("SendRaw", func() { + Describe("Send*", func() { + type msgSender struct { + tag string + doSend func() error + decoder msgp.Decodable + } var ( serverSide net.Conn msg protocol.MessageExt bits []byte + el protocol.EntryList ) BeforeEach(func() { clientSide, serverSide = net.Pipe() + msg = protocol.MessageExt{ - Tag: "foo.bar", + Record: map[string]string{ + "a": "b", + }, + Tag: "msg", } var err error bits, err = msg.MarshalMsg(nil) Expect(err).NotTo(HaveOccurred()) + + el = protocol.EntryList{ + { + Record: map[string]interface{}{ + "foo": "bar", + "george": "jungle", + }, + }, + { + Record: map[string]interface{}{ + "foo": "kablooie", + "george": "frank", + }, + }, + } }) JustBeforeEach(func() { @@ -283,33 +307,127 @@ var _ = Describe("Client", func() { Expect(err).NotTo(HaveOccurred()) }) - It("Sends the message", func() { + doTest := func(sndr msgSender) { c := make(chan bool, 1) go func() { defer GinkgoRecover() c <- true - err := client.SendRaw(bits) + err := sndr.doSend() Expect(err).NotTo(HaveOccurred()) }() - var recvd protocol.MessageExt <-c - err := recvd.DecodeMsg(msgp.NewReader(serverSide)) + err := sndr.decoder.DecodeMsg(msgp.NewReader(serverSide)) Expect(err).NotTo(HaveOccurred()) - Expect(recvd.Tag).To(Equal(msg.Tag)) + val := reflect.Indirect(reflect.ValueOf(sndr.decoder)) + Expect(val.FieldByName("Tag").String()).To(Equal(sndr.tag)) + } + + Context("SendForward", func() { + It("works", func() { + doTest(msgSender{ + tag: "fwd", + decoder: &protocol.ForwardMessage{}, + doSend: func() error { + return client.SendForward("fwd", el) + }, + }) + }) }) - Context("When the Session is not yet in Transport phase (handshake not performed)", func() { - JustBeforeEach(func() { - client.Disconnect() + Context("SendCompressed", func() { + It("works", func() { + doTest(msgSender{ + tag: "cmp", + decoder: &protocol.PackedForwardMessage{}, + doSend: func() error { + return client.SendCompressed("cmp", el) + }, + }) }) + }) - It("Returns an error", func() { - Expect(client.Send(&msg)).To(HaveOccurred()) + Context("SendCompressedFromBytes", func() { + It("works", func() { + doTest(msgSender{ + tag: "cmpfb", + decoder: &protocol.PackedForwardMessage{}, + doSend: func() error { + return client.SendCompressedFromBytes("cmpfb", bits) + }, + }) }) + }) - // TODO: We need a test that no message is sent + Context("SendMessage", func() { + It("works", func() { + doTest(msgSender{ + tag: "sm", + decoder: &protocol.Message{}, + doSend: func() error { + return client.SendMessage("sm", el[0].Record) + }, + }) + }) + }) + + Context("SendMessageExt", func() { + It("works", func() { + doTest(msgSender{ + tag: "ext", + decoder: &protocol.MessageExt{}, + doSend: func() error { + return client.SendMessageExt("ext", el[1].Record) + }, + }) + }) + }) + + Context("SendPacked", func() { + It("works", func() { + doTest(msgSender{ + tag: "pkd", + decoder: &protocol.PackedForwardMessage{}, + doSend: func() error { + return client.SendPacked("pkd", el) + }, + }) + }) + }) + + Context("SendPackedFromBytes", func() { + It("works", func() { + doTest(msgSender{ + tag: "pkdfb", + decoder: &protocol.PackedForwardMessage{}, + doSend: func() error { + return client.SendPackedFromBytes("pkdfb", bits) + }, + }) + }) + }) + + Context("SendRaw", func() { + It("works", func() { + doTest(msgSender{ + tag: "msg", + decoder: &protocol.MessageExt{}, + doSend: func() error { + return client.SendRaw(bits) + }, + }) + }) + + Context("When the Session is not yet in Transport phase (handshake not performed)", func() { + JustBeforeEach(func() { + client.Disconnect() + }) + + It("Returns an error", func() { + Expect(client.SendRaw(bits)).To(HaveOccurred()) + }) + }) }) }) diff --git a/fluent/client/clientfakes/fake_message_client.go b/fluent/client/clientfakes/fake_message_client.go index 22fa1e6..be0f9c2 100644 --- a/fluent/client/clientfakes/fake_message_client.go +++ b/fluent/client/clientfakes/fake_message_client.go @@ -39,10 +39,58 @@ type FakeMessageClient struct { reconnectReturnsOnCall map[int]struct { result1 error } - SendMessageStub func(protocol.ChunkEncoder) error + SendStub func(protocol.ChunkEncoder) error + sendMutex sync.RWMutex + sendArgsForCall []struct { + arg1 protocol.ChunkEncoder + } + sendReturns struct { + result1 error + } + sendReturnsOnCall map[int]struct { + result1 error + } + SendCompressedStub func(string, protocol.EntryList) error + sendCompressedMutex sync.RWMutex + sendCompressedArgsForCall []struct { + arg1 string + arg2 protocol.EntryList + } + sendCompressedReturns struct { + result1 error + } + sendCompressedReturnsOnCall map[int]struct { + result1 error + } + SendCompressedFromBytesStub func(string, []byte) error + sendCompressedFromBytesMutex sync.RWMutex + sendCompressedFromBytesArgsForCall []struct { + arg1 string + arg2 []byte + } + sendCompressedFromBytesReturns struct { + result1 error + } + sendCompressedFromBytesReturnsOnCall map[int]struct { + result1 error + } + SendForwardStub func(string, protocol.EntryList) error + sendForwardMutex sync.RWMutex + sendForwardArgsForCall []struct { + arg1 string + arg2 protocol.EntryList + } + sendForwardReturns struct { + result1 error + } + sendForwardReturnsOnCall map[int]struct { + result1 error + } + SendMessageStub func(string, interface{}) error sendMessageMutex sync.RWMutex sendMessageArgsForCall []struct { - arg1 protocol.ChunkEncoder + arg1 string + arg2 interface{} } sendMessageReturns struct { result1 error @@ -50,6 +98,42 @@ type FakeMessageClient struct { sendMessageReturnsOnCall map[int]struct { result1 error } + SendMessageExtStub func(string, interface{}) error + sendMessageExtMutex sync.RWMutex + sendMessageExtArgsForCall []struct { + arg1 string + arg2 interface{} + } + sendMessageExtReturns struct { + result1 error + } + sendMessageExtReturnsOnCall map[int]struct { + result1 error + } + SendPackedStub func(string, protocol.EntryList) error + sendPackedMutex sync.RWMutex + sendPackedArgsForCall []struct { + arg1 string + arg2 protocol.EntryList + } + sendPackedReturns struct { + result1 error + } + sendPackedReturnsOnCall map[int]struct { + result1 error + } + SendPackedFromBytesStub func(string, []byte) error + sendPackedFromBytesMutex sync.RWMutex + sendPackedFromBytesArgsForCall []struct { + arg1 string + arg2 []byte + } + sendPackedFromBytesReturns struct { + result1 error + } + sendPackedFromBytesReturnsOnCall map[int]struct { + result1 error + } SendRawStub func([]byte) error sendRawMutex sync.RWMutex sendRawArgsForCall []struct { @@ -225,17 +309,270 @@ func (fake *FakeMessageClient) ReconnectReturnsOnCall(i int, result1 error) { } func (fake *FakeMessageClient) Send(arg1 protocol.ChunkEncoder) error { + fake.sendMutex.Lock() + ret, specificReturn := fake.sendReturnsOnCall[len(fake.sendArgsForCall)] + fake.sendArgsForCall = append(fake.sendArgsForCall, struct { + arg1 protocol.ChunkEncoder + }{arg1}) + stub := fake.SendStub + fakeReturns := fake.sendReturns + fake.recordInvocation("Send", []interface{}{arg1}) + fake.sendMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendCallCount() int { + fake.sendMutex.RLock() + defer fake.sendMutex.RUnlock() + return len(fake.sendArgsForCall) +} + +func (fake *FakeMessageClient) SendCalls(stub func(protocol.ChunkEncoder) error) { + fake.sendMutex.Lock() + defer fake.sendMutex.Unlock() + fake.SendStub = stub +} + +func (fake *FakeMessageClient) SendArgsForCall(i int) protocol.ChunkEncoder { + fake.sendMutex.RLock() + defer fake.sendMutex.RUnlock() + argsForCall := fake.sendArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeMessageClient) SendReturns(result1 error) { + fake.sendMutex.Lock() + defer fake.sendMutex.Unlock() + fake.SendStub = nil + fake.sendReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendReturnsOnCall(i int, result1 error) { + fake.sendMutex.Lock() + defer fake.sendMutex.Unlock() + fake.SendStub = nil + if fake.sendReturnsOnCall == nil { + fake.sendReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendCompressed(arg1 string, arg2 protocol.EntryList) error { + fake.sendCompressedMutex.Lock() + ret, specificReturn := fake.sendCompressedReturnsOnCall[len(fake.sendCompressedArgsForCall)] + fake.sendCompressedArgsForCall = append(fake.sendCompressedArgsForCall, struct { + arg1 string + arg2 protocol.EntryList + }{arg1, arg2}) + stub := fake.SendCompressedStub + fakeReturns := fake.sendCompressedReturns + fake.recordInvocation("SendCompressed", []interface{}{arg1, arg2}) + fake.sendCompressedMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendCompressedCallCount() int { + fake.sendCompressedMutex.RLock() + defer fake.sendCompressedMutex.RUnlock() + return len(fake.sendCompressedArgsForCall) +} + +func (fake *FakeMessageClient) SendCompressedCalls(stub func(string, protocol.EntryList) error) { + fake.sendCompressedMutex.Lock() + defer fake.sendCompressedMutex.Unlock() + fake.SendCompressedStub = stub +} + +func (fake *FakeMessageClient) SendCompressedArgsForCall(i int) (string, protocol.EntryList) { + fake.sendCompressedMutex.RLock() + defer fake.sendCompressedMutex.RUnlock() + argsForCall := fake.sendCompressedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeMessageClient) SendCompressedReturns(result1 error) { + fake.sendCompressedMutex.Lock() + defer fake.sendCompressedMutex.Unlock() + fake.SendCompressedStub = nil + fake.sendCompressedReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendCompressedReturnsOnCall(i int, result1 error) { + fake.sendCompressedMutex.Lock() + defer fake.sendCompressedMutex.Unlock() + fake.SendCompressedStub = nil + if fake.sendCompressedReturnsOnCall == nil { + fake.sendCompressedReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendCompressedReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendCompressedFromBytes(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.sendCompressedFromBytesMutex.Lock() + ret, specificReturn := fake.sendCompressedFromBytesReturnsOnCall[len(fake.sendCompressedFromBytesArgsForCall)] + fake.sendCompressedFromBytesArgsForCall = append(fake.sendCompressedFromBytesArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + stub := fake.SendCompressedFromBytesStub + fakeReturns := fake.sendCompressedFromBytesReturns + fake.recordInvocation("SendCompressedFromBytes", []interface{}{arg1, arg2Copy}) + fake.sendCompressedFromBytesMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendCompressedFromBytesCallCount() int { + fake.sendCompressedFromBytesMutex.RLock() + defer fake.sendCompressedFromBytesMutex.RUnlock() + return len(fake.sendCompressedFromBytesArgsForCall) +} + +func (fake *FakeMessageClient) SendCompressedFromBytesCalls(stub func(string, []byte) error) { + fake.sendCompressedFromBytesMutex.Lock() + defer fake.sendCompressedFromBytesMutex.Unlock() + fake.SendCompressedFromBytesStub = stub +} + +func (fake *FakeMessageClient) SendCompressedFromBytesArgsForCall(i int) (string, []byte) { + fake.sendCompressedFromBytesMutex.RLock() + defer fake.sendCompressedFromBytesMutex.RUnlock() + argsForCall := fake.sendCompressedFromBytesArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeMessageClient) SendCompressedFromBytesReturns(result1 error) { + fake.sendCompressedFromBytesMutex.Lock() + defer fake.sendCompressedFromBytesMutex.Unlock() + fake.SendCompressedFromBytesStub = nil + fake.sendCompressedFromBytesReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendCompressedFromBytesReturnsOnCall(i int, result1 error) { + fake.sendCompressedFromBytesMutex.Lock() + defer fake.sendCompressedFromBytesMutex.Unlock() + fake.SendCompressedFromBytesStub = nil + if fake.sendCompressedFromBytesReturnsOnCall == nil { + fake.sendCompressedFromBytesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendCompressedFromBytesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendForward(arg1 string, arg2 protocol.EntryList) error { + fake.sendForwardMutex.Lock() + ret, specificReturn := fake.sendForwardReturnsOnCall[len(fake.sendForwardArgsForCall)] + fake.sendForwardArgsForCall = append(fake.sendForwardArgsForCall, struct { + arg1 string + arg2 protocol.EntryList + }{arg1, arg2}) + stub := fake.SendForwardStub + fakeReturns := fake.sendForwardReturns + fake.recordInvocation("SendForward", []interface{}{arg1, arg2}) + fake.sendForwardMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendForwardCallCount() int { + fake.sendForwardMutex.RLock() + defer fake.sendForwardMutex.RUnlock() + return len(fake.sendForwardArgsForCall) +} + +func (fake *FakeMessageClient) SendForwardCalls(stub func(string, protocol.EntryList) error) { + fake.sendForwardMutex.Lock() + defer fake.sendForwardMutex.Unlock() + fake.SendForwardStub = stub +} + +func (fake *FakeMessageClient) SendForwardArgsForCall(i int) (string, protocol.EntryList) { + fake.sendForwardMutex.RLock() + defer fake.sendForwardMutex.RUnlock() + argsForCall := fake.sendForwardArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeMessageClient) SendForwardReturns(result1 error) { + fake.sendForwardMutex.Lock() + defer fake.sendForwardMutex.Unlock() + fake.SendForwardStub = nil + fake.sendForwardReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendForwardReturnsOnCall(i int, result1 error) { + fake.sendForwardMutex.Lock() + defer fake.sendForwardMutex.Unlock() + fake.SendForwardStub = nil + if fake.sendForwardReturnsOnCall == nil { + fake.sendForwardReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendForwardReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendMessage(arg1 string, arg2 interface{}) error { fake.sendMessageMutex.Lock() ret, specificReturn := fake.sendMessageReturnsOnCall[len(fake.sendMessageArgsForCall)] fake.sendMessageArgsForCall = append(fake.sendMessageArgsForCall, struct { - arg1 protocol.ChunkEncoder - }{arg1}) + arg1 string + arg2 interface{} + }{arg1, arg2}) stub := fake.SendMessageStub fakeReturns := fake.sendMessageReturns - fake.recordInvocation("Send", []interface{}{arg1}) + fake.recordInvocation("SendMessage", []interface{}{arg1, arg2}) fake.sendMessageMutex.Unlock() if stub != nil { - return stub(arg1) + return stub(arg1, arg2) } if specificReturn { return ret.result1 @@ -249,17 +586,17 @@ func (fake *FakeMessageClient) SendMessageCallCount() int { return len(fake.sendMessageArgsForCall) } -func (fake *FakeMessageClient) SendMessageCalls(stub func(protocol.ChunkEncoder) error) { +func (fake *FakeMessageClient) SendMessageCalls(stub func(string, interface{}) error) { fake.sendMessageMutex.Lock() defer fake.sendMessageMutex.Unlock() fake.SendMessageStub = stub } -func (fake *FakeMessageClient) SendMessageArgsForCall(i int) protocol.ChunkEncoder { +func (fake *FakeMessageClient) SendMessageArgsForCall(i int) (string, interface{}) { fake.sendMessageMutex.RLock() defer fake.sendMessageMutex.RUnlock() argsForCall := fake.sendMessageArgsForCall[i] - return argsForCall.arg1 + return argsForCall.arg1, argsForCall.arg2 } func (fake *FakeMessageClient) SendMessageReturns(result1 error) { @@ -285,6 +622,197 @@ func (fake *FakeMessageClient) SendMessageReturnsOnCall(i int, result1 error) { }{result1} } +func (fake *FakeMessageClient) SendMessageExt(arg1 string, arg2 interface{}) error { + fake.sendMessageExtMutex.Lock() + ret, specificReturn := fake.sendMessageExtReturnsOnCall[len(fake.sendMessageExtArgsForCall)] + fake.sendMessageExtArgsForCall = append(fake.sendMessageExtArgsForCall, struct { + arg1 string + arg2 interface{} + }{arg1, arg2}) + stub := fake.SendMessageExtStub + fakeReturns := fake.sendMessageExtReturns + fake.recordInvocation("SendMessageExt", []interface{}{arg1, arg2}) + fake.sendMessageExtMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendMessageExtCallCount() int { + fake.sendMessageExtMutex.RLock() + defer fake.sendMessageExtMutex.RUnlock() + return len(fake.sendMessageExtArgsForCall) +} + +func (fake *FakeMessageClient) SendMessageExtCalls(stub func(string, interface{}) error) { + fake.sendMessageExtMutex.Lock() + defer fake.sendMessageExtMutex.Unlock() + fake.SendMessageExtStub = stub +} + +func (fake *FakeMessageClient) SendMessageExtArgsForCall(i int) (string, interface{}) { + fake.sendMessageExtMutex.RLock() + defer fake.sendMessageExtMutex.RUnlock() + argsForCall := fake.sendMessageExtArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeMessageClient) SendMessageExtReturns(result1 error) { + fake.sendMessageExtMutex.Lock() + defer fake.sendMessageExtMutex.Unlock() + fake.SendMessageExtStub = nil + fake.sendMessageExtReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendMessageExtReturnsOnCall(i int, result1 error) { + fake.sendMessageExtMutex.Lock() + defer fake.sendMessageExtMutex.Unlock() + fake.SendMessageExtStub = nil + if fake.sendMessageExtReturnsOnCall == nil { + fake.sendMessageExtReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendMessageExtReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendPacked(arg1 string, arg2 protocol.EntryList) error { + fake.sendPackedMutex.Lock() + ret, specificReturn := fake.sendPackedReturnsOnCall[len(fake.sendPackedArgsForCall)] + fake.sendPackedArgsForCall = append(fake.sendPackedArgsForCall, struct { + arg1 string + arg2 protocol.EntryList + }{arg1, arg2}) + stub := fake.SendPackedStub + fakeReturns := fake.sendPackedReturns + fake.recordInvocation("SendPacked", []interface{}{arg1, arg2}) + fake.sendPackedMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendPackedCallCount() int { + fake.sendPackedMutex.RLock() + defer fake.sendPackedMutex.RUnlock() + return len(fake.sendPackedArgsForCall) +} + +func (fake *FakeMessageClient) SendPackedCalls(stub func(string, protocol.EntryList) error) { + fake.sendPackedMutex.Lock() + defer fake.sendPackedMutex.Unlock() + fake.SendPackedStub = stub +} + +func (fake *FakeMessageClient) SendPackedArgsForCall(i int) (string, protocol.EntryList) { + fake.sendPackedMutex.RLock() + defer fake.sendPackedMutex.RUnlock() + argsForCall := fake.sendPackedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeMessageClient) SendPackedReturns(result1 error) { + fake.sendPackedMutex.Lock() + defer fake.sendPackedMutex.Unlock() + fake.SendPackedStub = nil + fake.sendPackedReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendPackedReturnsOnCall(i int, result1 error) { + fake.sendPackedMutex.Lock() + defer fake.sendPackedMutex.Unlock() + fake.SendPackedStub = nil + if fake.sendPackedReturnsOnCall == nil { + fake.sendPackedReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendPackedReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendPackedFromBytes(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.sendPackedFromBytesMutex.Lock() + ret, specificReturn := fake.sendPackedFromBytesReturnsOnCall[len(fake.sendPackedFromBytesArgsForCall)] + fake.sendPackedFromBytesArgsForCall = append(fake.sendPackedFromBytesArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + stub := fake.SendPackedFromBytesStub + fakeReturns := fake.sendPackedFromBytesReturns + fake.recordInvocation("SendPackedFromBytes", []interface{}{arg1, arg2Copy}) + fake.sendPackedFromBytesMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMessageClient) SendPackedFromBytesCallCount() int { + fake.sendPackedFromBytesMutex.RLock() + defer fake.sendPackedFromBytesMutex.RUnlock() + return len(fake.sendPackedFromBytesArgsForCall) +} + +func (fake *FakeMessageClient) SendPackedFromBytesCalls(stub func(string, []byte) error) { + fake.sendPackedFromBytesMutex.Lock() + defer fake.sendPackedFromBytesMutex.Unlock() + fake.SendPackedFromBytesStub = stub +} + +func (fake *FakeMessageClient) SendPackedFromBytesArgsForCall(i int) (string, []byte) { + fake.sendPackedFromBytesMutex.RLock() + defer fake.sendPackedFromBytesMutex.RUnlock() + argsForCall := fake.sendPackedFromBytesArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeMessageClient) SendPackedFromBytesReturns(result1 error) { + fake.sendPackedFromBytesMutex.Lock() + defer fake.sendPackedFromBytesMutex.Unlock() + fake.SendPackedFromBytesStub = nil + fake.sendPackedFromBytesReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeMessageClient) SendPackedFromBytesReturnsOnCall(i int, result1 error) { + fake.sendPackedFromBytesMutex.Lock() + defer fake.sendPackedFromBytesMutex.Unlock() + fake.SendPackedFromBytesStub = nil + if fake.sendPackedFromBytesReturnsOnCall == nil { + fake.sendPackedFromBytesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendPackedFromBytesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + func (fake *FakeMessageClient) SendRaw(arg1 []byte) error { var arg1Copy []byte if arg1 != nil { @@ -360,8 +888,22 @@ func (fake *FakeMessageClient) Invocations() map[string][][]interface{} { defer fake.disconnectMutex.RUnlock() fake.reconnectMutex.RLock() defer fake.reconnectMutex.RUnlock() + fake.sendMutex.RLock() + defer fake.sendMutex.RUnlock() + fake.sendCompressedMutex.RLock() + defer fake.sendCompressedMutex.RUnlock() + fake.sendCompressedFromBytesMutex.RLock() + defer fake.sendCompressedFromBytesMutex.RUnlock() + fake.sendForwardMutex.RLock() + defer fake.sendForwardMutex.RUnlock() fake.sendMessageMutex.RLock() defer fake.sendMessageMutex.RUnlock() + fake.sendMessageExtMutex.RLock() + defer fake.sendMessageExtMutex.RUnlock() + fake.sendPackedMutex.RLock() + defer fake.sendPackedMutex.RUnlock() + fake.sendPackedFromBytesMutex.RLock() + defer fake.sendPackedFromBytesMutex.RUnlock() fake.sendRawMutex.RLock() defer fake.sendRawMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} diff --git a/go.mod b/go.mod index 7aa1fb8..f3601a5 100644 --- a/go.mod +++ b/go.mod @@ -5,17 +5,18 @@ go 1.16 require ( github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect github.com/fluent/fluent-logger-golang v1.8.0 + github.com/fsnotify/fsnotify v1.5.4 // indirect github.com/google/uuid v1.3.0 github.com/gorilla/mux v1.8.0 github.com/gorilla/websocket v1.4.2 github.com/kr/pretty v0.3.0 // indirect - github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect - github.com/onsi/ginkgo v1.16.4 - github.com/onsi/gomega v1.13.0 + github.com/onsi/ginkgo v1.16.5 + github.com/onsi/gomega v1.19.0 github.com/stretchr/testify v1.7.0 github.com/tinylib/msgp v1.1.6 - golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c // indirect - gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect + golang.org/x/net v0.0.0-20220622184535-263ec571b305 // indirect + golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 // indirect + gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect ) replace gopkg.in/yaml.v3 => gopkg.in/yaml.v3 v3.0.0 diff --git a/go.sum b/go.sum index cf1514c..6787ac7 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,8 @@ github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY= github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= @@ -7,8 +10,9 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/fluent/fluent-logger-golang v1.8.0 h1:K/fUDqUAItNcdf/Rq7aA2d1apwqsNgNzzInlXZTwK28= github.com/fluent/fluent-logger-golang v1.8.0/go.mod h1:2/HCT/jTy78yGyeNGQLGQsjF3zzzAuy6Xlk6FCMV5eU= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI= +github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= @@ -24,6 +28,7 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= @@ -31,27 +36,30 @@ github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB7 github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= -github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= -github.com/onsi/ginkgo v1.16.2/go.mod h1:CObGmKUOKaSC0RjmoAK7tKyn4Azo5P2IWuoMnvwxz1E= -github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= +github.com/onsi/ginkgo/v2 v2.1.3 h1:e/3Cwtogj0HA+25nMP1jCMDIf8RtRYbGwGGuBIFztkc= +github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/onsi/gomega v1.13.0 h1:7lLHu94wT9Ij0o6EWWclhu0aOh32VxhkwEJvzuWPeak= -github.com/onsi/gomega v1.13.0/go.mod h1:lRk9szgn8TxENtWd0Tp4c3wjlRfMTMH27I+3Je41yGY= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= +github.com/onsi/gomega v1.19.0 h1:4ieX6qQjPP/BfC3mpsAtIGGlxTWPeA3Inl/7DtXw1tw= +github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= github.com/philhofer/fwd v1.1.1 h1:GdGcTjf5RNAxwS4QLsiMzJYj5KEvPJD3Abr261yRQXQ= github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= @@ -74,8 +82,10 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210428140749-89ef3d95e781 h1:DzZ89McO9/gWPsQXS/FVKAlG02ZjaQ6AlZRBimEYOd0= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220622184535-263ec571b305 h1:dAgbJ2SP4jD6XYfMNLVj0BF21jo2PjChrtGaAvF5M3I= +golang.org/x/net v0.0.0-20220622184535-263ec571b305/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -85,18 +95,25 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 h1:wEZYwx+kK+KlZ0hpvP2Ls1Xr4+RWnlzGFwPP0aiDjIU= +golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= @@ -116,8 +133,8 @@ google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/l google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U= -gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=