Aurelien Perrier
4 years ago
No known key found for this signature in database
GPG Key ID: AED69FB60BEC43E1
35 changed files with 14 additions and 8421 deletions
Split View
Diff Options
-
+2 -2README.md
-
+1 -1channel.go
-
+1 -1consume.go
-
+1 -1examples/consumer/main.go
-
+1 -1examples/logger/main.go
-
+1 -1examples/publisher/main.go
-
+1 -1go.mod
-
+2 -2go.sum
-
+1 -1publish.go
-
+1 -1table.go
-
+0 -12vendor/github.com/streadway/amqp/.gitignore
-
+0 -25vendor/github.com/streadway/amqp/.travis.yml
-
+0 -35vendor/github.com/streadway/amqp/CONTRIBUTING.md
-
+0 -23vendor/github.com/streadway/amqp/LICENSE
-
+0 -93vendor/github.com/streadway/amqp/README.md
-
+0 -106vendor/github.com/streadway/amqp/allocator.go
-
+0 -62vendor/github.com/streadway/amqp/auth.go
-
+0 -159vendor/github.com/streadway/amqp/certs.sh
-
+0 -1593vendor/github.com/streadway/amqp/channel.go
-
+0 -94vendor/github.com/streadway/amqp/confirms.go
-
+0 -847vendor/github.com/streadway/amqp/connection.go
-
+0 -142vendor/github.com/streadway/amqp/consumers.go
-
+0 -173vendor/github.com/streadway/amqp/delivery.go
-
+0 -108vendor/github.com/streadway/amqp/doc.go
-
+0 -17vendor/github.com/streadway/amqp/fuzz.go
-
+0 -2vendor/github.com/streadway/amqp/gen.sh
-
+0 -3vendor/github.com/streadway/amqp/go.mod
-
+0 -67vendor/github.com/streadway/amqp/pre-commit
-
+0 -456vendor/github.com/streadway/amqp/read.go
-
+0 -64vendor/github.com/streadway/amqp/return.go
-
+0 -3306vendor/github.com/streadway/amqp/spec091.go
-
+0 -428vendor/github.com/streadway/amqp/types.go
-
+0 -176vendor/github.com/streadway/amqp/uri.go
-
+0 -416vendor/github.com/streadway/amqp/write.go
-
+2 -2vendor/modules.txt
+ 2
- 2
README.md
View File
+ 1
- 1
channel.go
View File
+ 1
- 1
consume.go
View File
+ 1
- 1
examples/consumer/main.go
View File
+ 1
- 1
examples/logger/main.go
View File
+ 1
- 1
examples/publisher/main.go
View File
+ 1
- 1
go.mod
View File
+ 2
- 2
go.sum
View File
| @ -1,2 +1,2 @@ | |||
| github.com/streadway/amqp v1.0.0 h1:kuuDrUJFZL1QYL9hUNuCxNObNzB0bV/ZG5jV3RWAQgo= | |||
| github.com/streadway/amqp v1.0.0/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= | |||
| github.com/rabbitmq/amqp091-go v0.0.0-20210823000215-c428a6150891 h1:13nv5f/LNJxNpvpYm/u0NqrlFebon342f9Xu9GpklKc= | |||
| github.com/rabbitmq/amqp091-go v0.0.0-20210823000215-c428a6150891/go.mod h1:ogQDLSOACsLPsIq0NpbtiifNZi2YOz0VTJ0kHRghqbM= | |||
+ 1
- 1
publish.go
View File
+ 1
- 1
table.go
View File
+ 0
- 12
vendor/github.com/streadway/amqp/.gitignore
View File
| @ -1,12 +0,0 @@ | |||
| certs/* | |||
| spec/spec | |||
| examples/simple-consumer/simple-consumer | |||
| examples/simple-producer/simple-producer | |||
| .idea/**/workspace.xml | |||
| .idea/**/tasks.xml | |||
| .idea/**/usage.statistics.xml | |||
| .idea/**/dictionaries | |||
| .idea/**/shelf | |||
| .idea/**/contentModel.xml | |||
+ 0
- 25
vendor/github.com/streadway/amqp/.travis.yml
View File
| @ -1,25 +0,0 @@ | |||
| language: go | |||
| go: | |||
| - 1.10.x | |||
| - 1.11.x | |||
| - 1.12.x | |||
| - 1.13.x | |||
| addons: | |||
| apt: | |||
| packages: | |||
| - rabbitmq-server | |||
| services: | |||
| - rabbitmq | |||
| env: | |||
| - GO111MODULE=on AMQP_URL=amqp://guest:guest@127.0.0.1:5672/ | |||
| before_install: | |||
| - go get -v golang.org/x/lint/golint | |||
| script: | |||
| - ./pre-commit | |||
| - go test -cpu=1,2 -v -tags integration ./... | |||
+ 0
- 35
vendor/github.com/streadway/amqp/CONTRIBUTING.md
View File
| @ -1,35 +0,0 @@ | |||
| ## Prequisites | |||
| 1. Go: [https://golang.org/dl/](https://golang.org/dl/) | |||
| 1. Golint `go get -u -v github.com/golang/lint/golint` | |||
| ## Contributing | |||
| The workflow is pretty standard: | |||
| 1. Fork github.com/streadway/amqp | |||
| 1. Add the pre-commit hook: `ln -s ../../pre-commit .git/hooks/pre-commit` | |||
| 1. Create your feature branch (`git checkout -b my-new-feature`) | |||
| 1. Run integration tests (see below) | |||
| 1. **Implement tests** | |||
| 1. Implement fixs | |||
| 1. Commit your changes (`git commit -am 'Add some feature'`) | |||
| 1. Push to a branch (`git push -u origin my-new-feature`) | |||
| 1. Submit a pull request | |||
| ## Running Tests | |||
| The test suite assumes that: | |||
| * A RabbitMQ node is running on localhost with all defaults: [https://www.rabbitmq.com/download.html](https://www.rabbitmq.com/download.html) | |||
| * `AMQP_URL` is exported to `amqp://guest:guest@127.0.0.1:5672/` | |||
| ### Integration Tests | |||
| After starting a local RabbitMQ, run integration tests with the following: | |||
| env AMQP_URL=amqp://guest:guest@127.0.0.1:5672/ go test -v -cpu 2 -tags integration -race | |||
| All integration tests should use the `integrationConnection(...)` test | |||
| helpers defined in `integration_test.go` to setup the integration environment | |||
| and logging. | |||
+ 0
- 23
vendor/github.com/streadway/amqp/LICENSE
View File
| @ -1,23 +0,0 @@ | |||
| Copyright (c) 2012-2019, Sean Treadway, SoundCloud Ltd. | |||
| All rights reserved. | |||
| Redistribution and use in source and binary forms, with or without | |||
| modification, are permitted provided that the following conditions are met: | |||
| Redistributions of source code must retain the above copyright notice, this | |||
| list of conditions and the following disclaimer. | |||
| Redistributions in binary form must reproduce the above copyright notice, this | |||
| list of conditions and the following disclaimer in the documentation and/or | |||
| other materials provided with the distribution. | |||
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
| ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
| DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |||
| FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |||
| DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |||
| SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |||
| CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |||
| OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||
+ 0
- 93
vendor/github.com/streadway/amqp/README.md
View File
| @ -1,93 +0,0 @@ | |||
| [](http://travis-ci.org/streadway/amqp) [](http://godoc.org/github.com/streadway/amqp) | |||
| # Go RabbitMQ Client Library | |||
| This is an AMQP 0.9.1 client with RabbitMQ extensions in Go. | |||
| ## Project Maturity | |||
| This project has been used in production systems for many years. It is reasonably mature | |||
| and feature complete, and as of November 2016 has [a team of maintainers](https://github.com/streadway/amqp/issues/215). | |||
| Future API changes are unlikely but possible. They will be discussed on [Github | |||
| issues](https://github.com/streadway/amqp/issues) along with any bugs or | |||
| enhancements. | |||
| ## Supported Go Versions | |||
| This library supports two most recent Go release series, currently 1.10 and 1.11. | |||
| ## Supported RabbitMQ Versions | |||
| This project supports RabbitMQ versions starting with `2.0` but primarily tested | |||
| against reasonably recent `3.x` releases. Some features and behaviours may be | |||
| server version-specific. | |||
| ## Goals | |||
| Provide a functional interface that closely represents the AMQP 0.9.1 model | |||
| targeted to RabbitMQ as a server. This includes the minimum necessary to | |||
| interact the semantics of the protocol. | |||
| ## Non-goals | |||
| Things not intended to be supported. | |||
| * Auto reconnect and re-synchronization of client and server topologies. | |||
| * Reconnection would require understanding the error paths when the | |||
| topology cannot be declared on reconnect. This would require a new set | |||
| of types and code paths that are best suited at the call-site of this | |||
| package. AMQP has a dynamic topology that needs all peers to agree. If | |||
| this doesn't happen, the behavior is undefined. Instead of producing a | |||
| possible interface with undefined behavior, this package is designed to | |||
| be simple for the caller to implement the necessary connection-time | |||
| topology declaration so that reconnection is trivial and encapsulated in | |||
| the caller's application code. | |||
| * AMQP Protocol negotiation for forward or backward compatibility. | |||
| * 0.9.1 is stable and widely deployed. Versions 0.10 and 1.0 are divergent | |||
| specifications that change the semantics and wire format of the protocol. | |||
| We will accept patches for other protocol support but have no plans for | |||
| implementation ourselves. | |||
| * Anything other than PLAIN and EXTERNAL authentication mechanisms. | |||
| * Keeping the mechanisms interface modular makes it possible to extend | |||
| outside of this package. If other mechanisms prove to be popular, then | |||
| we would accept patches to include them in this package. | |||
| ## Usage | |||
| See the 'examples' subdirectory for simple producers and consumers executables. | |||
| If you have a use-case in mind which isn't well-represented by the examples, | |||
| please file an issue. | |||
| ## Documentation | |||
| Use [Godoc documentation](http://godoc.org/github.com/streadway/amqp) for | |||
| reference and usage. | |||
| [RabbitMQ tutorials in | |||
| Go](https://github.com/rabbitmq/rabbitmq-tutorials/tree/master/go) are also | |||
| available. | |||
| ## Contributing | |||
| Pull requests are very much welcomed. Create your pull request on a non-master | |||
| branch, make sure a test or example is included that covers your change and | |||
| your commits represent coherent changes that include a reason for the change. | |||
| To run the integration tests, make sure you have RabbitMQ running on any host, | |||
| export the environment variable `AMQP_URL=amqp://host/` and run `go test -tags | |||
| integration`. TravisCI will also run the integration tests. | |||
| Thanks to the [community of contributors](https://github.com/streadway/amqp/graphs/contributors). | |||
| ## External packages | |||
| * [Google App Engine Dialer support](https://github.com/soundtrackyourbrand/gaeamqp) | |||
| * [RabbitMQ examples in Go](https://github.com/rabbitmq/rabbitmq-tutorials/tree/master/go) | |||
| ## License | |||
| BSD 2 clause - see LICENSE for more details. | |||
+ 0
- 106
vendor/github.com/streadway/amqp/allocator.go
View File
| @ -1,106 +0,0 @@ | |||
| package amqp | |||
| import ( | |||
| "bytes" | |||
| "fmt" | |||
| "math/big" | |||
| ) | |||
| const ( | |||
| free = 0 | |||
| allocated = 1 | |||
| ) | |||
| // allocator maintains a bitset of allocated numbers. | |||
| type allocator struct { | |||
| pool *big.Int | |||
| last int | |||
| low int | |||
| high int | |||
| } | |||
| // NewAllocator reserves and frees integers out of a range between low and | |||
| // high. | |||
| // | |||
| // O(N) worst case space used, where N is maximum allocated, divided by | |||
| // sizeof(big.Word) | |||
| func newAllocator(low, high int) *allocator { | |||
| return &allocator{ | |||
| pool: big.NewInt(0), | |||
| last: low, | |||
| low: low, | |||
| high: high, | |||
| } | |||
| } | |||
| // String returns a string describing the contents of the allocator like | |||
| // "allocator[low..high] reserved..until" | |||
| // | |||
| // O(N) where N is high-low | |||
| func (a allocator) String() string { | |||
| b := &bytes.Buffer{} | |||
| fmt.Fprintf(b, "allocator[%d..%d]", a.low, a.high) | |||
| for low := a.low; low <= a.high; low++ { | |||
| high := low | |||
| for a.reserved(high) && high <= a.high { | |||
| high++ | |||
| } | |||
| if high > low+1 { | |||
| fmt.Fprintf(b, " %d..%d", low, high-1) | |||
| } else if high > low { | |||
| fmt.Fprintf(b, " %d", high-1) | |||
| } | |||
| low = high | |||
| } | |||
| return b.String() | |||
| } | |||
| // Next reserves and returns the next available number out of the range between | |||
| // low and high. If no number is available, false is returned. | |||
| // | |||
| // O(N) worst case runtime where N is allocated, but usually O(1) due to a | |||
| // rolling index into the oldest allocation. | |||
| func (a *allocator) next() (int, bool) { | |||
| wrapped := a.last | |||
| // Find trailing bit | |||
| for ; a.last <= a.high; a.last++ { | |||
| if a.reserve(a.last) { | |||
| return a.last, true | |||
| } | |||
| } | |||
| // Find preceding free'd pool | |||
| a.last = a.low | |||
| for ; a.last < wrapped; a.last++ { | |||
| if a.reserve(a.last) { | |||
| return a.last, true | |||
| } | |||
| } | |||
| return 0, false | |||
| } | |||
| // reserve claims the bit if it is not already claimed, returning true if | |||
| // successfully claimed. | |||
| func (a *allocator) reserve(n int) bool { | |||
| if a.reserved(n) { | |||
| return false | |||
| } | |||
| a.pool.SetBit(a.pool, n-a.low, allocated) | |||
| return true | |||
| } | |||
| // reserved returns true if the integer has been allocated | |||
| func (a *allocator) reserved(n int) bool { | |||
| return a.pool.Bit(n-a.low) == allocated | |||
| } | |||
| // release frees the use of the number for another allocation | |||
| func (a *allocator) release(n int) { | |||
| a.pool.SetBit(a.pool, n-a.low, free) | |||
| } | |||
+ 0
- 62
vendor/github.com/streadway/amqp/auth.go
View File
| @ -1,62 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "fmt" | |||
| ) | |||
| // Authentication interface provides a means for different SASL authentication | |||
| // mechanisms to be used during connection tuning. | |||
| type Authentication interface { | |||
| Mechanism() string | |||
| Response() string | |||
| } | |||
| // PlainAuth is a similar to Basic Auth in HTTP. | |||
| type PlainAuth struct { | |||
| Username string | |||
| Password string | |||
| } | |||
| // Mechanism returns "PLAIN" | |||
| func (auth *PlainAuth) Mechanism() string { | |||
| return "PLAIN" | |||
| } | |||
| // Response returns the null character delimited encoding for the SASL PLAIN Mechanism. | |||
| func (auth *PlainAuth) Response() string { | |||
| return fmt.Sprintf("\000%s\000%s", auth.Username, auth.Password) | |||
| } | |||
| // AMQPlainAuth is similar to PlainAuth | |||
| type AMQPlainAuth struct { | |||
| Username string | |||
| Password string | |||
| } | |||
| // Mechanism returns "AMQPLAIN" | |||
| func (auth *AMQPlainAuth) Mechanism() string { | |||
| return "AMQPLAIN" | |||
| } | |||
| // Response returns the null character delimited encoding for the SASL PLAIN Mechanism. | |||
| func (auth *AMQPlainAuth) Response() string { | |||
| return fmt.Sprintf("LOGIN:%sPASSWORD:%s", auth.Username, auth.Password) | |||
| } | |||
| // Finds the first mechanism preferred by the client that the server supports. | |||
| func pickSASLMechanism(client []Authentication, serverMechanisms []string) (auth Authentication, ok bool) { | |||
| for _, auth = range client { | |||
| for _, mech := range serverMechanisms { | |||
| if auth.Mechanism() == mech { | |||
| return auth, true | |||
| } | |||
| } | |||
| } | |||
| return | |||
| } | |||
+ 0
- 159
vendor/github.com/streadway/amqp/certs.sh
View File
| @ -1,159 +0,0 @@ | |||
| #!/bin/sh | |||
| # | |||
| # Creates the CA, server and client certs to be used by tls_test.go | |||
| # http://www.rabbitmq.com/ssl.html | |||
| # | |||
| # Copy stdout into the const section of tls_test.go or use for RabbitMQ | |||
| # | |||
| root=$PWD/certs | |||
| if [ -f $root/ca/serial ]; then | |||
| echo >&2 "Previous installation found" | |||
| echo >&2 "Remove $root/ca and rerun to overwrite" | |||
| exit 1 | |||
| fi | |||
| mkdir -p $root/ca/private | |||
| mkdir -p $root/ca/certs | |||
| mkdir -p $root/server | |||
| mkdir -p $root/client | |||
| cd $root/ca | |||
| chmod 700 private | |||
| touch index.txt | |||
| echo 'unique_subject = no' > index.txt.attr | |||
| echo '01' > serial | |||
| echo >openssl.cnf ' | |||
| [ ca ] | |||
| default_ca = testca | |||
| [ testca ] | |||
| dir = . | |||
| certificate = $dir/cacert.pem | |||
| database = $dir/index.txt | |||
| new_certs_dir = $dir/certs | |||
| private_key = $dir/private/cakey.pem | |||
| serial = $dir/serial | |||
| default_crl_days = 7 | |||
| default_days = 3650 | |||
| default_md = sha1 | |||
| policy = testca_policy | |||
| x509_extensions = certificate_extensions | |||
| [ testca_policy ] | |||
| commonName = supplied | |||
| stateOrProvinceName = optional | |||
| countryName = optional | |||
| emailAddress = optional | |||
| organizationName = optional | |||
| organizationalUnitName = optional | |||
| [ certificate_extensions ] | |||
| basicConstraints = CA:false | |||
| [ req ] | |||
| default_bits = 2048 | |||
| default_keyfile = ./private/cakey.pem | |||
| default_md = sha1 | |||
| prompt = yes | |||
| distinguished_name = root_ca_distinguished_name | |||
| x509_extensions = root_ca_extensions | |||
| [ root_ca_distinguished_name ] | |||
| commonName = hostname | |||
| [ root_ca_extensions ] | |||
| basicConstraints = CA:true | |||
| keyUsage = keyCertSign, cRLSign | |||
| [ client_ca_extensions ] | |||
| basicConstraints = CA:false | |||
| keyUsage = digitalSignature | |||
| extendedKeyUsage = 1.3.6.1.5.5.7.3.2 | |||
| [ server_ca_extensions ] | |||
| basicConstraints = CA:false | |||
| keyUsage = keyEncipherment | |||
| extendedKeyUsage = 1.3.6.1.5.5.7.3.1 | |||
| subjectAltName = @alt_names | |||
| [ alt_names ] | |||
| IP.1 = 127.0.0.1 | |||
| ' | |||
| openssl req \ | |||
| -x509 \ | |||
| -nodes \ | |||
| -config openssl.cnf \ | |||
| -newkey rsa:2048 \ | |||
| -days 3650 \ | |||
| -subj "/CN=MyTestCA/" \ | |||
| -out cacert.pem \ | |||
| -outform PEM | |||
| openssl x509 \ | |||
| -in cacert.pem \ | |||
| -out cacert.cer \ | |||
| -outform DER | |||
| openssl genrsa -out $root/server/key.pem 2048 | |||
| openssl genrsa -out $root/client/key.pem 2048 | |||
| openssl req \ | |||
| -new \ | |||
| -nodes \ | |||
| -config openssl.cnf \ | |||
| -subj "/CN=127.0.0.1/O=server/" \ | |||
| -key $root/server/key.pem \ | |||
| -out $root/server/req.pem \ | |||
| -outform PEM | |||
| openssl req \ | |||
| -new \ | |||
| -nodes \ | |||
| -config openssl.cnf \ | |||
| -subj "/CN=127.0.0.1/O=client/" \ | |||
| -key $root/client/key.pem \ | |||
| -out $root/client/req.pem \ | |||
| -outform PEM | |||
| openssl ca \ | |||
| -config openssl.cnf \ | |||
| -in $root/server/req.pem \ | |||
| -out $root/server/cert.pem \ | |||
| -notext \ | |||
| -batch \ | |||
| -extensions server_ca_extensions | |||
| openssl ca \ | |||
| -config openssl.cnf \ | |||
| -in $root/client/req.pem \ | |||
| -out $root/client/cert.pem \ | |||
| -notext \ | |||
| -batch \ | |||
| -extensions client_ca_extensions | |||
| cat <<-END | |||
| const caCert = \` | |||
| `cat $root/ca/cacert.pem` | |||
| \` | |||
| const serverCert = \` | |||
| `cat $root/server/cert.pem` | |||
| \` | |||
| const serverKey = \` | |||
| `cat $root/server/key.pem` | |||
| \` | |||
| const clientCert = \` | |||
| `cat $root/client/cert.pem` | |||
| \` | |||
| const clientKey = \` | |||
| `cat $root/client/key.pem` | |||
| \` | |||
| END | |||
+ 0
- 1593
vendor/github.com/streadway/amqp/channel.go
File diff suppressed because it is too large
View File
+ 0
- 94
vendor/github.com/streadway/amqp/confirms.go
View File
| @ -1,94 +0,0 @@ | |||
| package amqp | |||
| import "sync" | |||
| // confirms resequences and notifies one or multiple publisher confirmation listeners | |||
| type confirms struct { | |||
| m sync.Mutex | |||
| listeners []chan Confirmation | |||
| sequencer map[uint64]Confirmation | |||
| published uint64 | |||
| expecting uint64 | |||
| } | |||
| // newConfirms allocates a confirms | |||
| func newConfirms() *confirms { | |||
| return &confirms{ | |||
| sequencer: map[uint64]Confirmation{}, | |||
| published: 0, | |||
| expecting: 1, | |||
| } | |||
| } | |||
| func (c *confirms) Listen(l chan Confirmation) { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| c.listeners = append(c.listeners, l) | |||
| } | |||
| // publish increments the publishing counter | |||
| func (c *confirms) Publish() uint64 { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| c.published++ | |||
| return c.published | |||
| } | |||
| // confirm confirms one publishing, increments the expecting delivery tag, and | |||
| // removes bookkeeping for that delivery tag. | |||
| func (c *confirms) confirm(confirmation Confirmation) { | |||
| delete(c.sequencer, c.expecting) | |||
| c.expecting++ | |||
| for _, l := range c.listeners { | |||
| l <- confirmation | |||
| } | |||
| } | |||
| // resequence confirms any out of order delivered confirmations | |||
| func (c *confirms) resequence() { | |||
| for c.expecting <= c.published { | |||
| sequenced, found := c.sequencer[c.expecting] | |||
| if !found { | |||
| return | |||
| } | |||
| c.confirm(sequenced) | |||
| } | |||
| } | |||
| // one confirms one publishing and all following in the publishing sequence | |||
| func (c *confirms) One(confirmed Confirmation) { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| if c.expecting == confirmed.DeliveryTag { | |||
| c.confirm(confirmed) | |||
| } else { | |||
| c.sequencer[confirmed.DeliveryTag] = confirmed | |||
| } | |||
| c.resequence() | |||
| } | |||
| // multiple confirms all publishings up until the delivery tag | |||
| func (c *confirms) Multiple(confirmed Confirmation) { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| for c.expecting <= confirmed.DeliveryTag { | |||
| c.confirm(Confirmation{c.expecting, confirmed.Ack}) | |||
| } | |||
| c.resequence() | |||
| } | |||
| // Close closes all listeners, discarding any out of sequence confirmations | |||
| func (c *confirms) Close() error { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| for _, l := range c.listeners { | |||
| close(l) | |||
| } | |||
| c.listeners = nil | |||
| return nil | |||
| } | |||
+ 0
- 847
vendor/github.com/streadway/amqp/connection.go
View File
| @ -1,847 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "bufio" | |||
| "crypto/tls" | |||
| "io" | |||
| "net" | |||
| "reflect" | |||
| "strconv" | |||
| "strings" | |||
| "sync" | |||
| "sync/atomic" | |||
| "time" | |||
| ) | |||
| const ( | |||
| maxChannelMax = (2 << 15) - 1 | |||
| defaultHeartbeat = 10 * time.Second | |||
| defaultConnectionTimeout = 30 * time.Second | |||
| defaultProduct = "https://github.com/streadway/amqp" | |||
| defaultVersion = "β" | |||
| // Safer default that makes channel leaks a lot easier to spot | |||
| // before they create operational headaches. See https://github.com/rabbitmq/rabbitmq-server/issues/1593. | |||
| defaultChannelMax = (2 << 10) - 1 | |||
| defaultLocale = "en_US" | |||
| ) | |||
| // Config is used in DialConfig and Open to specify the desired tuning | |||
| // parameters used during a connection open handshake. The negotiated tuning | |||
| // will be stored in the returned connection's Config field. | |||
| type Config struct { | |||
| // The SASL mechanisms to try in the client request, and the successful | |||
| // mechanism used on the Connection object. | |||
| // If SASL is nil, PlainAuth from the URL is used. | |||
| SASL []Authentication | |||
| // Vhost specifies the namespace of permissions, exchanges, queues and | |||
| // bindings on the server. Dial sets this to the path parsed from the URL. | |||
| Vhost string | |||
| ChannelMax int // 0 max channels means 2^16 - 1 | |||
| FrameSize int // 0 max bytes means unlimited | |||
| Heartbeat time.Duration // less than 1s uses the server's interval | |||
| // TLSClientConfig specifies the client configuration of the TLS connection | |||
| // when establishing a tls transport. | |||
| // If the URL uses an amqps scheme, then an empty tls.Config with the | |||
| // ServerName from the URL is used. | |||
| TLSClientConfig *tls.Config | |||
| // Properties is table of properties that the client advertises to the server. | |||
| // This is an optional setting - if the application does not set this, | |||
| // the underlying library will use a generic set of client properties. | |||
| Properties Table | |||
| // Connection locale that we expect to always be en_US | |||
| // Even though servers must return it as per the AMQP 0-9-1 spec, | |||
| // we are not aware of it being used other than to satisfy the spec requirements | |||
| Locale string | |||
| // Dial returns a net.Conn prepared for a TLS handshake with TSLClientConfig, | |||
| // then an AMQP connection handshake. | |||
| // If Dial is nil, net.DialTimeout with a 30s connection and 30s deadline is | |||
| // used during TLS and AMQP handshaking. | |||
| Dial func(network, addr string) (net.Conn, error) | |||
| } | |||
| // Connection manages the serialization and deserialization of frames from IO | |||
| // and dispatches the frames to the appropriate channel. All RPC methods and | |||
| // asynchronous Publishing, Delivery, Ack, Nack and Return messages are | |||
| // multiplexed on this channel. There must always be active receivers for | |||
| // every asynchronous message on this connection. | |||
| type Connection struct { | |||
| destructor sync.Once // shutdown once | |||
| sendM sync.Mutex // conn writer mutex | |||
| m sync.Mutex // struct field mutex | |||
| conn io.ReadWriteCloser | |||
| rpc chan message | |||
| writer *writer | |||
| sends chan time.Time // timestamps of each frame sent | |||
| deadlines chan readDeadliner // heartbeater updates read deadlines | |||
| allocator *allocator // id generator valid after openTune | |||
| channels map[uint16]*Channel | |||
| noNotify bool // true when we will never notify again | |||
| closes []chan *Error | |||
| blocks []chan Blocking | |||
| errors chan *Error | |||
| Config Config // The negotiated Config after connection.open | |||
| Major int // Server's major version | |||
| Minor int // Server's minor version | |||
| Properties Table // Server properties | |||
| Locales []string // Server locales | |||
| closed int32 // Will be 1 if the connection is closed, 0 otherwise. Should only be accessed as atomic | |||
| } | |||
| type readDeadliner interface { | |||
| SetReadDeadline(time.Time) error | |||
| } | |||
| // DefaultDial establishes a connection when config.Dial is not provided | |||
| func DefaultDial(connectionTimeout time.Duration) func(network, addr string) (net.Conn, error) { | |||
| return func(network, addr string) (net.Conn, error) { | |||
| conn, err := net.DialTimeout(network, addr, connectionTimeout) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| // Heartbeating hasn't started yet, don't stall forever on a dead server. | |||
| // A deadline is set for TLS and AMQP handshaking. After AMQP is established, | |||
| // the deadline is cleared in openComplete. | |||
| if err := conn.SetDeadline(time.Now().Add(connectionTimeout)); err != nil { | |||
| return nil, err | |||
| } | |||
| return conn, nil | |||
| } | |||
| } | |||
| // Dial accepts a string in the AMQP URI format and returns a new Connection | |||
| // over TCP using PlainAuth. Defaults to a server heartbeat interval of 10 | |||
| // seconds and sets the handshake deadline to 30 seconds. After handshake, | |||
| // deadlines are cleared. | |||
| // | |||
| // Dial uses the zero value of tls.Config when it encounters an amqps:// | |||
| // scheme. It is equivalent to calling DialTLS(amqp, nil). | |||
| func Dial(url string) (*Connection, error) { | |||
| return DialConfig(url, Config{ | |||
| Heartbeat: defaultHeartbeat, | |||
| Locale: defaultLocale, | |||
| }) | |||
| } | |||
| // DialTLS accepts a string in the AMQP URI format and returns a new Connection | |||
| // over TCP using PlainAuth. Defaults to a server heartbeat interval of 10 | |||
| // seconds and sets the initial read deadline to 30 seconds. | |||
| // | |||
| // DialTLS uses the provided tls.Config when encountering an amqps:// scheme. | |||
| func DialTLS(url string, amqps *tls.Config) (*Connection, error) { | |||
| return DialConfig(url, Config{ | |||
| Heartbeat: defaultHeartbeat, | |||
| TLSClientConfig: amqps, | |||
| Locale: defaultLocale, | |||
| }) | |||
| } | |||
| // DialConfig accepts a string in the AMQP URI format and a configuration for | |||
| // the transport and connection setup, returning a new Connection. Defaults to | |||
| // a server heartbeat interval of 10 seconds and sets the initial read deadline | |||
| // to 30 seconds. | |||
| func DialConfig(url string, config Config) (*Connection, error) { | |||
| var err error | |||
| var conn net.Conn | |||
| uri, err := ParseURI(url) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if config.SASL == nil { | |||
| config.SASL = []Authentication{uri.PlainAuth()} | |||
| } | |||
| if config.Vhost == "" { | |||
| config.Vhost = uri.Vhost | |||
| } | |||
| addr := net.JoinHostPort(uri.Host, strconv.FormatInt(int64(uri.Port), 10)) | |||
| dialer := config.Dial | |||
| if dialer == nil { | |||
| dialer = DefaultDial(defaultConnectionTimeout) | |||
| } | |||
| conn, err = dialer("tcp", addr) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if uri.Scheme == "amqps" { | |||
| if config.TLSClientConfig == nil { | |||
| config.TLSClientConfig = new(tls.Config) | |||
| } | |||
| // If ServerName has not been specified in TLSClientConfig, | |||
| // set it to the URI host used for this connection. | |||
| if config.TLSClientConfig.ServerName == "" { | |||
| config.TLSClientConfig.ServerName = uri.Host | |||
| } | |||
| client := tls.Client(conn, config.TLSClientConfig) | |||
| if err := client.Handshake(); err != nil { | |||
| conn.Close() | |||
| return nil, err | |||
| } | |||
| conn = client | |||
| } | |||
| return Open(conn, config) | |||
| } | |||
| /* | |||
| Open accepts an already established connection, or other io.ReadWriteCloser as | |||
| a transport. Use this method if you have established a TLS connection or wish | |||
| to use your own custom transport. | |||
| */ | |||
| func Open(conn io.ReadWriteCloser, config Config) (*Connection, error) { | |||
| c := &Connection{ | |||
| conn: conn, | |||
| writer: &writer{bufio.NewWriter(conn)}, | |||
| channels: make(map[uint16]*Channel), | |||
| rpc: make(chan message), | |||
| sends: make(chan time.Time), | |||
| errors: make(chan *Error, 1), | |||
| deadlines: make(chan readDeadliner, 1), | |||
| } | |||
| go c.reader(conn) | |||
| return c, c.open(config) | |||
| } | |||
| /* | |||
| LocalAddr returns the local TCP peer address, or ":0" (the zero value of net.TCPAddr) | |||
| as a fallback default value if the underlying transport does not support LocalAddr(). | |||
| */ | |||
| func (c *Connection) LocalAddr() net.Addr { | |||
| if conn, ok := c.conn.(interface { | |||
| LocalAddr() net.Addr | |||
| }); ok { | |||
| return conn.LocalAddr() | |||
| } | |||
| return &net.TCPAddr{} | |||
| } | |||
| // ConnectionState returns basic TLS details of the underlying transport. | |||
| // Returns a zero value when the underlying connection does not implement | |||
| // ConnectionState() tls.ConnectionState. | |||
| func (c *Connection) ConnectionState() tls.ConnectionState { | |||
| if conn, ok := c.conn.(interface { | |||
| ConnectionState() tls.ConnectionState | |||
| }); ok { | |||
| return conn.ConnectionState() | |||
| } | |||
| return tls.ConnectionState{} | |||
| } | |||
| /* | |||
| NotifyClose registers a listener for close events either initiated by an error | |||
| accompanying a connection.close method or by a normal shutdown. | |||
| On normal shutdowns, the chan will be closed. | |||
| To reconnect after a transport or protocol error, register a listener here and | |||
| re-run your setup process. | |||
| */ | |||
| func (c *Connection) NotifyClose(receiver chan *Error) chan *Error { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| if c.noNotify { | |||
| close(receiver) | |||
| } else { | |||
| c.closes = append(c.closes, receiver) | |||
| } | |||
| return receiver | |||
| } | |||
| /* | |||
| NotifyBlocked registers a listener for RabbitMQ specific TCP flow control | |||
| method extensions connection.blocked and connection.unblocked. Flow control is | |||
| active with a reason when Blocking.Blocked is true. When a Connection is | |||
| blocked, all methods will block across all connections until server resources | |||
| become free again. | |||
| This optional extension is supported by the server when the | |||
| "connection.blocked" server capability key is true. | |||
| */ | |||
| func (c *Connection) NotifyBlocked(receiver chan Blocking) chan Blocking { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| if c.noNotify { | |||
| close(receiver) | |||
| } else { | |||
| c.blocks = append(c.blocks, receiver) | |||
| } | |||
| return receiver | |||
| } | |||
| /* | |||
| Close requests and waits for the response to close the AMQP connection. | |||
| It's advisable to use this message when publishing to ensure all kernel buffers | |||
| have been flushed on the server and client before exiting. | |||
| An error indicates that server may not have received this request to close but | |||
| the connection should be treated as closed regardless. | |||
| After returning from this call, all resources associated with this connection, | |||
| including the underlying io, Channels, Notify listeners and Channel consumers | |||
| will also be closed. | |||
| */ | |||
| func (c *Connection) Close() error { | |||
| if c.IsClosed() { | |||
| return ErrClosed | |||
| } | |||
| defer c.shutdown(nil) | |||
| return c.call( | |||
| &connectionClose{ | |||
| ReplyCode: replySuccess, | |||
| ReplyText: "kthxbai", | |||
| }, | |||
| &connectionCloseOk{}, | |||
| ) | |||
| } | |||
| func (c *Connection) closeWith(err *Error) error { | |||
| if c.IsClosed() { | |||
| return ErrClosed | |||
| } | |||
| defer c.shutdown(err) | |||
| return c.call( | |||
| &connectionClose{ | |||
| ReplyCode: uint16(err.Code), | |||
| ReplyText: err.Reason, | |||
| }, | |||
| &connectionCloseOk{}, | |||
| ) | |||
| } | |||
| // IsClosed returns true if the connection is marked as closed, otherwise false | |||
| // is returned. | |||
| func (c *Connection) IsClosed() bool { | |||
| return (atomic.LoadInt32(&c.closed) == 1) | |||
| } | |||
| func (c *Connection) send(f frame) error { | |||
| if c.IsClosed() { | |||
| return ErrClosed | |||
| } | |||
| c.sendM.Lock() | |||
| err := c.writer.WriteFrame(f) | |||
| c.sendM.Unlock() | |||
| if err != nil { | |||
| // shutdown could be re-entrant from signaling notify chans | |||
| go c.shutdown(&Error{ | |||
| Code: FrameError, | |||
| Reason: err.Error(), | |||
| }) | |||
| } else { | |||
| // Broadcast we sent a frame, reducing heartbeats, only | |||
| // if there is something that can receive - like a non-reentrant | |||
| // call or if the heartbeater isn't running | |||
| select { | |||
| case c.sends <- time.Now(): | |||
| default: | |||
| } | |||
| } | |||
| return err | |||
| } | |||
| func (c *Connection) shutdown(err *Error) { | |||
| atomic.StoreInt32(&c.closed, 1) | |||
| c.destructor.Do(func() { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| if err != nil { | |||
| for _, c := range c.closes { | |||
| c <- err | |||
| } | |||
| } | |||
| if err != nil { | |||
| c.errors <- err | |||
| } | |||
| // Shutdown handler goroutine can still receive the result. | |||
| close(c.errors) | |||
| for _, c := range c.closes { | |||
| close(c) | |||
| } | |||
| for _, c := range c.blocks { | |||
| close(c) | |||
| } | |||
| // Shutdown the channel, but do not use closeChannel() as it calls | |||
| // releaseChannel() which requires the connection lock. | |||
| // | |||
| // Ranging over c.channels and calling releaseChannel() that mutates | |||
| // c.channels is racy - see commit 6063341 for an example. | |||
| for _, ch := range c.channels { | |||
| ch.shutdown(err) | |||
| } | |||
| c.conn.Close() | |||
| c.channels = map[uint16]*Channel{} | |||
| c.allocator = newAllocator(1, c.Config.ChannelMax) | |||
| c.noNotify = true | |||
| }) | |||
| } | |||
| // All methods sent to the connection channel should be synchronous so we | |||
| // can handle them directly without a framing component | |||
| func (c *Connection) demux(f frame) { | |||
| if f.channel() == 0 { | |||
| c.dispatch0(f) | |||
| } else { | |||
| c.dispatchN(f) | |||
| } | |||
| } | |||
| func (c *Connection) dispatch0(f frame) { | |||
| switch mf := f.(type) { | |||
| case *methodFrame: | |||
| switch m := mf.Method.(type) { | |||
| case *connectionClose: | |||
| // Send immediately as shutdown will close our side of the writer. | |||
| c.send(&methodFrame{ | |||
| ChannelId: 0, | |||
| Method: &connectionCloseOk{}, | |||
| }) | |||
| c.shutdown(newError(m.ReplyCode, m.ReplyText)) | |||
| case *connectionBlocked: | |||
| for _, c := range c.blocks { | |||
| c <- Blocking{Active: true, Reason: m.Reason} | |||
| } | |||
| case *connectionUnblocked: | |||
| for _, c := range c.blocks { | |||
| c <- Blocking{Active: false} | |||
| } | |||
| default: | |||
| c.rpc <- m | |||
| } | |||
| case *heartbeatFrame: | |||
| // kthx - all reads reset our deadline. so we can drop this | |||
| default: | |||
| // lolwat - channel0 only responds to methods and heartbeats | |||
| c.closeWith(ErrUnexpectedFrame) | |||
| } | |||
| } | |||
| func (c *Connection) dispatchN(f frame) { | |||
| c.m.Lock() | |||
| channel := c.channels[f.channel()] | |||
| c.m.Unlock() | |||
| if channel != nil { | |||
| channel.recv(channel, f) | |||
| } else { | |||
| c.dispatchClosed(f) | |||
| } | |||
| } | |||
| // section 2.3.7: "When a peer decides to close a channel or connection, it | |||
| // sends a Close method. The receiving peer MUST respond to a Close with a | |||
| // Close-Ok, and then both parties can close their channel or connection. Note | |||
| // that if peers ignore Close, deadlock can happen when both peers send Close | |||
| // at the same time." | |||
| // | |||
| // When we don't have a channel, so we must respond with close-ok on a close | |||
| // method. This can happen between a channel exception on an asynchronous | |||
| // method like basic.publish and a synchronous close with channel.close. | |||
| // In that case, we'll get both a channel.close and channel.close-ok in any | |||
| // order. | |||
| func (c *Connection) dispatchClosed(f frame) { | |||
| // Only consider method frames, drop content/header frames | |||
| if mf, ok := f.(*methodFrame); ok { | |||
| switch mf.Method.(type) { | |||
| case *channelClose: | |||
| c.send(&methodFrame{ | |||
| ChannelId: f.channel(), | |||
| Method: &channelCloseOk{}, | |||
| }) | |||
| case *channelCloseOk: | |||
| // we are already closed, so do nothing | |||
| default: | |||
| // unexpected method on closed channel | |||
| c.closeWith(ErrClosed) | |||
| } | |||
| } | |||
| } | |||
| // Reads each frame off the IO and hand off to the connection object that | |||
| // will demux the streams and dispatch to one of the opened channels or | |||
| // handle on channel 0 (the connection channel). | |||
| func (c *Connection) reader(r io.Reader) { | |||
| buf := bufio.NewReader(r) | |||
| frames := &reader{buf} | |||
| conn, haveDeadliner := r.(readDeadliner) | |||
| for { | |||
| frame, err := frames.ReadFrame() | |||
| if err != nil { | |||
| c.shutdown(&Error{Code: FrameError, Reason: err.Error()}) | |||
| return | |||
| } | |||
| c.demux(frame) | |||
| if haveDeadliner { | |||
| c.deadlines <- conn | |||
| } | |||
| } | |||
| } | |||
| // Ensures that at least one frame is being sent at the tuned interval with a | |||
| // jitter tolerance of 1s | |||
| func (c *Connection) heartbeater(interval time.Duration, done chan *Error) { | |||
| const maxServerHeartbeatsInFlight = 3 | |||
| var sendTicks <-chan time.Time | |||
| if interval > 0 { | |||
| ticker := time.NewTicker(interval) | |||
| defer ticker.Stop() | |||
| sendTicks = ticker.C | |||
| } | |||
| lastSent := time.Now() | |||
| for { | |||
| select { | |||
| case at, stillSending := <-c.sends: | |||
| // When actively sending, depend on sent frames to reset server timer | |||
| if stillSending { | |||
| lastSent = at | |||
| } else { | |||
| return | |||
| } | |||
| case at := <-sendTicks: | |||
| // When idle, fill the space with a heartbeat frame | |||
| if at.Sub(lastSent) > interval-time.Second { | |||
| if err := c.send(&heartbeatFrame{}); err != nil { | |||
| // send heartbeats even after close/closeOk so we | |||
| // tick until the connection starts erroring | |||
| return | |||
| } | |||
| } | |||
| case conn := <-c.deadlines: | |||
| // When reading, reset our side of the deadline, if we've negotiated one with | |||
| // a deadline that covers at least 2 server heartbeats | |||
| if interval > 0 { | |||
| conn.SetReadDeadline(time.Now().Add(maxServerHeartbeatsInFlight * interval)) | |||
| } | |||
| case <-done: | |||
| return | |||
| } | |||
| } | |||
| } | |||
| // Convenience method to inspect the Connection.Properties["capabilities"] | |||
| // Table for server identified capabilities like "basic.ack" or | |||
| // "confirm.select". | |||
| func (c *Connection) isCapable(featureName string) bool { | |||
| capabilities, _ := c.Properties["capabilities"].(Table) | |||
| hasFeature, _ := capabilities[featureName].(bool) | |||
| return hasFeature | |||
| } | |||
| // allocateChannel records but does not open a new channel with a unique id. | |||
| // This method is the initial part of the channel lifecycle and paired with | |||
| // releaseChannel | |||
| func (c *Connection) allocateChannel() (*Channel, error) { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| if c.IsClosed() { | |||
| return nil, ErrClosed | |||
| } | |||
| id, ok := c.allocator.next() | |||
| if !ok { | |||
| return nil, ErrChannelMax | |||
| } | |||
| ch := newChannel(c, uint16(id)) | |||
| c.channels[uint16(id)] = ch | |||
| return ch, nil | |||
| } | |||
| // releaseChannel removes a channel from the registry as the final part of the | |||
| // channel lifecycle | |||
| func (c *Connection) releaseChannel(id uint16) { | |||
| c.m.Lock() | |||
| defer c.m.Unlock() | |||
| delete(c.channels, id) | |||
| c.allocator.release(int(id)) | |||
| } | |||
| // openChannel allocates and opens a channel, must be paired with closeChannel | |||
| func (c *Connection) openChannel() (*Channel, error) { | |||
| ch, err := c.allocateChannel() | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if err := ch.open(); err != nil { | |||
| c.releaseChannel(ch.id) | |||
| return nil, err | |||
| } | |||
| return ch, nil | |||
| } | |||
| // closeChannel releases and initiates a shutdown of the channel. All channel | |||
| // closures should be initiated here for proper channel lifecycle management on | |||
| // this connection. | |||
| func (c *Connection) closeChannel(ch *Channel, e *Error) { | |||
| ch.shutdown(e) | |||
| c.releaseChannel(ch.id) | |||
| } | |||
| /* | |||
| Channel opens a unique, concurrent server channel to process the bulk of AMQP | |||
| messages. Any error from methods on this receiver will render the receiver | |||
| invalid and a new Channel should be opened. | |||
| */ | |||
| func (c *Connection) Channel() (*Channel, error) { | |||
| return c.openChannel() | |||
| } | |||
| func (c *Connection) call(req message, res ...message) error { | |||
| // Special case for when the protocol header frame is sent insted of a | |||
| // request method | |||
| if req != nil { | |||
| if err := c.send(&methodFrame{ChannelId: 0, Method: req}); err != nil { | |||
| return err | |||
| } | |||
| } | |||
| select { | |||
| case err, ok := <-c.errors: | |||
| if !ok { | |||
| return ErrClosed | |||
| } | |||
| return err | |||
| case msg := <-c.rpc: | |||
| // Try to match one of the result types | |||
| for _, try := range res { | |||
| if reflect.TypeOf(msg) == reflect.TypeOf(try) { | |||
| // *res = *msg | |||
| vres := reflect.ValueOf(try).Elem() | |||
| vmsg := reflect.ValueOf(msg).Elem() | |||
| vres.Set(vmsg) | |||
| return nil | |||
| } | |||
| } | |||
| return ErrCommandInvalid | |||
| } | |||
| // unreachable | |||
| } | |||
| // Connection = open-Connection *use-Connection close-Connection | |||
| // open-Connection = C:protocol-header | |||
| // S:START C:START-OK | |||
| // *challenge | |||
| // S:TUNE C:TUNE-OK | |||
| // C:OPEN S:OPEN-OK | |||
| // challenge = S:SECURE C:SECURE-OK | |||
| // use-Connection = *channel | |||
| // close-Connection = C:CLOSE S:CLOSE-OK | |||
| // / S:CLOSE C:CLOSE-OK | |||
| func (c *Connection) open(config Config) error { | |||
| if err := c.send(&protocolHeader{}); err != nil { | |||
| return err | |||
| } | |||
| return c.openStart(config) | |||
| } | |||
| func (c *Connection) openStart(config Config) error { | |||
| start := &connectionStart{} | |||
| if err := c.call(nil, start); err != nil { | |||
| return err | |||
| } | |||
| c.Major = int(start.VersionMajor) | |||
| c.Minor = int(start.VersionMinor) | |||
| c.Properties = Table(start.ServerProperties) | |||
| c.Locales = strings.Split(start.Locales, " ") | |||
| // eventually support challenge/response here by also responding to | |||
| // connectionSecure. | |||
| auth, ok := pickSASLMechanism(config.SASL, strings.Split(start.Mechanisms, " ")) | |||
| if !ok { | |||
| return ErrSASL | |||
| } | |||
| // Save this mechanism off as the one we chose | |||
| c.Config.SASL = []Authentication{auth} | |||
| // Set the connection locale to client locale | |||
| c.Config.Locale = config.Locale | |||
| return c.openTune(config, auth) | |||
| } | |||
| func (c *Connection) openTune(config Config, auth Authentication) error { | |||
| if len(config.Properties) == 0 { | |||
| config.Properties = Table{ | |||
| "product": defaultProduct, | |||
| "version": defaultVersion, | |||
| } | |||
| } | |||
| config.Properties["capabilities"] = Table{ | |||
| "connection.blocked": true, | |||
| "consumer_cancel_notify": true, | |||
| } | |||
| ok := &connectionStartOk{ | |||
| ClientProperties: config.Properties, | |||
| Mechanism: auth.Mechanism(), | |||
| Response: auth.Response(), | |||
| Locale: config.Locale, | |||
| } | |||
| tune := &connectionTune{} | |||
| if err := c.call(ok, tune); err != nil { | |||
| // per spec, a connection can only be closed when it has been opened | |||
| // so at this point, we know it's an auth error, but the socket | |||
| // was closed instead. Return a meaningful error. | |||
| return ErrCredentials | |||
| } | |||
| // When the server and client both use default 0, then the max channel is | |||
| // only limited by uint16. | |||
| c.Config.ChannelMax = pick(config.ChannelMax, int(tune.ChannelMax)) | |||
| if c.Config.ChannelMax == 0 { | |||
| c.Config.ChannelMax = defaultChannelMax | |||
| } | |||
| c.Config.ChannelMax = min(c.Config.ChannelMax, maxChannelMax) | |||
| // Frame size includes headers and end byte (len(payload)+8), even if | |||
| // this is less than FrameMinSize, use what the server sends because the | |||
| // alternative is to stop the handshake here. | |||
| c.Config.FrameSize = pick(config.FrameSize, int(tune.FrameMax)) | |||
| // Save this off for resetDeadline() | |||
| c.Config.Heartbeat = time.Second * time.Duration(pick( | |||
| int(config.Heartbeat/time.Second), | |||
| int(tune.Heartbeat))) | |||
| // "The client should start sending heartbeats after receiving a | |||
| // Connection.Tune method" | |||
| go c.heartbeater(c.Config.Heartbeat, c.NotifyClose(make(chan *Error, 1))) | |||
| if err := c.send(&methodFrame{ | |||
| ChannelId: 0, | |||
| Method: &connectionTuneOk{ | |||
| ChannelMax: uint16(c.Config.ChannelMax), | |||
| FrameMax: uint32(c.Config.FrameSize), | |||
| Heartbeat: uint16(c.Config.Heartbeat / time.Second), | |||
| }, | |||
| }); err != nil { | |||
| return err | |||
| } | |||
| return c.openVhost(config) | |||
| } | |||
| func (c *Connection) openVhost(config Config) error { | |||
| req := &connectionOpen{VirtualHost: config.Vhost} | |||
| res := &connectionOpenOk{} | |||
| if err := c.call(req, res); err != nil { | |||
| // Cannot be closed yet, but we know it's a vhost problem | |||
| return ErrVhost | |||
| } | |||
| c.Config.Vhost = config.Vhost | |||
| return c.openComplete() | |||
| } | |||
| // openComplete performs any final Connection initialization dependent on the | |||
| // connection handshake and clears any state needed for TLS and AMQP handshaking. | |||
| func (c *Connection) openComplete() error { | |||
| // We clear the deadlines and let the heartbeater reset the read deadline if requested. | |||
| // RabbitMQ uses TCP flow control at this point for pushback so Writes can | |||
| // intentionally block. | |||
| if deadliner, ok := c.conn.(interface { | |||
| SetDeadline(time.Time) error | |||
| }); ok { | |||
| _ = deadliner.SetDeadline(time.Time{}) | |||
| } | |||
| c.allocator = newAllocator(1, c.Config.ChannelMax) | |||
| return nil | |||
| } | |||
| func max(a, b int) int { | |||
| if a > b { | |||
| return a | |||
| } | |||
| return b | |||
| } | |||
| func min(a, b int) int { | |||
| if a < b { | |||
| return a | |||
| } | |||
| return b | |||
| } | |||
| func pick(client, server int) int { | |||
| if client == 0 || server == 0 { | |||
| return max(client, server) | |||
| } | |||
| return min(client, server) | |||
| } | |||
+ 0
- 142
vendor/github.com/streadway/amqp/consumers.go
View File
| @ -1,142 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "os" | |||
| "strconv" | |||
| "sync" | |||
| "sync/atomic" | |||
| ) | |||
| var consumerSeq uint64 | |||
| const consumerTagLengthMax = 0xFF // see writeShortstr | |||
| func uniqueConsumerTag() string { | |||
| return commandNameBasedUniqueConsumerTag(os.Args[0]) | |||
| } | |||
| func commandNameBasedUniqueConsumerTag(commandName string) string { | |||
| tagPrefix := "ctag-" | |||
| tagInfix := commandName | |||
| tagSuffix := "-" + strconv.FormatUint(atomic.AddUint64(&consumerSeq, 1), 10) | |||
| if len(tagPrefix)+len(tagInfix)+len(tagSuffix) > consumerTagLengthMax { | |||
| tagInfix = "streadway/amqp" | |||
| } | |||
| return tagPrefix + tagInfix + tagSuffix | |||
| } | |||
| type consumerBuffers map[string]chan *Delivery | |||
| // Concurrent type that manages the consumerTag -> | |||
| // ingress consumerBuffer mapping | |||
| type consumers struct { | |||
| sync.WaitGroup // one for buffer | |||
| closed chan struct{} // signal buffer | |||
| sync.Mutex // protects below | |||
| chans consumerBuffers | |||
| } | |||
| func makeConsumers() *consumers { | |||
| return &consumers{ | |||
| closed: make(chan struct{}), | |||
| chans: make(consumerBuffers), | |||
| } | |||
| } | |||
| func (subs *consumers) buffer(in chan *Delivery, out chan Delivery) { | |||
| defer close(out) | |||
| defer subs.Done() | |||
| var inflight = in | |||
| var queue []*Delivery | |||
| for delivery := range in { | |||
| queue = append(queue, delivery) | |||
| for len(queue) > 0 { | |||
| select { | |||
| case <-subs.closed: | |||
| // closed before drained, drop in-flight | |||
| return | |||
| case delivery, consuming := <-inflight: | |||
| if consuming { | |||
| queue = append(queue, delivery) | |||
| } else { | |||
| inflight = nil | |||
| } | |||
| case out <- *queue[0]: | |||
| queue = queue[1:] | |||
| } | |||
| } | |||
| } | |||
| } | |||
| // On key conflict, close the previous channel. | |||
| func (subs *consumers) add(tag string, consumer chan Delivery) { | |||
| subs.Lock() | |||
| defer subs.Unlock() | |||
| if prev, found := subs.chans[tag]; found { | |||
| close(prev) | |||
| } | |||
| in := make(chan *Delivery) | |||
| subs.chans[tag] = in | |||
| subs.Add(1) | |||
| go subs.buffer(in, consumer) | |||
| } | |||
| func (subs *consumers) cancel(tag string) (found bool) { | |||
| subs.Lock() | |||
| defer subs.Unlock() | |||
| ch, found := subs.chans[tag] | |||
| if found { | |||
| delete(subs.chans, tag) | |||
| close(ch) | |||
| } | |||
| return found | |||
| } | |||
| func (subs *consumers) close() { | |||
| subs.Lock() | |||
| defer subs.Unlock() | |||
| close(subs.closed) | |||
| for tag, ch := range subs.chans { | |||
| delete(subs.chans, tag) | |||
| close(ch) | |||
| } | |||
| subs.Wait() | |||
| } | |||
| // Sends a delivery to a the consumer identified by `tag`. | |||
| // If unbuffered channels are used for Consume this method | |||
| // could block all deliveries until the consumer | |||
| // receives on the other end of the channel. | |||
| func (subs *consumers) send(tag string, msg *Delivery) bool { | |||
| subs.Lock() | |||
| defer subs.Unlock() | |||
| buffer, found := subs.chans[tag] | |||
| if found { | |||
| buffer <- msg | |||
| } | |||
| return found | |||
| } | |||
+ 0
- 173
vendor/github.com/streadway/amqp/delivery.go
View File
| @ -1,173 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "errors" | |||
| "time" | |||
| ) | |||
| var errDeliveryNotInitialized = errors.New("delivery not initialized") | |||
| // Acknowledger notifies the server of successful or failed consumption of | |||
| // delivieries via identifier found in the Delivery.DeliveryTag field. | |||
| // | |||
| // Applications can provide mock implementations in tests of Delivery handlers. | |||
| type Acknowledger interface { | |||
| Ack(tag uint64, multiple bool) error | |||
| Nack(tag uint64, multiple bool, requeue bool) error | |||
| Reject(tag uint64, requeue bool) error | |||
| } | |||
| // Delivery captures the fields for a previously delivered message resident in | |||
| // a queue to be delivered by the server to a consumer from Channel.Consume or | |||
| // Channel.Get. | |||
| type Delivery struct { | |||
| Acknowledger Acknowledger // the channel from which this delivery arrived | |||
| Headers Table // Application or header exchange table | |||
| // Properties | |||
| ContentType string // MIME content type | |||
| ContentEncoding string // MIME content encoding | |||
| DeliveryMode uint8 // queue implementation use - non-persistent (1) or persistent (2) | |||
| Priority uint8 // queue implementation use - 0 to 9 | |||
| CorrelationId string // application use - correlation identifier | |||
| ReplyTo string // application use - address to reply to (ex: RPC) | |||
| Expiration string // implementation use - message expiration spec | |||
| MessageId string // application use - message identifier | |||
| Timestamp time.Time // application use - message timestamp | |||
| Type string // application use - message type name | |||
| UserId string // application use - creating user - should be authenticated user | |||
| AppId string // application use - creating application id | |||
| // Valid only with Channel.Consume | |||
| ConsumerTag string | |||
| // Valid only with Channel.Get | |||
| MessageCount uint32 | |||
| DeliveryTag uint64 | |||
| Redelivered bool | |||
| Exchange string // basic.publish exchange | |||
| RoutingKey string // basic.publish routing key | |||
| Body []byte | |||
| } | |||
| func newDelivery(channel *Channel, msg messageWithContent) *Delivery { | |||
| props, body := msg.getContent() | |||
| delivery := Delivery{ | |||
| Acknowledger: channel, | |||
| Headers: props.Headers, | |||
| ContentType: props.ContentType, | |||
| ContentEncoding: props.ContentEncoding, | |||
| DeliveryMode: props.DeliveryMode, | |||
| Priority: props.Priority, | |||
| CorrelationId: props.CorrelationId, | |||
| ReplyTo: props.ReplyTo, | |||
| Expiration: props.Expiration, | |||
| MessageId: props.MessageId, | |||
| Timestamp: props.Timestamp, | |||
| Type: props.Type, | |||
| UserId: props.UserId, | |||
| AppId: props.AppId, | |||
| Body: body, | |||
| } | |||
| // Properties for the delivery types | |||
| switch m := msg.(type) { | |||
| case *basicDeliver: | |||
| delivery.ConsumerTag = m.ConsumerTag | |||
| delivery.DeliveryTag = m.DeliveryTag | |||
| delivery.Redelivered = m.Redelivered | |||
| delivery.Exchange = m.Exchange | |||
| delivery.RoutingKey = m.RoutingKey | |||
| case *basicGetOk: | |||
| delivery.MessageCount = m.MessageCount | |||
| delivery.DeliveryTag = m.DeliveryTag | |||
| delivery.Redelivered = m.Redelivered | |||
| delivery.Exchange = m.Exchange | |||
| delivery.RoutingKey = m.RoutingKey | |||
| } | |||
| return &delivery | |||
| } | |||
| /* | |||
| Ack delegates an acknowledgement through the Acknowledger interface that the | |||
| client or server has finished work on a delivery. | |||
| All deliveries in AMQP must be acknowledged. If you called Channel.Consume | |||
| with autoAck true then the server will be automatically ack each message and | |||
| this method should not be called. Otherwise, you must call Delivery.Ack after | |||
| you have successfully processed this delivery. | |||
| When multiple is true, this delivery and all prior unacknowledged deliveries | |||
| on the same channel will be acknowledged. This is useful for batch processing | |||
| of deliveries. | |||
| An error will indicate that the acknowledge could not be delivered to the | |||
| channel it was sent from. | |||
| Either Delivery.Ack, Delivery.Reject or Delivery.Nack must be called for every | |||
| delivery that is not automatically acknowledged. | |||
| */ | |||
| func (d Delivery) Ack(multiple bool) error { | |||
| if d.Acknowledger == nil { | |||
| return errDeliveryNotInitialized | |||
| } | |||
| return d.Acknowledger.Ack(d.DeliveryTag, multiple) | |||
| } | |||
| /* | |||
| Reject delegates a negatively acknowledgement through the Acknowledger interface. | |||
| When requeue is true, queue this message to be delivered to a consumer on a | |||
| different channel. When requeue is false or the server is unable to queue this | |||
| message, it will be dropped. | |||
| If you are batch processing deliveries, and your server supports it, prefer | |||
| Delivery.Nack. | |||
| Either Delivery.Ack, Delivery.Reject or Delivery.Nack must be called for every | |||
| delivery that is not automatically acknowledged. | |||
| */ | |||
| func (d Delivery) Reject(requeue bool) error { | |||
| if d.Acknowledger == nil { | |||
| return errDeliveryNotInitialized | |||
| } | |||
| return d.Acknowledger.Reject(d.DeliveryTag, requeue) | |||
| } | |||
| /* | |||
| Nack negatively acknowledge the delivery of message(s) identified by the | |||
| delivery tag from either the client or server. | |||
| When multiple is true, nack messages up to and including delivered messages up | |||
| until the delivery tag delivered on the same channel. | |||
| When requeue is true, request the server to deliver this message to a different | |||
| consumer. If it is not possible or requeue is false, the message will be | |||
| dropped or delivered to a server configured dead-letter queue. | |||
| This method must not be used to select or requeue messages the client wishes | |||
| not to handle, rather it is to inform the server that the client is incapable | |||
| of handling this message at this time. | |||
| Either Delivery.Ack, Delivery.Reject or Delivery.Nack must be called for every | |||
| delivery that is not automatically acknowledged. | |||
| */ | |||
| func (d Delivery) Nack(multiple, requeue bool) error { | |||
| if d.Acknowledger == nil { | |||
| return errDeliveryNotInitialized | |||
| } | |||
| return d.Acknowledger.Nack(d.DeliveryTag, multiple, requeue) | |||
| } | |||
+ 0
- 108
vendor/github.com/streadway/amqp/doc.go
View File
| @ -1,108 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| /* | |||
| Package amqp is an AMQP 0.9.1 client with RabbitMQ extensions | |||
| Understand the AMQP 0.9.1 messaging model by reviewing these links first. Much | |||
| of the terminoLoggery in this library directly relates to AMQP concepts. | |||
| Resources | |||
| http://www.rabbitmq.com/tutorials/amqp-concepts.html | |||
| http://www.rabbitmq.com/getstarted.html | |||
| http://www.rabbitmq.com/amqp-0-9-1-reference.html | |||
| Design | |||
| Most other broker clients publish to queues, but in AMQP, clients publish | |||
| Exchanges instead. AMQP is programmable, meaning that both the producers and | |||
| consumers agree on the configuration of the broker, instead of requiring an | |||
| operator or system configuration that declares the logical topology in the | |||
| broker. The routing between producers and consumer queues is via Bindings. | |||
| These bindings form the logical topology of the broker. | |||
| In this library, a message sent from publisher is called a "Publishing" and a | |||
| message received to a consumer is called a "Delivery". The fields of | |||
| Publishings and Deliveries are close but not exact mappings to the underlying | |||
| wire format to maintain stronger types. Many other libraries will combine | |||
| message properties with message headers. In this library, the message well | |||
| known properties are strongly typed fields on the Publishings and Deliveries, | |||
| whereas the user defined headers are in the Headers field. | |||
| The method naming closely matches the protocol's method name with positional | |||
| parameters mapping to named protocol message fields. The motivation here is to | |||
| present a comprehensive view over all possible interactions with the server. | |||
| Generally, methods that map to protocol methods of the "basic" class will be | |||
| elided in this interface, and "select" methods of various channel mode selectors | |||
| will be elided for example Channel.Confirm and Channel.Tx. | |||
| The library is intentionally designed to be synchronous, where responses for | |||
| each protocol message are required to be received in an RPC manner. Some | |||
| methods have a noWait parameter like Channel.QueueDeclare, and some methods are | |||
| asynchronous like Channel.Publish. The error values should still be checked for | |||
| these methods as they will indicate IO failures like when the underlying | |||
| connection closes. | |||
| Asynchronous Events | |||
| Clients of this library may be interested in receiving some of the protocol | |||
| messages other than Deliveries like basic.ack methods while a channel is in | |||
| confirm mode. | |||
| The Notify* methods with Connection and Channel receivers model the pattern of | |||
| asynchronous events like closes due to exceptions, or messages that are sent out | |||
| of band from an RPC call like basic.ack or basic.flow. | |||
| Any asynchronous events, including Deliveries and Publishings must always have | |||
| a receiver until the corresponding chans are closed. Without asynchronous | |||
| receivers, the sychronous methods will block. | |||
| Use Case | |||
| It's important as a client to an AMQP topology to ensure the state of the | |||
| broker matches your expectations. For both publish and consume use cases, | |||
| make sure you declare the queues, exchanges and bindings you expect to exist | |||
| prior to calling Channel.Publish or Channel.Consume. | |||
| // Connections start with amqp.Dial() typically from a command line argument | |||
| // or environment variable. | |||
| connection, err := amqp.Dial(os.Getenv("AMQP_URL")) | |||
| // To cleanly shutdown by flushing kernel buffers, make sure to close and | |||
| // wait for the response. | |||
| defer connection.Close() | |||
| // Most operations happen on a channel. If any error is returned on a | |||
| // channel, the channel will no longer be valid, throw it away and try with | |||
| // a different channel. If you use many channels, it's useful for the | |||
| // server to | |||
| channel, err := connection.Channel() | |||
| // Declare your topology here, if it doesn't exist, it will be created, if | |||
| // it existed already and is not what you expect, then that's considered an | |||
| // error. | |||
| // Use your connection on this topology with either Publish or Consume, or | |||
| // inspect your queues with QueueInspect. It's unwise to mix Publish and | |||
| // Consume to let TCP do its job well. | |||
| SSL/TLS - Secure connections | |||
| When Dial encounters an amqps:// scheme, it will use the zero value of a | |||
| tls.Config. This will only perform server certificate and host verification. | |||
| Use DialTLS when you wish to provide a client certificate (recommended), | |||
| include a private certificate authority's certificate in the cert chain for | |||
| server validity, or run insecure by not verifying the server certificate dial | |||
| your own connection. DialTLS will use the provided tls.Config when it | |||
| encounters an amqps:// scheme and will dial a plain connection when it | |||
| encounters an amqp:// scheme. | |||
| SSL/TLS in RabbitMQ is documented here: http://www.rabbitmq.com/ssl.html | |||
| */ | |||
| package amqp | |||
+ 0
- 17
vendor/github.com/streadway/amqp/fuzz.go
View File
| @ -1,17 +0,0 @@ | |||
| // +build gofuzz | |||
| package amqp | |||
| import "bytes" | |||
| func Fuzz(data []byte) int { | |||
| r := reader{bytes.NewReader(data)} | |||
| frame, err := r.ReadFrame() | |||
| if err != nil { | |||
| if frame != nil { | |||
| panic("frame is not nil") | |||
| } | |||
| return 0 | |||
| } | |||
| return 1 | |||
| } | |||
+ 0
- 2
vendor/github.com/streadway/amqp/gen.sh
View File
| @ -1,2 +0,0 @@ | |||
| #!/bin/sh | |||
| go run spec/gen.go < spec/amqp0-9-1.stripped.extended.xml | gofmt > spec091.go | |||
+ 0
- 3
vendor/github.com/streadway/amqp/go.mod
View File
| @ -1,3 +0,0 @@ | |||
| module github.com/streadway/amqp | |||
| go 1.10 | |||
+ 0
- 67
vendor/github.com/streadway/amqp/pre-commit
View File
| @ -1,67 +0,0 @@ | |||
| #!/bin/sh | |||
| LATEST_STABLE_SUPPORTED_GO_VERSION="1.11" | |||
| main() { | |||
| if local_go_version_is_latest_stable | |||
| then | |||
| run_gofmt | |||
| run_golint | |||
| run_govet | |||
| fi | |||
| run_unit_tests | |||
| } | |||
| local_go_version_is_latest_stable() { | |||
| go version | grep -q $LATEST_STABLE_SUPPORTED_GO_VERSION | |||
| } | |||
| log_error() { | |||
| echo "$*" 1>&2 | |||
| } | |||
| run_gofmt() { | |||
| GOFMT_FILES=$(gofmt -l .) | |||
| if [ -n "$GOFMT_FILES" ] | |||
| then | |||
| log_error "gofmt failed for the following files: | |||
| $GOFMT_FILES | |||
| please run 'gofmt -w .' on your changes before committing." | |||
| exit 1 | |||
| fi | |||
| } | |||
| run_golint() { | |||
| GOLINT_ERRORS=$(golint ./... | grep -v "Id should be") | |||
| if [ -n "$GOLINT_ERRORS" ] | |||
| then | |||
| log_error "golint failed for the following reasons: | |||
| $GOLINT_ERRORS | |||
| please run 'golint ./...' on your changes before committing." | |||
| exit 1 | |||
| fi | |||
| } | |||
| run_govet() { | |||
| GOVET_ERRORS=$(go tool vet ./*.go 2>&1) | |||
| if [ -n "$GOVET_ERRORS" ] | |||
| then | |||
| log_error "go vet failed for the following reasons: | |||
| $GOVET_ERRORS | |||
| please run 'go tool vet ./*.go' on your changes before committing." | |||
| exit 1 | |||
| fi | |||
| } | |||
| run_unit_tests() { | |||
| if [ -z "$NOTEST" ] | |||
| then | |||
| log_error 'Running short tests...' | |||
| env AMQP_URL= go test -short | |||
| fi | |||
| } | |||
| main | |||
+ 0
- 456
vendor/github.com/streadway/amqp/read.go
View File
| @ -1,456 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "bytes" | |||
| "encoding/binary" | |||
| "errors" | |||
| "io" | |||
| "time" | |||
| ) | |||
| /* | |||
| Reads a frame from an input stream and returns an interface that can be cast into | |||
| one of the following: | |||
| methodFrame | |||
| PropertiesFrame | |||
| bodyFrame | |||
| heartbeatFrame | |||
| 2.3.5 frame Details | |||
| All frames consist of a header (7 octets), a payload of arbitrary size, and a | |||
| 'frame-end' octet that detects malformed frames: | |||
| 0 1 3 7 size+7 size+8 | |||
| +------+---------+-------------+ +------------+ +-----------+ | |||
| | type | channel | size | | payload | | frame-end | | |||
| +------+---------+-------------+ +------------+ +-----------+ | |||
| octet short long size octets octet | |||
| To read a frame, we: | |||
| 1. Read the header and check the frame type and channel. | |||
| 2. Depending on the frame type, we read the payload and process it. | |||
| 3. Read the frame end octet. | |||
| In realistic implementations where performance is a concern, we would use | |||
| “read-ahead buffering” or | |||
| “gathering reads” to avoid doing three separate system calls to read a frame. | |||
| */ | |||
| func (r *reader) ReadFrame() (frame frame, err error) { | |||
| var scratch [7]byte | |||
| if _, err = io.ReadFull(r.r, scratch[:7]); err != nil { | |||
| return | |||
| } | |||
| typ := uint8(scratch[0]) | |||
| channel := binary.BigEndian.Uint16(scratch[1:3]) | |||
| size := binary.BigEndian.Uint32(scratch[3:7]) | |||
| switch typ { | |||
| case frameMethod: | |||
| if frame, err = r.parseMethodFrame(channel, size); err != nil { | |||
| return | |||
| } | |||
| case frameHeader: | |||
| if frame, err = r.parseHeaderFrame(channel, size); err != nil { | |||
| return | |||
| } | |||
| case frameBody: | |||
| if frame, err = r.parseBodyFrame(channel, size); err != nil { | |||
| return nil, err | |||
| } | |||
| case frameHeartbeat: | |||
| if frame, err = r.parseHeartbeatFrame(channel, size); err != nil { | |||
| return | |||
| } | |||
| default: | |||
| return nil, ErrFrame | |||
| } | |||
| if _, err = io.ReadFull(r.r, scratch[:1]); err != nil { | |||
| return nil, err | |||
| } | |||
| if scratch[0] != frameEnd { | |||
| return nil, ErrFrame | |||
| } | |||
| return | |||
| } | |||
| func readShortstr(r io.Reader) (v string, err error) { | |||
| var length uint8 | |||
| if err = binary.Read(r, binary.BigEndian, &length); err != nil { | |||
| return | |||
| } | |||
| bytes := make([]byte, length) | |||
| if _, err = io.ReadFull(r, bytes); err != nil { | |||
| return | |||
| } | |||
| return string(bytes), nil | |||
| } | |||
| func readLongstr(r io.Reader) (v string, err error) { | |||
| var length uint32 | |||
| if err = binary.Read(r, binary.BigEndian, &length); err != nil { | |||
| return | |||
| } | |||
| // slices can't be longer than max int32 value | |||
| if length > (^uint32(0) >> 1) { | |||
| return | |||
| } | |||
| bytes := make([]byte, length) | |||
| if _, err = io.ReadFull(r, bytes); err != nil { | |||
| return | |||
| } | |||
| return string(bytes), nil | |||
| } | |||
| func readDecimal(r io.Reader) (v Decimal, err error) { | |||
| if err = binary.Read(r, binary.BigEndian, &v.Scale); err != nil { | |||
| return | |||
| } | |||
| if err = binary.Read(r, binary.BigEndian, &v.Value); err != nil { | |||
| return | |||
| } | |||
| return | |||
| } | |||
| func readFloat32(r io.Reader) (v float32, err error) { | |||
| if err = binary.Read(r, binary.BigEndian, &v); err != nil { | |||
| return | |||
| } | |||
| return | |||
| } | |||
| func readFloat64(r io.Reader) (v float64, err error) { | |||
| if err = binary.Read(r, binary.BigEndian, &v); err != nil { | |||
| return | |||
| } | |||
| return | |||
| } | |||
| func readTimestamp(r io.Reader) (v time.Time, err error) { | |||
| var sec int64 | |||
| if err = binary.Read(r, binary.BigEndian, &sec); err != nil { | |||
| return | |||
| } | |||
| return time.Unix(sec, 0), nil | |||
| } | |||
| /* | |||
| 'A': []interface{} | |||
| 'D': Decimal | |||
| 'F': Table | |||
| 'I': int32 | |||
| 'S': string | |||
| 'T': time.Time | |||
| 'V': nil | |||
| 'b': byte | |||
| 'd': float64 | |||
| 'f': float32 | |||
| 'l': int64 | |||
| 's': int16 | |||
| 't': bool | |||
| 'x': []byte | |||
| */ | |||
| func readField(r io.Reader) (v interface{}, err error) { | |||
| var typ byte | |||
| if err = binary.Read(r, binary.BigEndian, &typ); err != nil { | |||
| return | |||
| } | |||
| switch typ { | |||
| case 't': | |||
| var value uint8 | |||
| if err = binary.Read(r, binary.BigEndian, &value); err != nil { | |||
| return | |||
| } | |||
| return (value != 0), nil | |||
| case 'b': | |||
| var value [1]byte | |||
| if _, err = io.ReadFull(r, value[0:1]); err != nil { | |||
| return | |||
| } | |||
| return value[0], nil | |||
| case 's': | |||
| var value int16 | |||
| if err = binary.Read(r, binary.BigEndian, &value); err != nil { | |||
| return | |||
| } | |||
| return value, nil | |||
| case 'I': | |||
| var value int32 | |||
| if err = binary.Read(r, binary.BigEndian, &value); err != nil { | |||
| return | |||
| } | |||
| return value, nil | |||
| case 'l': | |||
| var value int64 | |||
| if err = binary.Read(r, binary.BigEndian, &value); err != nil { | |||
| return | |||
| } | |||
| return value, nil | |||
| case 'f': | |||
| var value float32 | |||
| if err = binary.Read(r, binary.BigEndian, &value); err != nil { | |||
| return | |||
| } | |||
| return value, nil | |||
| case 'd': | |||
| var value float64 | |||
| if err = binary.Read(r, binary.BigEndian, &value); err != nil { | |||
| return | |||
| } | |||
| return value, nil | |||
| case 'D': | |||
| return readDecimal(r) | |||
| case 'S': | |||
| return readLongstr(r) | |||
| case 'A': | |||
| return readArray(r) | |||
| case 'T': | |||
| return readTimestamp(r) | |||
| case 'F': | |||
| return readTable(r) | |||
| case 'x': | |||
| var len int32 | |||
| if err = binary.Read(r, binary.BigEndian, &len); err != nil { | |||
| return nil, err | |||
| } | |||
| value := make([]byte, len) | |||
| if _, err = io.ReadFull(r, value); err != nil { | |||
| return nil, err | |||
| } | |||
| return value, err | |||
| case 'V': | |||
| return nil, nil | |||
| } | |||
| return nil, ErrSyntax | |||
| } | |||
| /* | |||
| Field tables are long strings that contain packed name-value pairs. The | |||
| name-value pairs are encoded as short string defining the name, and octet | |||
| defining the values type and then the value itself. The valid field types for | |||
| tables are an extension of the native integer, bit, string, and timestamp | |||
| types, and are shown in the grammar. Multi-octet integer fields are always | |||
| held in network byte order. | |||
| */ | |||
| func readTable(r io.Reader) (table Table, err error) { | |||
| var nested bytes.Buffer | |||
| var str string | |||
| if str, err = readLongstr(r); err != nil { | |||
| return | |||
| } | |||
| nested.Write([]byte(str)) | |||
| table = make(Table) | |||
| for nested.Len() > 0 { | |||
| var key string | |||
| var value interface{} | |||
| if key, err = readShortstr(&nested); err != nil { | |||
| return | |||
| } | |||
| if value, err = readField(&nested); err != nil { | |||
| return | |||
| } | |||
| table[key] = value | |||
| } | |||
| return | |||
| } | |||
| func readArray(r io.Reader) ([]interface{}, error) { | |||
| var ( | |||
| size uint32 | |||
| err error | |||
| ) | |||
| if err = binary.Read(r, binary.BigEndian, &size); err != nil { | |||
| return nil, err | |||
| } | |||
| var ( | |||
| lim = &io.LimitedReader{R: r, N: int64(size)} | |||
| arr = []interface{}{} | |||
| field interface{} | |||
| ) | |||
| for { | |||
| if field, err = readField(lim); err != nil { | |||
| if err == io.EOF { | |||
| break | |||
| } | |||
| return nil, err | |||
| } | |||
| arr = append(arr, field) | |||
| } | |||
| return arr, nil | |||
| } | |||
| // Checks if this bit mask matches the flags bitset | |||
| func hasProperty(mask uint16, prop int) bool { | |||
| return int(mask)&prop > 0 | |||
| } | |||
| func (r *reader) parseHeaderFrame(channel uint16, size uint32) (frame frame, err error) { | |||
| hf := &headerFrame{ | |||
| ChannelId: channel, | |||
| } | |||
| if err = binary.Read(r.r, binary.BigEndian, &hf.ClassId); err != nil { | |||
| return | |||
| } | |||
| if err = binary.Read(r.r, binary.BigEndian, &hf.weight); err != nil { | |||
| return | |||
| } | |||
| if err = binary.Read(r.r, binary.BigEndian, &hf.Size); err != nil { | |||
| return | |||
| } | |||
| var flags uint16 | |||
| if err = binary.Read(r.r, binary.BigEndian, &flags); err != nil { | |||
| return | |||
| } | |||
| if hasProperty(flags, flagContentType) { | |||
| if hf.Properties.ContentType, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagContentEncoding) { | |||
| if hf.Properties.ContentEncoding, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagHeaders) { | |||
| if hf.Properties.Headers, err = readTable(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagDeliveryMode) { | |||
| if err = binary.Read(r.r, binary.BigEndian, &hf.Properties.DeliveryMode); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagPriority) { | |||
| if err = binary.Read(r.r, binary.BigEndian, &hf.Properties.Priority); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagCorrelationId) { | |||
| if hf.Properties.CorrelationId, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagReplyTo) { | |||
| if hf.Properties.ReplyTo, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagExpiration) { | |||
| if hf.Properties.Expiration, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagMessageId) { | |||
| if hf.Properties.MessageId, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagTimestamp) { | |||
| if hf.Properties.Timestamp, err = readTimestamp(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagType) { | |||
| if hf.Properties.Type, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagUserId) { | |||
| if hf.Properties.UserId, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagAppId) { | |||
| if hf.Properties.AppId, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(flags, flagReserved1) { | |||
| if hf.Properties.reserved1, err = readShortstr(r.r); err != nil { | |||
| return | |||
| } | |||
| } | |||
| return hf, nil | |||
| } | |||
| func (r *reader) parseBodyFrame(channel uint16, size uint32) (frame frame, err error) { | |||
| bf := &bodyFrame{ | |||
| ChannelId: channel, | |||
| Body: make([]byte, size), | |||
| } | |||
| if _, err = io.ReadFull(r.r, bf.Body); err != nil { | |||
| return nil, err | |||
| } | |||
| return bf, nil | |||
| } | |||
| var errHeartbeatPayload = errors.New("Heartbeats should not have a payload") | |||
| func (r *reader) parseHeartbeatFrame(channel uint16, size uint32) (frame frame, err error) { | |||
| hf := &heartbeatFrame{ | |||
| ChannelId: channel, | |||
| } | |||
| if size > 0 { | |||
| return nil, errHeartbeatPayload | |||
| } | |||
| return hf, nil | |||
| } | |||
+ 0
- 64
vendor/github.com/streadway/amqp/return.go
View File
| @ -1,64 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "time" | |||
| ) | |||
| // Return captures a flattened struct of fields returned by the server when a | |||
| // Publishing is unable to be delivered either due to the `mandatory` flag set | |||
| // and no route found, or `immediate` flag set and no free consumer. | |||
| type Return struct { | |||
| ReplyCode uint16 // reason | |||
| ReplyText string // description | |||
| Exchange string // basic.publish exchange | |||
| RoutingKey string // basic.publish routing key | |||
| // Properties | |||
| ContentType string // MIME content type | |||
| ContentEncoding string // MIME content encoding | |||
| Headers Table // Application or header exchange table | |||
| DeliveryMode uint8 // queue implementation use - non-persistent (1) or persistent (2) | |||
| Priority uint8 // queue implementation use - 0 to 9 | |||
| CorrelationId string // application use - correlation identifier | |||
| ReplyTo string // application use - address to to reply to (ex: RPC) | |||
| Expiration string // implementation use - message expiration spec | |||
| MessageId string // application use - message identifier | |||
| Timestamp time.Time // application use - message timestamp | |||
| Type string // application use - message type name | |||
| UserId string // application use - creating user id | |||
| AppId string // application use - creating application | |||
| Body []byte | |||
| } | |||
| func newReturn(msg basicReturn) *Return { | |||
| props, body := msg.getContent() | |||
| return &Return{ | |||
| ReplyCode: msg.ReplyCode, | |||
| ReplyText: msg.ReplyText, | |||
| Exchange: msg.Exchange, | |||
| RoutingKey: msg.RoutingKey, | |||
| Headers: props.Headers, | |||
| ContentType: props.ContentType, | |||
| ContentEncoding: props.ContentEncoding, | |||
| DeliveryMode: props.DeliveryMode, | |||
| Priority: props.Priority, | |||
| CorrelationId: props.CorrelationId, | |||
| ReplyTo: props.ReplyTo, | |||
| Expiration: props.Expiration, | |||
| MessageId: props.MessageId, | |||
| Timestamp: props.Timestamp, | |||
| Type: props.Type, | |||
| UserId: props.UserId, | |||
| AppId: props.AppId, | |||
| Body: body, | |||
| } | |||
| } | |||
+ 0
- 3306
vendor/github.com/streadway/amqp/spec091.go
File diff suppressed because it is too large
View File
+ 0
- 428
vendor/github.com/streadway/amqp/types.go
View File
| @ -1,428 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "fmt" | |||
| "io" | |||
| "time" | |||
| ) | |||
| // Constants for standard AMQP 0-9-1 exchange types. | |||
| const ( | |||
| ExchangeDirect = "direct" | |||
| ExchangeFanout = "fanout" | |||
| ExchangeTopic = "topic" | |||
| ExchangeHeaders = "headers" | |||
| ) | |||
| var ( | |||
| // ErrClosed is returned when the channel or connection is not open | |||
| ErrClosed = &Error{Code: ChannelError, Reason: "channel/connection is not open"} | |||
| // ErrChannelMax is returned when Connection.Channel has been called enough | |||
| // times that all channel IDs have been exhausted in the client or the | |||
| // server. | |||
| ErrChannelMax = &Error{Code: ChannelError, Reason: "channel id space exhausted"} | |||
| // ErrSASL is returned from Dial when the authentication mechanism could not | |||
| // be negoated. | |||
| ErrSASL = &Error{Code: AccessRefused, Reason: "SASL could not negotiate a shared mechanism"} | |||
| // ErrCredentials is returned when the authenticated client is not authorized | |||
| // to any vhost. | |||
| ErrCredentials = &Error{Code: AccessRefused, Reason: "username or password not allowed"} | |||
| // ErrVhost is returned when the authenticated user is not permitted to | |||
| // access the requested Vhost. | |||
| ErrVhost = &Error{Code: AccessRefused, Reason: "no access to this vhost"} | |||
| // ErrSyntax is hard protocol error, indicating an unsupported protocol, | |||
| // implementation or encoding. | |||
| ErrSyntax = &Error{Code: SyntaxError, Reason: "invalid field or value inside of a frame"} | |||
| // ErrFrame is returned when the protocol frame cannot be read from the | |||
| // server, indicating an unsupported protocol or unsupported frame type. | |||
| ErrFrame = &Error{Code: FrameError, Reason: "frame could not be parsed"} | |||
| // ErrCommandInvalid is returned when the server sends an unexpected response | |||
| // to this requested message type. This indicates a bug in this client. | |||
| ErrCommandInvalid = &Error{Code: CommandInvalid, Reason: "unexpected command received"} | |||
| // ErrUnexpectedFrame is returned when something other than a method or | |||
| // heartbeat frame is delivered to the Connection, indicating a bug in the | |||
| // client. | |||
| ErrUnexpectedFrame = &Error{Code: UnexpectedFrame, Reason: "unexpected frame received"} | |||
| // ErrFieldType is returned when writing a message containing a Go type unsupported by AMQP. | |||
| ErrFieldType = &Error{Code: SyntaxError, Reason: "unsupported table field type"} | |||
| ) | |||
| // Error captures the code and reason a channel or connection has been closed | |||
| // by the server. | |||
| type Error struct { | |||
| Code int // constant code from the specification | |||
| Reason string // description of the error | |||
| Server bool // true when initiated from the server, false when from this library | |||
| Recover bool // true when this error can be recovered by retrying later or with different parameters | |||
| } | |||
| func newError(code uint16, text string) *Error { | |||
| return &Error{ | |||
| Code: int(code), | |||
| Reason: text, | |||
| Recover: isSoftExceptionCode(int(code)), | |||
| Server: true, | |||
| } | |||
| } | |||
| func (e Error) Error() string { | |||
| return fmt.Sprintf("Exception (%d) Reason: %q", e.Code, e.Reason) | |||
| } | |||
| // Used by header frames to capture routing and header information | |||
| type properties struct { | |||
| ContentType string // MIME content type | |||
| ContentEncoding string // MIME content encoding | |||
| Headers Table // Application or header exchange table | |||
| DeliveryMode uint8 // queue implementation use - Transient (1) or Persistent (2) | |||
| Priority uint8 // queue implementation use - 0 to 9 | |||
| CorrelationId string // application use - correlation identifier | |||
| ReplyTo string // application use - address to to reply to (ex: RPC) | |||
| Expiration string // implementation use - message expiration spec | |||
| MessageId string // application use - message identifier | |||
| Timestamp time.Time // application use - message timestamp | |||
| Type string // application use - message type name | |||
| UserId string // application use - creating user id | |||
| AppId string // application use - creating application | |||
| reserved1 string // was cluster-id - process for buffer consumption | |||
| } | |||
| // DeliveryMode. Transient means higher throughput but messages will not be | |||
| // restored on broker restart. The delivery mode of publishings is unrelated | |||
| // to the durability of the queues they reside on. Transient messages will | |||
| // not be restored to durable queues, persistent messages will be restored to | |||
| // durable queues and lost on non-durable queues during server restart. | |||
| // | |||
| // This remains typed as uint8 to match Publishing.DeliveryMode. Other | |||
| // delivery modes specific to custom queue implementations are not enumerated | |||
| // here. | |||
| const ( | |||
| Transient uint8 = 1 | |||
| Persistent uint8 = 2 | |||
| ) | |||
| // The property flags are an array of bits that indicate the presence or | |||
| // absence of each property value in sequence. The bits are ordered from most | |||
| // high to low - bit 15 indicates the first property. | |||
| const ( | |||
| flagContentType = 0x8000 | |||
| flagContentEncoding = 0x4000 | |||
| flagHeaders = 0x2000 | |||
| flagDeliveryMode = 0x1000 | |||
| flagPriority = 0x0800 | |||
| flagCorrelationId = 0x0400 | |||
| flagReplyTo = 0x0200 | |||
| flagExpiration = 0x0100 | |||
| flagMessageId = 0x0080 | |||
| flagTimestamp = 0x0040 | |||
| flagType = 0x0020 | |||
| flagUserId = 0x0010 | |||
| flagAppId = 0x0008 | |||
| flagReserved1 = 0x0004 | |||
| ) | |||
| // Queue captures the current server state of the queue on the server returned | |||
| // from Channel.QueueDeclare or Channel.QueueInspect. | |||
| type Queue struct { | |||
| Name string // server confirmed or generated name | |||
| Messages int // count of messages not awaiting acknowledgment | |||
| Consumers int // number of consumers receiving deliveries | |||
| } | |||
| // Publishing captures the client message sent to the server. The fields | |||
| // outside of the Headers table included in this struct mirror the underlying | |||
| // fields in the content frame. They use native types for convenience and | |||
| // efficiency. | |||
| type Publishing struct { | |||
| // Application or exchange specific fields, | |||
| // the headers exchange will inspect this field. | |||
| Headers Table | |||
| // Properties | |||
| ContentType string // MIME content type | |||
| ContentEncoding string // MIME content encoding | |||
| DeliveryMode uint8 // Transient (0 or 1) or Persistent (2) | |||
| Priority uint8 // 0 to 9 | |||
| CorrelationId string // correlation identifier | |||
| ReplyTo string // address to to reply to (ex: RPC) | |||
| Expiration string // message expiration spec | |||
| MessageId string // message identifier | |||
| Timestamp time.Time // message timestamp | |||
| Type string // message type name | |||
| UserId string // creating user id - ex: "guest" | |||
| AppId string // creating application id | |||
| // The application specific payload of the message | |||
| Body []byte | |||
| } | |||
| // Blocking notifies the server's TCP flow control of the Connection. When a | |||
| // server hits a memory or disk alarm it will block all connections until the | |||
| // resources are reclaimed. Use NotifyBlock on the Connection to receive these | |||
| // events. | |||
| type Blocking struct { | |||
| Active bool // TCP pushback active/inactive on server | |||
| Reason string // Server reason for activation | |||
| } | |||
| // Confirmation notifies the acknowledgment or negative acknowledgement of a | |||
| // publishing identified by its delivery tag. Use NotifyPublish on the Channel | |||
| // to consume these events. | |||
| type Confirmation struct { | |||
| DeliveryTag uint64 // A 1 based counter of publishings from when the channel was put in Confirm mode | |||
| Ack bool // True when the server successfully received the publishing | |||
| } | |||
| // Decimal matches the AMQP decimal type. Scale is the number of decimal | |||
| // digits Scale == 2, Value == 12345, Decimal == 123.45 | |||
| type Decimal struct { | |||
| Scale uint8 | |||
| Value int32 | |||
| } | |||
| // Table stores user supplied fields of the following types: | |||
| // | |||
| // bool | |||
| // byte | |||
| // float32 | |||
| // float64 | |||
| // int | |||
| // int16 | |||
| // int32 | |||
| // int64 | |||
| // nil | |||
| // string | |||
| // time.Time | |||
| // amqp.Decimal | |||
| // amqp.Table | |||
| // []byte | |||
| // []interface{} - containing above types | |||
| // | |||
| // Functions taking a table will immediately fail when the table contains a | |||
| // value of an unsupported type. | |||
| // | |||
| // The caller must be specific in which precision of integer it wishes to | |||
| // encode. | |||
| // | |||
| // Use a type assertion when reading values from a table for type conversion. | |||
| // | |||
| // RabbitMQ expects int32 for integer values. | |||
| // | |||
| type Table map[string]interface{} | |||
| func validateField(f interface{}) error { | |||
| switch fv := f.(type) { | |||
| case nil, bool, byte, int, int16, int32, int64, float32, float64, string, []byte, Decimal, time.Time: | |||
| return nil | |||
| case []interface{}: | |||
| for _, v := range fv { | |||
| if err := validateField(v); err != nil { | |||
| return fmt.Errorf("in array %s", err) | |||
| } | |||
| } | |||
| return nil | |||
| case Table: | |||
| for k, v := range fv { | |||
| if err := validateField(v); err != nil { | |||
| return fmt.Errorf("table field %q %s", k, err) | |||
| } | |||
| } | |||
| return nil | |||
| } | |||
| return fmt.Errorf("value %T not supported", f) | |||
| } | |||
| // Validate returns and error if any Go types in the table are incompatible with AMQP types. | |||
| func (t Table) Validate() error { | |||
| return validateField(t) | |||
| } | |||
| // Heap interface for maintaining delivery tags | |||
| type tagSet []uint64 | |||
| func (set tagSet) Len() int { return len(set) } | |||
| func (set tagSet) Less(i, j int) bool { return (set)[i] < (set)[j] } | |||
| func (set tagSet) Swap(i, j int) { (set)[i], (set)[j] = (set)[j], (set)[i] } | |||
| func (set *tagSet) Push(tag interface{}) { *set = append(*set, tag.(uint64)) } | |||
| func (set *tagSet) Pop() interface{} { | |||
| val := (*set)[len(*set)-1] | |||
| *set = (*set)[:len(*set)-1] | |||
| return val | |||
| } | |||
| type message interface { | |||
| id() (uint16, uint16) | |||
| wait() bool | |||
| read(io.Reader) error | |||
| write(io.Writer) error | |||
| } | |||
| type messageWithContent interface { | |||
| message | |||
| getContent() (properties, []byte) | |||
| setContent(properties, []byte) | |||
| } | |||
| /* | |||
| The base interface implemented as: | |||
| 2.3.5 frame Details | |||
| All frames consist of a header (7 octets), a payload of arbitrary size, and a 'frame-end' octet that detects | |||
| malformed frames: | |||
| 0 1 3 7 size+7 size+8 | |||
| +------+---------+-------------+ +------------+ +-----------+ | |||
| | type | channel | size | | payload | | frame-end | | |||
| +------+---------+-------------+ +------------+ +-----------+ | |||
| octet short long size octets octet | |||
| To read a frame, we: | |||
| 1. Read the header and check the frame type and channel. | |||
| 2. Depending on the frame type, we read the payload and process it. | |||
| 3. Read the frame end octet. | |||
| In realistic implementations where performance is a concern, we would use | |||
| “read-ahead buffering” or “gathering reads” to avoid doing three separate | |||
| system calls to read a frame. | |||
| */ | |||
| type frame interface { | |||
| write(io.Writer) error | |||
| channel() uint16 | |||
| } | |||
| type reader struct { | |||
| r io.Reader | |||
| } | |||
| type writer struct { | |||
| w io.Writer | |||
| } | |||
| // Implements the frame interface for Connection RPC | |||
| type protocolHeader struct{} | |||
| func (protocolHeader) write(w io.Writer) error { | |||
| _, err := w.Write([]byte{'A', 'M', 'Q', 'P', 0, 0, 9, 1}) | |||
| return err | |||
| } | |||
| func (protocolHeader) channel() uint16 { | |||
| panic("only valid as initial handshake") | |||
| } | |||
| /* | |||
| Method frames carry the high-level protocol commands (which we call "methods"). | |||
| One method frame carries one command. The method frame payload has this format: | |||
| 0 2 4 | |||
| +----------+-----------+-------------- - - | |||
| | class-id | method-id | arguments... | |||
| +----------+-----------+-------------- - - | |||
| short short ... | |||
| To process a method frame, we: | |||
| 1. Read the method frame payload. | |||
| 2. Unpack it into a structure. A given method always has the same structure, | |||
| so we can unpack the method rapidly. 3. Check that the method is allowed in | |||
| the current context. | |||
| 4. Check that the method arguments are valid. | |||
| 5. Execute the method. | |||
| Method frame bodies are constructed as a list of AMQP data fields (bits, | |||
| integers, strings and string tables). The marshalling code is trivially | |||
| generated directly from the protocol specifications, and can be very rapid. | |||
| */ | |||
| type methodFrame struct { | |||
| ChannelId uint16 | |||
| ClassId uint16 | |||
| MethodId uint16 | |||
| Method message | |||
| } | |||
| func (f *methodFrame) channel() uint16 { return f.ChannelId } | |||
| /* | |||
| Heartbeating is a technique designed to undo one of TCP/IP's features, namely | |||
| its ability to recover from a broken physical connection by closing only after | |||
| a quite long time-out. In some scenarios we need to know very rapidly if a | |||
| peer is disconnected or not responding for other reasons (e.g. it is looping). | |||
| Since heartbeating can be done at a low level, we implement this as a special | |||
| type of frame that peers exchange at the transport level, rather than as a | |||
| class method. | |||
| */ | |||
| type heartbeatFrame struct { | |||
| ChannelId uint16 | |||
| } | |||
| func (f *heartbeatFrame) channel() uint16 { return f.ChannelId } | |||
| /* | |||
| Certain methods (such as Basic.Publish, Basic.Deliver, etc.) are formally | |||
| defined as carrying content. When a peer sends such a method frame, it always | |||
| follows it with a content header and zero or more content body frames. | |||
| A content header frame has this format: | |||
| 0 2 4 12 14 | |||
| +----------+--------+-----------+----------------+------------- - - | |||
| | class-id | weight | body size | property flags | property list... | |||
| +----------+--------+-----------+----------------+------------- - - | |||
| short short long long short remainder... | |||
| We place content body in distinct frames (rather than including it in the | |||
| method) so that AMQP may support "zero copy" techniques in which content is | |||
| never marshalled or encoded. We place the content properties in their own | |||
| frame so that recipients can selectively discard contents they do not want to | |||
| process | |||
| */ | |||
| type headerFrame struct { | |||
| ChannelId uint16 | |||
| ClassId uint16 | |||
| weight uint16 | |||
| Size uint64 | |||
| Properties properties | |||
| } | |||
| func (f *headerFrame) channel() uint16 { return f.ChannelId } | |||
| /* | |||
| Content is the application data we carry from client-to-client via the AMQP | |||
| server. Content is, roughly speaking, a set of properties plus a binary data | |||
| part. The set of allowed properties are defined by the Basic class, and these | |||
| form the "content header frame". The data can be any size, and MAY be broken | |||
| into several (or many) chunks, each forming a "content body frame". | |||
| Looking at the frames for a specific channel, as they pass on the wire, we | |||
| might see something like this: | |||
| [method] | |||
| [method] [header] [body] [body] | |||
| [method] | |||
| ... | |||
| */ | |||
| type bodyFrame struct { | |||
| ChannelId uint16 | |||
| Body []byte | |||
| } | |||
| func (f *bodyFrame) channel() uint16 { return f.ChannelId } | |||
+ 0
- 176
vendor/github.com/streadway/amqp/uri.go
View File
| @ -1,176 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "errors" | |||
| "net" | |||
| "net/url" | |||
| "strconv" | |||
| "strings" | |||
| ) | |||
| var errURIScheme = errors.New("AMQP scheme must be either 'amqp://' or 'amqps://'") | |||
| var errURIWhitespace = errors.New("URI must not contain whitespace") | |||
| var schemePorts = map[string]int{ | |||
| "amqp": 5672, | |||
| "amqps": 5671, | |||
| } | |||
| var defaultURI = URI{ | |||
| Scheme: "amqp", | |||
| Host: "localhost", | |||
| Port: 5672, | |||
| Username: "guest", | |||
| Password: "guest", | |||
| Vhost: "/", | |||
| } | |||
| // URI represents a parsed AMQP URI string. | |||
| type URI struct { | |||
| Scheme string | |||
| Host string | |||
| Port int | |||
| Username string | |||
| Password string | |||
| Vhost string | |||
| } | |||
| // ParseURI attempts to parse the given AMQP URI according to the spec. | |||
| // See http://www.rabbitmq.com/uri-spec.html. | |||
| // | |||
| // Default values for the fields are: | |||
| // | |||
| // Scheme: amqp | |||
| // Host: localhost | |||
| // Port: 5672 | |||
| // Username: guest | |||
| // Password: guest | |||
| // Vhost: / | |||
| // | |||
| func ParseURI(uri string) (URI, error) { | |||
| builder := defaultURI | |||
| if strings.Contains(uri, " ") == true { | |||
| return builder, errURIWhitespace | |||
| } | |||
| u, err := url.Parse(uri) | |||
| if err != nil { | |||
| return builder, err | |||
| } | |||
| defaultPort, okScheme := schemePorts[u.Scheme] | |||
| if okScheme { | |||
| builder.Scheme = u.Scheme | |||
| } else { | |||
| return builder, errURIScheme | |||
| } | |||
| host := u.Hostname() | |||
| port := u.Port() | |||
| if host != "" { | |||
| builder.Host = host | |||
| } | |||
| if port != "" { | |||
| port32, err := strconv.ParseInt(port, 10, 32) | |||
| if err != nil { | |||
| return builder, err | |||
| } | |||
| builder.Port = int(port32) | |||
| } else { | |||
| builder.Port = defaultPort | |||
| } | |||
| if u.User != nil { | |||
| builder.Username = u.User.Username() | |||
| if password, ok := u.User.Password(); ok { | |||
| builder.Password = password | |||
| } | |||
| } | |||
| if u.Path != "" { | |||
| if strings.HasPrefix(u.Path, "/") { | |||
| if u.Host == "" && strings.HasPrefix(u.Path, "///") { | |||
| // net/url doesn't handle local context authorities and leaves that up | |||
| // to the scheme handler. In our case, we translate amqp:/// into the | |||
| // default host and whatever the vhost should be | |||
| if len(u.Path) > 3 { | |||
| builder.Vhost = u.Path[3:] | |||
| } | |||
| } else if len(u.Path) > 1 { | |||
| builder.Vhost = u.Path[1:] | |||
| } | |||
| } else { | |||
| builder.Vhost = u.Path | |||
| } | |||
| } | |||
| return builder, nil | |||
| } | |||
| // PlainAuth returns a PlainAuth structure based on the parsed URI's | |||
| // Username and Password fields. | |||
| func (uri URI) PlainAuth() *PlainAuth { | |||
| return &PlainAuth{ | |||
| Username: uri.Username, | |||
| Password: uri.Password, | |||
| } | |||
| } | |||
| // AMQPlainAuth returns a PlainAuth structure based on the parsed URI's | |||
| // Username and Password fields. | |||
| func (uri URI) AMQPlainAuth() *AMQPlainAuth { | |||
| return &AMQPlainAuth{ | |||
| Username: uri.Username, | |||
| Password: uri.Password, | |||
| } | |||
| } | |||
| func (uri URI) String() string { | |||
| authority, err := url.Parse("") | |||
| if err != nil { | |||
| return err.Error() | |||
| } | |||
| authority.Scheme = uri.Scheme | |||
| if uri.Username != defaultURI.Username || uri.Password != defaultURI.Password { | |||
| authority.User = url.User(uri.Username) | |||
| if uri.Password != defaultURI.Password { | |||
| authority.User = url.UserPassword(uri.Username, uri.Password) | |||
| } | |||
| } | |||
| authority.Host = net.JoinHostPort(uri.Host, strconv.Itoa(uri.Port)) | |||
| if defaultPort, found := schemePorts[uri.Scheme]; !found || defaultPort != uri.Port { | |||
| authority.Host = net.JoinHostPort(uri.Host, strconv.Itoa(uri.Port)) | |||
| } else { | |||
| // JoinHostPort() automatically add brackets to the host if it's | |||
| // an IPv6 address. | |||
| // | |||
| // If not port is specified, JoinHostPort() return an IP address in the | |||
| // form of "[::1]:", so we use TrimSuffix() to remove the extra ":". | |||
| authority.Host = strings.TrimSuffix(net.JoinHostPort(uri.Host, ""), ":") | |||
| } | |||
| if uri.Vhost != defaultURI.Vhost { | |||
| // Make sure net/url does not double escape, e.g. | |||
| // "%2F" does not become "%252F". | |||
| authority.Path = uri.Vhost | |||
| authority.RawPath = url.QueryEscape(uri.Vhost) | |||
| } else { | |||
| authority.Path = "/" | |||
| } | |||
| return authority.String() | |||
| } | |||
+ 0
- 416
vendor/github.com/streadway/amqp/write.go
View File
| @ -1,416 +0,0 @@ | |||
| // Copyright (c) 2012, Sean Treadway, SoundCloud Ltd. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // Source code and contact info at http://github.com/streadway/amqp | |||
| package amqp | |||
| import ( | |||
| "bufio" | |||
| "bytes" | |||
| "encoding/binary" | |||
| "errors" | |||
| "io" | |||
| "math" | |||
| "time" | |||
| ) | |||
| func (w *writer) WriteFrame(frame frame) (err error) { | |||
| if err = frame.write(w.w); err != nil { | |||
| return | |||
| } | |||
| if buf, ok := w.w.(*bufio.Writer); ok { | |||
| err = buf.Flush() | |||
| } | |||
| return | |||
| } | |||
| func (f *methodFrame) write(w io.Writer) (err error) { | |||
| var payload bytes.Buffer | |||
| if f.Method == nil { | |||
| return errors.New("malformed frame: missing method") | |||
| } | |||
| class, method := f.Method.id() | |||
| if err = binary.Write(&payload, binary.BigEndian, class); err != nil { | |||
| return | |||
| } | |||
| if err = binary.Write(&payload, binary.BigEndian, method); err != nil { | |||
| return | |||
| } | |||
| if err = f.Method.write(&payload); err != nil { | |||
| return | |||
| } | |||
| return writeFrame(w, frameMethod, f.ChannelId, payload.Bytes()) | |||
| } | |||
| // Heartbeat | |||
| // | |||
| // Payload is empty | |||
| func (f *heartbeatFrame) write(w io.Writer) (err error) { | |||
| return writeFrame(w, frameHeartbeat, f.ChannelId, []byte{}) | |||
| } | |||
| // CONTENT HEADER | |||
| // 0 2 4 12 14 | |||
| // +----------+--------+-----------+----------------+------------- - - | |||
| // | class-id | weight | body size | property flags | property list... | |||
| // +----------+--------+-----------+----------------+------------- - - | |||
| // short short long long short remainder... | |||
| // | |||
| func (f *headerFrame) write(w io.Writer) (err error) { | |||
| var payload bytes.Buffer | |||
| var zeroTime time.Time | |||
| if err = binary.Write(&payload, binary.BigEndian, f.ClassId); err != nil { | |||
| return | |||
| } | |||
| if err = binary.Write(&payload, binary.BigEndian, f.weight); err != nil { | |||
| return | |||
| } | |||
| if err = binary.Write(&payload, binary.BigEndian, f.Size); err != nil { | |||
| return | |||
| } | |||
| // First pass will build the mask to be serialized, second pass will serialize | |||
| // each of the fields that appear in the mask. | |||
| var mask uint16 | |||
| if len(f.Properties.ContentType) > 0 { | |||
| mask = mask | flagContentType | |||
| } | |||
| if len(f.Properties.ContentEncoding) > 0 { | |||
| mask = mask | flagContentEncoding | |||
| } | |||
| if f.Properties.Headers != nil && len(f.Properties.Headers) > 0 { | |||
| mask = mask | flagHeaders | |||
| } | |||
| if f.Properties.DeliveryMode > 0 { | |||
| mask = mask | flagDeliveryMode | |||
| } | |||
| if f.Properties.Priority > 0 { | |||
| mask = mask | flagPriority | |||
| } | |||
| if len(f.Properties.CorrelationId) > 0 { | |||
| mask = mask | flagCorrelationId | |||
| } | |||
| if len(f.Properties.ReplyTo) > 0 { | |||
| mask = mask | flagReplyTo | |||
| } | |||
| if len(f.Properties.Expiration) > 0 { | |||
| mask = mask | flagExpiration | |||
| } | |||
| if len(f.Properties.MessageId) > 0 { | |||
| mask = mask | flagMessageId | |||
| } | |||
| if f.Properties.Timestamp != zeroTime { | |||
| mask = mask | flagTimestamp | |||
| } | |||
| if len(f.Properties.Type) > 0 { | |||
| mask = mask | flagType | |||
| } | |||
| if len(f.Properties.UserId) > 0 { | |||
| mask = mask | flagUserId | |||
| } | |||
| if len(f.Properties.AppId) > 0 { | |||
| mask = mask | flagAppId | |||
| } | |||
| if err = binary.Write(&payload, binary.BigEndian, mask); err != nil { | |||
| return | |||
| } | |||
| if hasProperty(mask, flagContentType) { | |||
| if err = writeShortstr(&payload, f.Properties.ContentType); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagContentEncoding) { | |||
| if err = writeShortstr(&payload, f.Properties.ContentEncoding); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagHeaders) { | |||
| if err = writeTable(&payload, f.Properties.Headers); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagDeliveryMode) { | |||
| if err = binary.Write(&payload, binary.BigEndian, f.Properties.DeliveryMode); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagPriority) { | |||
| if err = binary.Write(&payload, binary.BigEndian, f.Properties.Priority); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagCorrelationId) { | |||
| if err = writeShortstr(&payload, f.Properties.CorrelationId); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagReplyTo) { | |||
| if err = writeShortstr(&payload, f.Properties.ReplyTo); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagExpiration) { | |||
| if err = writeShortstr(&payload, f.Properties.Expiration); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagMessageId) { | |||
| if err = writeShortstr(&payload, f.Properties.MessageId); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagTimestamp) { | |||
| if err = binary.Write(&payload, binary.BigEndian, uint64(f.Properties.Timestamp.Unix())); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagType) { | |||
| if err = writeShortstr(&payload, f.Properties.Type); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagUserId) { | |||
| if err = writeShortstr(&payload, f.Properties.UserId); err != nil { | |||
| return | |||
| } | |||
| } | |||
| if hasProperty(mask, flagAppId) { | |||
| if err = writeShortstr(&payload, f.Properties.AppId); err != nil { | |||
| return | |||
| } | |||
| } | |||
| return writeFrame(w, frameHeader, f.ChannelId, payload.Bytes()) | |||
| } | |||
| // Body | |||
| // | |||
| // Payload is one byterange from the full body who's size is declared in the | |||
| // Header frame | |||
| func (f *bodyFrame) write(w io.Writer) (err error) { | |||
| return writeFrame(w, frameBody, f.ChannelId, f.Body) | |||
| } | |||
| func writeFrame(w io.Writer, typ uint8, channel uint16, payload []byte) (err error) { | |||
| end := []byte{frameEnd} | |||
| size := uint(len(payload)) | |||
| _, err = w.Write([]byte{ | |||
| byte(typ), | |||
| byte((channel & 0xff00) >> 8), | |||
| byte((channel & 0x00ff) >> 0), | |||
| byte((size & 0xff000000) >> 24), | |||
| byte((size & 0x00ff0000) >> 16), | |||
| byte((size & 0x0000ff00) >> 8), | |||
| byte((size & 0x000000ff) >> 0), | |||
| }) | |||
| if err != nil { | |||
| return | |||
| } | |||
| if _, err = w.Write(payload); err != nil { | |||
| return | |||
| } | |||
| if _, err = w.Write(end); err != nil { | |||
| return | |||
| } | |||
| return | |||
| } | |||
| func writeShortstr(w io.Writer, s string) (err error) { | |||
| b := []byte(s) | |||
| var length = uint8(len(b)) | |||
| if err = binary.Write(w, binary.BigEndian, length); err != nil { | |||
| return | |||
| } | |||
| if _, err = w.Write(b[:length]); err != nil { | |||
| return | |||
| } | |||
| return | |||
| } | |||
| func writeLongstr(w io.Writer, s string) (err error) { | |||
| b := []byte(s) | |||
| var length = uint32(len(b)) | |||
| if err = binary.Write(w, binary.BigEndian, length); err != nil { | |||
| return | |||
| } | |||
| if _, err = w.Write(b[:length]); err != nil { | |||
| return | |||
| } | |||
| return | |||
| } | |||
| /* | |||
| 'A': []interface{} | |||
| 'D': Decimal | |||
| 'F': Table | |||
| 'I': int32 | |||
| 'S': string | |||
| 'T': time.Time | |||
| 'V': nil | |||
| 'b': byte | |||
| 'd': float64 | |||
| 'f': float32 | |||
| 'l': int64 | |||
| 's': int16 | |||
| 't': bool | |||
| 'x': []byte | |||
| */ | |||
| func writeField(w io.Writer, value interface{}) (err error) { | |||
| var buf [9]byte | |||
| var enc []byte | |||
| switch v := value.(type) { | |||
| case bool: | |||
| buf[0] = 't' | |||
| if v { | |||
| buf[1] = byte(1) | |||
| } else { | |||
| buf[1] = byte(0) | |||
| } | |||
| enc = buf[:2] | |||
| case byte: | |||
| buf[0] = 'b' | |||
| buf[1] = byte(v) | |||
| enc = buf[:2] | |||
| case int16: | |||
| buf[0] = 's' | |||
| binary.BigEndian.PutUint16(buf[1:3], uint16(v)) | |||
| enc = buf[:3] | |||
| case int: | |||
| buf[0] = 'I' | |||
| binary.BigEndian.PutUint32(buf[1:5], uint32(v)) | |||
| enc = buf[:5] | |||
| case int32: | |||
| buf[0] = 'I' | |||
| binary.BigEndian.PutUint32(buf[1:5], uint32(v)) | |||
| enc = buf[:5] | |||
| case int64: | |||
| buf[0] = 'l' | |||
| binary.BigEndian.PutUint64(buf[1:9], uint64(v)) | |||
| enc = buf[:9] | |||
| case float32: | |||
| buf[0] = 'f' | |||
| binary.BigEndian.PutUint32(buf[1:5], math.Float32bits(v)) | |||
| enc = buf[:5] | |||
| case float64: | |||
| buf[0] = 'd' | |||
| binary.BigEndian.PutUint64(buf[1:9], math.Float64bits(v)) | |||
| enc = buf[:9] | |||
| case Decimal: | |||
| buf[0] = 'D' | |||
| buf[1] = byte(v.Scale) | |||
| binary.BigEndian.PutUint32(buf[2:6], uint32(v.Value)) | |||
| enc = buf[:6] | |||
| case string: | |||
| buf[0] = 'S' | |||
| binary.BigEndian.PutUint32(buf[1:5], uint32(len(v))) | |||
| enc = append(buf[:5], []byte(v)...) | |||
| case []interface{}: // field-array | |||
| buf[0] = 'A' | |||
| sec := new(bytes.Buffer) | |||
| for _, val := range v { | |||
| if err = writeField(sec, val); err != nil { | |||
| return | |||
| } | |||
| } | |||
| binary.BigEndian.PutUint32(buf[1:5], uint32(sec.Len())) | |||
| if _, err = w.Write(buf[:5]); err != nil { | |||
| return | |||
| } | |||
| if _, err = w.Write(sec.Bytes()); err != nil { | |||
| return | |||
| } | |||
| return | |||
| case time.Time: | |||
| buf[0] = 'T' | |||
| binary.BigEndian.PutUint64(buf[1:9], uint64(v.Unix())) | |||
| enc = buf[:9] | |||
| case Table: | |||
| if _, err = w.Write([]byte{'F'}); err != nil { | |||
| return | |||
| } | |||
| return writeTable(w, v) | |||
| case []byte: | |||
| buf[0] = 'x' | |||
| binary.BigEndian.PutUint32(buf[1:5], uint32(len(v))) | |||
| if _, err = w.Write(buf[0:5]); err != nil { | |||
| return | |||
| } | |||
| if _, err = w.Write(v); err != nil { | |||
| return | |||
| } | |||
| return | |||
| case nil: | |||
| buf[0] = 'V' | |||
| enc = buf[:1] | |||
| default: | |||
| return ErrFieldType | |||
| } | |||
| _, err = w.Write(enc) | |||
| return | |||
| } | |||
| func writeTable(w io.Writer, table Table) (err error) { | |||
| var buf bytes.Buffer | |||
| for key, val := range table { | |||
| if err = writeShortstr(&buf, key); err != nil { | |||
| return | |||
| } | |||
| if err = writeField(&buf, val); err != nil { | |||
| return | |||
| } | |||
| } | |||
| return writeLongstr(w, string(buf.Bytes())) | |||
| } | |||
+ 2
- 2
vendor/modules.txt
View File
| @ -1,3 +1,3 @@ | |||
| # github.com/streadway/amqp v1.0.0 | |||
| # github.com/rabbitmq/amqp091-go v0.0.0-20210823000215-c428a6150891 | |||
| ## explicit | |||
| github.com/streadway/amqp | |||
| github.com/rabbitmq/amqp091-go | |||