You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by ac...@apache.org on 2015/09/28 23:22:41 UTC
[22/50] [abbrv] qpid-proton git commit: PROTON-827: Switch go
directory and symlink locations, problems with some go tools.
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/event/message.go
----------------------------------------------------------------------
diff --git a/go/event/message.go b/go/event/message.go
new file mode 100644
index 0000000..d900744
--- /dev/null
+++ b/go/event/message.go
@@ -0,0 +1,75 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package event
+
+// #include <proton/types.h>
+// #include <proton/message.h>
+// #include <proton/codec.h>
+import "C"
+
+import (
+ "qpid.apache.org/proton/go/amqp"
+ "qpid.apache.org/proton/go/internal"
+)
+
+// DecodeMessage decodes the message containined in a delivery event.
+func DecodeMessage(e Event) (m amqp.Message, err error) {
+ defer internal.DoRecover(&err)
+ delivery := e.Delivery()
+ if !delivery.Readable() || delivery.Partial() {
+ return nil, internal.Errorf("attempting to get incomplete message")
+ }
+ data := make([]byte, delivery.Pending())
+ result := delivery.Link().Recv(data)
+ if result != len(data) {
+ return nil, internal.Errorf("cannot receive message: %s", internal.PnErrorCode(result))
+ }
+ return amqp.DecodeMessage(data)
+}
+
+// FIXME aconway 2015-04-08: proper handling of delivery tags. Tag counter per link.
+var tags amqp.UidCounter
+
+// Send sends a amqp.Message over a Link.
+// Returns a Delivery that can be use to determine the outcome of the message.
+func (link Link) Send(m amqp.Message) (Delivery, error) {
+ if !link.IsSender() {
+ return Delivery{}, internal.Errorf("attempt to send message on receiving link")
+ }
+ // FIXME aconway 2015-04-08: buffering, error handling
+ delivery := link.Delivery(tags.Next())
+ bytes, err := m.Encode(nil)
+ if err != nil {
+ return Delivery{}, internal.Errorf("cannot send mesage %s", err)
+ }
+ result := link.SendBytes(bytes)
+ link.Advance()
+ if result != len(bytes) {
+ if result < 0 {
+ return delivery, internal.Errorf("send failed %v", internal.PnErrorCode(result))
+ } else {
+ return delivery, internal.Errorf("send incomplete %v of %v", result, len(bytes))
+ }
+ }
+ if link.RemoteSndSettleMode() == PnSndSettled { // FIXME aconway 2015-04-08: enum names
+ delivery.Settle()
+ }
+ return delivery, nil
+}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/event/pump.go
----------------------------------------------------------------------
diff --git a/go/event/pump.go b/go/event/pump.go
new file mode 100644
index 0000000..db022ff
--- /dev/null
+++ b/go/event/pump.go
@@ -0,0 +1,357 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package event
+
+// #include <proton/connection.h>
+// #include <proton/transport.h>
+// #include <proton/event.h>
+// #include <proton/reactor.h>
+// #include <proton/handlers.h>
+// #include <proton/transport.h>
+// #include <proton/session.h>
+// #include <memory.h>
+// #include <stdlib.h>
+//
+// PN_HANDLE(REMOTE_ADDR)
+import "C"
+
+import (
+ "fmt"
+ "io"
+ "net"
+ "qpid.apache.org/proton/go/internal"
+ "sync"
+ "unsafe"
+)
+
+// bufferChan manages a pair of ping-pong buffers to pass bytes through a channel.
+type bufferChan struct {
+ buffers chan []byte
+ buf1, buf2 []byte
+}
+
+func newBufferChan(size int) *bufferChan {
+ return &bufferChan{make(chan []byte), make([]byte, size), make([]byte, size)}
+}
+
+func (b *bufferChan) buffer() []byte {
+ b.buf1, b.buf2 = b.buf2, b.buf1 // Alternate buffers.
+ return b.buf1[:cap(b.buf1)]
+}
+
+// FIXME aconway 2015-05-04: direct sending to Inject may block user goroutines if
+// the pum stops. Make this a function that selects on running.
+
+// FIXME aconway 2015-05-05: for consistency should Pump be called Driver?
+
+/*
+Pump reads from a net.Conn, decodes AMQP events and calls the appropriate
+Handler functions. Actions taken by Handler functions (such as sending messages)
+are encoded and written to the net.Conn.
+
+The proton protocol engine is single threaded (per connection). The Pump runs
+proton in the goroutine that calls Pump.Run() and creates goroutines to feed
+data to/from a net.Conn. You can create multiple Pumps to handle multiple
+connections concurrently.
+
+Methods in this package can only be called in the goroutine that executes the
+corresponding Pump.Run(). You implement the EventHandler or MessagingHandler
+interfaces and provide those values to NewPump(). Their HandleEvent method will be
+called in the Pump goroutine, in typical event-driven style.
+
+Handlers can pass values from an event (Connections, Links, Deliveries etc.) to
+other goroutines, store them, or use them as map indexes. Effectively they are
+just C pointers. Other goroutines cannot call their methods directly but they
+can can create function closures that call their methods and send those closures
+to the Pump.Inject channel. They will execute safely in the pump
+goroutine. Injected functions, or your handlers, can set up channels to get
+results back to other goroutines.
+
+You are responsible for ensuring you don't use an event value after the C object
+has been deleted. The handler methods will tell you when a value is no longer
+valid. For example after a MethodHandler handles a LinkClosed event, that link
+is no longer valid. If you do Link.Close() yourself (in a handler or injected
+function) the link remains valid until the corresponing LinkClosed event is
+received by the handler.
+
+Pump.Close() will take care of cleaning up any remaining values and types when
+you are done with the Pump. All values associated with a pump become invalid
+when you call Pump.Close()
+
+The qpid.apache.org/proton/go/messaging package will do all this for you, so unless
+you are doing something fairly low-level it is probably a better choice.
+
+*/
+type Pump struct {
+ // Error is set on exit from Run() if there was an error.
+ Error error
+ // Channel to inject functions to be executed in the Pump's proton event loop.
+ Inject chan func()
+
+ conn net.Conn
+ transport *C.pn_transport_t
+ connection *C.pn_connection_t
+ collector *C.pn_collector_t
+ read *bufferChan // Read buffers channel.
+ write *bufferChan // Write buffers channel.
+ handlers []EventHandler // Handlers for proton events.
+ running chan struct{} // This channel will be closed when the goroutines are done.
+}
+
+const bufferSize = 4096
+
+var pumps map[*C.pn_connection_t]*Pump
+
+func init() {
+ pumps = make(map[*C.pn_connection_t]*Pump)
+}
+
+// NewPump initializes a pump with a connection and handlers. To start it running:
+// p := NewPump(...)
+// go run p.Run()
+// The goroutine will exit when the pump is closed or disconnected.
+// You can check for errors on Pump.Error.
+//
+func NewPump(conn net.Conn, handlers ...EventHandler) (*Pump, error) {
+ // Save the connection ID for Connection.String()
+ p := &Pump{
+ Inject: make(chan func(), 100), // FIXME aconway 2015-05-04: blocking hack
+ conn: conn,
+ transport: C.pn_transport(),
+ connection: C.pn_connection(),
+ collector: C.pn_collector(),
+ handlers: handlers,
+ read: newBufferChan(bufferSize),
+ write: newBufferChan(bufferSize),
+ running: make(chan struct{}),
+ }
+ if p.transport == nil || p.connection == nil || p.collector == nil {
+ return nil, internal.Errorf("failed to allocate pump")
+ }
+ pnErr := int(C.pn_transport_bind(p.transport, p.connection))
+ if pnErr != 0 {
+ return nil, internal.Errorf("cannot setup pump: %s", internal.PnErrorCode(pnErr))
+ }
+ C.pn_connection_collect(p.connection, p.collector)
+ C.pn_connection_open(p.connection)
+ pumps[p.connection] = p
+ return p, nil
+}
+
+func (p *Pump) String() string {
+ return fmt.Sprintf("(%s-%s)", p.conn.LocalAddr(), p.conn.RemoteAddr())
+}
+
+func (p *Pump) Id() string {
+ return fmt.Sprintf("%p", &p)
+}
+
+// setError sets error only if not already set
+func (p *Pump) setError(e error) {
+ if p.Error == nil {
+ p.Error = e
+ }
+}
+
+// Server puts the Pump in server mode, meaning it will auto-detect security settings on
+// the incoming connnection such as use of SASL and SSL.
+// Must be called before Run()
+//
+func (p *Pump) Server() {
+ C.pn_transport_set_server(p.transport)
+}
+
+func (p *Pump) free() {
+ if p.connection != nil {
+ C.pn_connection_free(p.connection)
+ }
+ if p.transport != nil {
+ C.pn_transport_free(p.transport)
+ }
+ if p.collector != nil {
+ C.pn_collector_free(p.collector)
+ }
+ for _, h := range p.handlers {
+ switch h := h.(type) {
+ case cHandler:
+ C.pn_handler_free(h.pn)
+ }
+ }
+}
+
+// Close closes the AMQP connection, the net.Conn, and stops associated goroutines.
+// It will cause Run() to return. Run() may return earlier if the network disconnects
+// but you must still call Close() to clean everything up.
+//
+// Methods on values associated with the pump (Connections, Sessions, Links) will panic
+// if called after Close()
+//
+func (p *Pump) Close() error {
+ // If the pump is still running, inject a close. Either way wait for it to finish.
+ select {
+ case p.Inject <- func() { C.pn_connection_close(p.connection) }:
+ <-p.running // Wait to finish
+ case <-p.running: // Wait for goroutines to finish
+ }
+ delete(pumps, p.connection)
+ p.free()
+ return p.Error
+}
+
+// Run the pump. Normally called in a goroutine as: go pump.Run()
+// An error dunring Run is stored on p.Error.
+//
+func (p *Pump) Run() {
+ // Signal errors from the read/write goroutines. Don't block if we don't
+ // read all the errors, we only care about the first.
+ error := make(chan error, 2)
+ // FIXME aconway 2015-05-04: stop := make(chan struct{}) // Closed to signal that read/write should stop.
+
+ wait := sync.WaitGroup{}
+ wait.Add(2)
+
+ go func() { // Read goroutine
+ defer wait.Done()
+ for {
+ rbuf := p.read.buffer()
+ n, err := p.conn.Read(rbuf)
+ if n > 0 {
+ p.read.buffers <- rbuf[:n]
+ } else if err != nil {
+ close(p.read.buffers)
+ error <- err
+ return
+ }
+ }
+ }()
+
+ go func() { // Write goroutine
+ defer wait.Done()
+ for {
+ wbuf, ok := <-p.write.buffers
+ if !ok {
+ return
+ }
+ _, err := p.conn.Write(wbuf)
+ if err != nil {
+ error <- err
+ return
+ }
+ }
+ }()
+
+ wbuf := p.write.buffer()[:0]
+loop:
+ for {
+ if len(wbuf) == 0 {
+ p.pop(&wbuf)
+ }
+ // Don't set wchan unless there is something to write.
+ var wchan chan []byte
+ if len(wbuf) > 0 {
+ wchan = p.write.buffers
+ }
+
+ select {
+ case buf := <-p.read.buffers: // Read a buffer
+ p.push(buf)
+ case wchan <- wbuf: // Write a buffer
+ wbuf = p.write.buffer()[:0]
+ case f := <-p.Inject: // Function injected from another goroutine
+ f()
+ case err := <-error: // Read or write error
+ p.setError(err)
+ C.pn_transport_close_tail(p.transport)
+ C.pn_transport_close_head(p.transport)
+ }
+ if err := p.process(); err != nil {
+ p.setError(err)
+ break loop
+ }
+ }
+ close(p.write.buffers)
+ p.conn.Close()
+ wait.Wait()
+ close(p.running) // Signal goroutines have exited and Error is set.
+}
+
+func minInt(a, b int) int {
+ if a < b {
+ return a
+ } else {
+ return b
+ }
+}
+
+func (p *Pump) pop(buf *[]byte) {
+ pending := int(C.pn_transport_pending(p.transport))
+ switch {
+ case pending == int(C.PN_EOS):
+ *buf = (*buf)[:]
+ return
+ case pending < 0:
+ panic(internal.Errorf("%s", internal.PnErrorCode(pending)))
+ }
+ size := minInt(pending, cap(*buf))
+ *buf = (*buf)[:size]
+ if size == 0 {
+ return
+ }
+ C.memcpy(unsafe.Pointer(&(*buf)[0]), unsafe.Pointer(C.pn_transport_head(p.transport)), C.size_t(size))
+ C.pn_transport_pop(p.transport, C.size_t(size))
+}
+
+func (p *Pump) push(buf []byte) {
+ buf2 := buf
+ for len(buf2) > 0 {
+ n := int(C.pn_transport_push(p.transport, (*C.char)(unsafe.Pointer((&buf2[0]))), C.size_t(len(buf2))))
+ if n <= 0 {
+ panic(internal.Errorf("error in transport: %s", internal.PnErrorCode(n)))
+ }
+ buf2 = buf2[n:]
+ }
+}
+
+func (p *Pump) handle(e Event) error {
+ for _, h := range p.handlers {
+ if err := h.HandleEvent(e); err != nil {
+ return err
+ }
+ }
+ if e.Type() == ETransportClosed {
+ return io.EOF
+ }
+ return nil
+}
+
+func (p *Pump) process() error {
+ // FIXME aconway 2015-05-04: if a Handler returns error we should stop the pump
+ for ce := C.pn_collector_peek(p.collector); ce != nil; ce = C.pn_collector_peek(p.collector) {
+ e := makeEvent(ce)
+ if err := p.handle(e); err != nil {
+ return err
+ }
+ C.pn_collector_pop(p.collector)
+ }
+ return nil
+}
+
+// Connectoin gets the Pump's connection value.
+func (p *Pump) Connection() Connection { return Connection{p.connection} }
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/event/wrappers.go
----------------------------------------------------------------------
diff --git a/go/event/wrappers.go b/go/event/wrappers.go
new file mode 100644
index 0000000..7043b9c
--- /dev/null
+++ b/go/event/wrappers.go
@@ -0,0 +1,253 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package event
+
+//#include <proton/codec.h>
+//#include <proton/connection.h>
+//#include <proton/session.h>
+//#include <proton/session.h>
+//#include <proton/delivery.h>
+//#include <proton/link.h>
+//#include <proton/event.h>
+//#include <proton/transport.h>
+//#include <proton/link.h>
+//#include <stdlib.h>
+import "C"
+
+import (
+ "fmt"
+ "qpid.apache.org/proton/go/internal"
+ "unsafe"
+)
+
+// FIXME aconway 2015-05-05: Documentation for generated types.
+
+// Event is an AMQP protocol event.
+type Event struct {
+ pn *C.pn_event_t
+ eventType EventType
+ connection Connection
+ session Session
+ link Link
+ delivery Delivery
+}
+
+func makeEvent(pn *C.pn_event_t) Event {
+ return Event{
+ pn: pn,
+ eventType: EventType(C.pn_event_type(pn)),
+ connection: Connection{C.pn_event_connection(pn)},
+ session: Session{C.pn_event_session(pn)},
+ link: Link{C.pn_event_link(pn)},
+ delivery: Delivery{C.pn_event_delivery(pn)},
+ }
+}
+func (e Event) IsNil() bool { return e.eventType == EventType(0) }
+func (e Event) Type() EventType { return e.eventType }
+func (e Event) Connection() Connection { return e.connection }
+func (e Event) Session() Session { return e.session }
+func (e Event) Link() Link { return e.link }
+func (e Event) Delivery() Delivery { return e.delivery }
+func (e Event) String() string { return e.Type().String() }
+
+// Data holds a pointer to decoded AMQP data.
+// Use amqp.marshal/unmarshal to access it as Go data types.
+//
+type Data struct{ pn *C.pn_data_t }
+
+func NewData(p unsafe.Pointer) Data { return Data{(*C.pn_data_t)(p)} }
+
+func (d Data) Free() { C.pn_data_free(d.pn) }
+func (d Data) Pointer() unsafe.Pointer { return unsafe.Pointer(d.pn) }
+func (d Data) Clear() { C.pn_data_clear(d.pn) }
+func (d Data) Rewind() { C.pn_data_rewind(d.pn) }
+func (d Data) Error() error {
+ return internal.PnError(unsafe.Pointer(C.pn_data_error(d.pn)))
+}
+
+// State holds the state flags for an AMQP endpoint.
+type State byte
+
+const (
+ SLocalUninit State = C.PN_LOCAL_UNINIT
+ SLocalActive = C.PN_LOCAL_ACTIVE
+ SLocalClosed = C.PN_LOCAL_CLOSED
+ SRemoteUninit = C.PN_REMOTE_UNINIT
+ SRemoteActive = C.PN_REMOTE_ACTIVE
+ SRemoteClosed = C.PN_REMOTE_CLOSED
+)
+
+// Is is True if bits & state is non 0.
+func (s State) Is(bits State) bool { return s&bits != 0 }
+
+// Return a State containig just the local flags
+func (s State) Local() State { return State(s & C.PN_LOCAL_MASK) }
+
+// Return a State containig just the remote flags
+func (s State) Remote() State { return State(s & C.PN_REMOTE_MASK) }
+
+// Endpoint is the common interface for Connection, Link and Session.
+type Endpoint interface {
+ // State is the open/closed state.
+ State() State
+ // Open an endpoint.
+ Open()
+ // Close an endpoint.
+ Close()
+ // Condition holds a local error condition.
+ Condition() Condition
+ // RemoteCondition holds a remote error condition.
+ RemoteCondition() Condition
+}
+
+const (
+ Received uint64 = C.PN_RECEIVED
+ Accepted = C.PN_ACCEPTED
+ Rejected = C.PN_REJECTED
+ Released = C.PN_RELEASED
+ Modified = C.PN_MODIFIED
+)
+
+// SettleAs is equivalent to d.Update(disposition); d.Settle()
+// It is a no-op if e does not have a delivery.
+func (d Delivery) SettleAs(disposition uint64) {
+ d.Update(disposition)
+ d.Settle()
+}
+
+// Accept accepts and settles a delivery.
+func (d Delivery) Accept() { d.SettleAs(Accepted) }
+
+// Reject rejects and settles a delivery
+func (d Delivery) Reject() { d.SettleAs(Rejected) }
+
+// Release releases and settles a delivery
+// If delivered is true the delivery count for the message will be increased.
+func (d Delivery) Release(delivered bool) {
+ if delivered {
+ d.SettleAs(Modified)
+ } else {
+ d.SettleAs(Released)
+ }
+}
+
+// FIXME aconway 2015-05-05: don't expose DeliveryTag as a C pointer, just as a String?
+
+type DeliveryTag struct{ pn C.pn_delivery_tag_t }
+
+func (t DeliveryTag) String() string { return C.GoStringN(t.pn.start, C.int(t.pn.size)) }
+
+func (l Link) Recv(buf []byte) int {
+ if len(buf) == 0 {
+ return 0
+ }
+ return int(C.pn_link_recv(l.pn, (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
+}
+
+func (l Link) SendBytes(bytes []byte) int {
+ return int(C.pn_link_send(l.pn, cPtr(bytes), cLen(bytes)))
+}
+
+func pnTag(tag string) C.pn_delivery_tag_t {
+ bytes := []byte(tag)
+ return C.pn_dtag(cPtr(bytes), cLen(bytes))
+}
+
+func (l Link) Delivery(tag string) Delivery {
+ return Delivery{C.pn_delivery(l.pn, pnTag(tag))}
+}
+
+func cPtr(b []byte) *C.char {
+ if len(b) == 0 {
+ return nil
+ }
+ return (*C.char)(unsafe.Pointer(&b[0]))
+}
+
+func cLen(b []byte) C.size_t {
+ return C.size_t(len(b))
+}
+
+func (s Session) Sender(name string) Link {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ return Link{C.pn_sender(s.pn, cname)}
+}
+
+func (s Session) Receiver(name string) Link {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ return Link{C.pn_receiver(s.pn, cname)}
+}
+
+func joinId(a, b interface{}) string {
+ return fmt.Sprintf("%s/%s", a, b)
+}
+
+// Pump associated with this connection.
+func (c Connection) Pump() *Pump { return pumps[c.pn] }
+
+// Unique (per process) string identifier for a connection, useful for debugging.
+func (c Connection) String() string { return pumps[c.pn].String() }
+
+// Head functions don't follow the normal naming conventions so missed by the generator.
+
+func (c Connection) LinkHead(s State) Link {
+ return Link{C.pn_link_head(c.pn, C.pn_state_t(s))}
+}
+
+func (c Connection) SessionHead(s State) Session {
+ return Session{C.pn_session_head(c.pn, C.pn_state_t(s))}
+}
+
+// Unique (per process) string identifier for a session, including connection identifier.
+func (s Session) String() string {
+ return joinId(s.Connection(), fmt.Sprintf("%p", s.pn))
+}
+
+// Unique (per process) string identifier for a link, inlcuding session identifier.
+func (l Link) String() string {
+ return joinId(l.Session(), l.Name())
+}
+
+// Error returns an error interface corresponding to Condition.
+func (c Condition) Error() error {
+ if c.IsNil() {
+ return nil
+ } else {
+ return fmt.Errorf("%s: %s", c.Name(), c.Description())
+ }
+}
+
+// SetIfUnset sets name and description on a condition if it is not already set.
+func (c Condition) SetIfUnset(name, description string) {
+ if !c.IsSet() {
+ c.SetName(name)
+ c.SetDescription(description)
+ }
+}
+
+func (c Connection) Session() (Session, error) {
+ s := Session{C.pn_session(c.pn)}
+ if s.IsNil() {
+ return s, Connection(c).Error()
+ }
+ return s, nil
+}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/event/wrappers_gen.go
----------------------------------------------------------------------
diff --git a/go/event/wrappers_gen.go b/go/event/wrappers_gen.go
new file mode 100644
index 0000000..73f0d3b
--- /dev/null
+++ b/go/event/wrappers_gen.go
@@ -0,0 +1,732 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+//
+// NOTE: This file was generated by genwrap.go, do not edit it by hand.
+//
+
+package event
+
+import (
+ "qpid.apache.org/proton/go/internal"
+ "time"
+ "unsafe"
+)
+
+// #include <proton/types.h>
+// #include <proton/event.h>
+// #include <stdlib.h>
+// #include <proton/session.h>
+// #include <proton/link.h>
+// #include <proton/delivery.h>
+// #include <proton/disposition.h>
+// #include <proton/condition.h>
+// #include <proton/terminus.h>
+// #include <proton/connection.h>
+import "C"
+
+type EventType int
+
+const (
+ EConnectionInit EventType = C.PN_CONNECTION_INIT
+ EConnectionBound EventType = C.PN_CONNECTION_BOUND
+ EConnectionUnbound EventType = C.PN_CONNECTION_UNBOUND
+ EConnectionLocalOpen EventType = C.PN_CONNECTION_LOCAL_OPEN
+ EConnectionRemoteOpen EventType = C.PN_CONNECTION_REMOTE_OPEN
+ EConnectionLocalClose EventType = C.PN_CONNECTION_LOCAL_CLOSE
+ EConnectionRemoteClose EventType = C.PN_CONNECTION_REMOTE_CLOSE
+ EConnectionFinal EventType = C.PN_CONNECTION_FINAL
+ ESessionInit EventType = C.PN_SESSION_INIT
+ ESessionLocalOpen EventType = C.PN_SESSION_LOCAL_OPEN
+ ESessionRemoteOpen EventType = C.PN_SESSION_REMOTE_OPEN
+ ESessionLocalClose EventType = C.PN_SESSION_LOCAL_CLOSE
+ ESessionRemoteClose EventType = C.PN_SESSION_REMOTE_CLOSE
+ ESessionFinal EventType = C.PN_SESSION_FINAL
+ ELinkInit EventType = C.PN_LINK_INIT
+ ELinkLocalOpen EventType = C.PN_LINK_LOCAL_OPEN
+ ELinkRemoteOpen EventType = C.PN_LINK_REMOTE_OPEN
+ ELinkLocalClose EventType = C.PN_LINK_LOCAL_CLOSE
+ ELinkRemoteClose EventType = C.PN_LINK_REMOTE_CLOSE
+ ELinkLocalDetach EventType = C.PN_LINK_LOCAL_DETACH
+ ELinkRemoteDetach EventType = C.PN_LINK_REMOTE_DETACH
+ ELinkFlow EventType = C.PN_LINK_FLOW
+ ELinkFinal EventType = C.PN_LINK_FINAL
+ EDelivery EventType = C.PN_DELIVERY
+ ETransport EventType = C.PN_TRANSPORT
+ ETransportAuthenticated EventType = C.PN_TRANSPORT_AUTHENTICATED
+ ETransportError EventType = C.PN_TRANSPORT_ERROR
+ ETransportHeadClosed EventType = C.PN_TRANSPORT_HEAD_CLOSED
+ ETransportTailClosed EventType = C.PN_TRANSPORT_TAIL_CLOSED
+ ETransportClosed EventType = C.PN_TRANSPORT_CLOSED
+)
+
+func (e EventType) String() string {
+ switch e {
+
+ case C.PN_CONNECTION_INIT:
+ return "ConnectionInit"
+ case C.PN_CONNECTION_BOUND:
+ return "ConnectionBound"
+ case C.PN_CONNECTION_UNBOUND:
+ return "ConnectionUnbound"
+ case C.PN_CONNECTION_LOCAL_OPEN:
+ return "ConnectionLocalOpen"
+ case C.PN_CONNECTION_REMOTE_OPEN:
+ return "ConnectionRemoteOpen"
+ case C.PN_CONNECTION_LOCAL_CLOSE:
+ return "ConnectionLocalClose"
+ case C.PN_CONNECTION_REMOTE_CLOSE:
+ return "ConnectionRemoteClose"
+ case C.PN_CONNECTION_FINAL:
+ return "ConnectionFinal"
+ case C.PN_SESSION_INIT:
+ return "SessionInit"
+ case C.PN_SESSION_LOCAL_OPEN:
+ return "SessionLocalOpen"
+ case C.PN_SESSION_REMOTE_OPEN:
+ return "SessionRemoteOpen"
+ case C.PN_SESSION_LOCAL_CLOSE:
+ return "SessionLocalClose"
+ case C.PN_SESSION_REMOTE_CLOSE:
+ return "SessionRemoteClose"
+ case C.PN_SESSION_FINAL:
+ return "SessionFinal"
+ case C.PN_LINK_INIT:
+ return "LinkInit"
+ case C.PN_LINK_LOCAL_OPEN:
+ return "LinkLocalOpen"
+ case C.PN_LINK_REMOTE_OPEN:
+ return "LinkRemoteOpen"
+ case C.PN_LINK_LOCAL_CLOSE:
+ return "LinkLocalClose"
+ case C.PN_LINK_REMOTE_CLOSE:
+ return "LinkRemoteClose"
+ case C.PN_LINK_LOCAL_DETACH:
+ return "LinkLocalDetach"
+ case C.PN_LINK_REMOTE_DETACH:
+ return "LinkRemoteDetach"
+ case C.PN_LINK_FLOW:
+ return "LinkFlow"
+ case C.PN_LINK_FINAL:
+ return "LinkFinal"
+ case C.PN_DELIVERY:
+ return "Delivery"
+ case C.PN_TRANSPORT:
+ return "Transport"
+ case C.PN_TRANSPORT_AUTHENTICATED:
+ return "TransportAuthenticated"
+ case C.PN_TRANSPORT_ERROR:
+ return "TransportError"
+ case C.PN_TRANSPORT_HEAD_CLOSED:
+ return "TransportHeadClosed"
+ case C.PN_TRANSPORT_TAIL_CLOSED:
+ return "TransportTailClosed"
+ case C.PN_TRANSPORT_CLOSED:
+ return "TransportClosed"
+ }
+ return "Unknown"
+}
+
+// Wrappers for declarations in session.h
+
+type Session struct{ pn *C.pn_session_t }
+
+func (s Session) IsNil() bool { return s.pn == nil }
+func (s Session) Free() {
+ C.pn_session_free(s.pn)
+}
+func (s Session) State() State {
+ return State(C.pn_session_state(s.pn))
+}
+func (s Session) Error() error {
+ return internal.PnError(unsafe.Pointer(C.pn_session_error(s.pn)))
+}
+func (s Session) Condition() Condition {
+ return Condition{C.pn_session_condition(s.pn)}
+}
+func (s Session) RemoteCondition() Condition {
+ return Condition{C.pn_session_remote_condition(s.pn)}
+}
+func (s Session) Connection() Connection {
+ return Connection{C.pn_session_connection(s.pn)}
+}
+func (s Session) Open() {
+ C.pn_session_open(s.pn)
+}
+func (s Session) Close() {
+ C.pn_session_close(s.pn)
+}
+func (s Session) IncomingCapacity() uint {
+ return uint(C.pn_session_get_incoming_capacity(s.pn))
+}
+func (s Session) SetIncomingCapacity(capacity uint) {
+ C.pn_session_set_incoming_capacity(s.pn, C.size_t(capacity))
+}
+func (s Session) OutgoingBytes() uint {
+ return uint(C.pn_session_outgoing_bytes(s.pn))
+}
+func (s Session) IncomingBytes() uint {
+ return uint(C.pn_session_incoming_bytes(s.pn))
+}
+func (s Session) Next(state State) Session {
+ return Session{C.pn_session_next(s.pn, C.pn_state_t(state))}
+}
+
+// Wrappers for declarations in link.h
+
+type SndSettleMode C.pn_snd_settle_mode_t
+
+const (
+ PnSndUnsettled SndSettleMode = C.PN_SND_UNSETTLED
+ PnSndSettled SndSettleMode = C.PN_SND_SETTLED
+ PnSndMixed SndSettleMode = C.PN_SND_MIXED
+)
+
+func (e SndSettleMode) String() string {
+ switch e {
+
+ case C.PN_SND_UNSETTLED:
+ return "SndUnsettled"
+ case C.PN_SND_SETTLED:
+ return "SndSettled"
+ case C.PN_SND_MIXED:
+ return "SndMixed"
+ }
+ return "unknown"
+}
+
+type RcvSettleMode C.pn_rcv_settle_mode_t
+
+const (
+ PnRcvFirst RcvSettleMode = C.PN_RCV_FIRST
+ PnRcvSecond RcvSettleMode = C.PN_RCV_SECOND
+)
+
+func (e RcvSettleMode) String() string {
+ switch e {
+
+ case C.PN_RCV_FIRST:
+ return "RcvFirst"
+ case C.PN_RCV_SECOND:
+ return "RcvSecond"
+ }
+ return "unknown"
+}
+
+type Link struct{ pn *C.pn_link_t }
+
+func (l Link) IsNil() bool { return l.pn == nil }
+func (l Link) Free() {
+ C.pn_link_free(l.pn)
+}
+func (l Link) Name() string {
+ return C.GoString(C.pn_link_name(l.pn))
+}
+func (l Link) IsSender() bool {
+ return bool(C.pn_link_is_sender(l.pn))
+}
+func (l Link) IsReceiver() bool {
+ return bool(C.pn_link_is_receiver(l.pn))
+}
+func (l Link) State() State {
+ return State(C.pn_link_state(l.pn))
+}
+func (l Link) Error() error {
+ return internal.PnError(unsafe.Pointer(C.pn_link_error(l.pn)))
+}
+func (l Link) Condition() Condition {
+ return Condition{C.pn_link_condition(l.pn)}
+}
+func (l Link) RemoteCondition() Condition {
+ return Condition{C.pn_link_remote_condition(l.pn)}
+}
+func (l Link) Session() Session {
+ return Session{C.pn_link_session(l.pn)}
+}
+func (l Link) Next(state State) Link {
+ return Link{C.pn_link_next(l.pn, C.pn_state_t(state))}
+}
+func (l Link) Open() {
+ C.pn_link_open(l.pn)
+}
+func (l Link) Close() {
+ C.pn_link_close(l.pn)
+}
+func (l Link) Detach() {
+ C.pn_link_detach(l.pn)
+}
+func (l Link) Source() Terminus {
+ return Terminus{C.pn_link_source(l.pn)}
+}
+func (l Link) Target() Terminus {
+ return Terminus{C.pn_link_target(l.pn)}
+}
+func (l Link) RemoteSource() Terminus {
+ return Terminus{C.pn_link_remote_source(l.pn)}
+}
+func (l Link) RemoteTarget() Terminus {
+ return Terminus{C.pn_link_remote_target(l.pn)}
+}
+func (l Link) Current() Delivery {
+ return Delivery{C.pn_link_current(l.pn)}
+}
+func (l Link) Advance() bool {
+ return bool(C.pn_link_advance(l.pn))
+}
+func (l Link) Credit() int {
+ return int(C.pn_link_credit(l.pn))
+}
+func (l Link) Queued() int {
+ return int(C.pn_link_queued(l.pn))
+}
+func (l Link) RemoteCredit() int {
+ return int(C.pn_link_remote_credit(l.pn))
+}
+func (l Link) IsDrain() bool {
+ return bool(C.pn_link_get_drain(l.pn))
+}
+func (l Link) Drained() int {
+ return int(C.pn_link_drained(l.pn))
+}
+func (l Link) Available() int {
+ return int(C.pn_link_available(l.pn))
+}
+func (l Link) SndSettleMode() SndSettleMode {
+ return SndSettleMode(C.pn_link_snd_settle_mode(l.pn))
+}
+func (l Link) RcvSettleMode() RcvSettleMode {
+ return RcvSettleMode(C.pn_link_rcv_settle_mode(l.pn))
+}
+func (l Link) SetSndSettleMode(mode SndSettleMode) {
+ C.pn_link_set_snd_settle_mode(l.pn, C.pn_snd_settle_mode_t(mode))
+}
+func (l Link) SetRcvSettleMode(mode RcvSettleMode) {
+ C.pn_link_set_rcv_settle_mode(l.pn, C.pn_rcv_settle_mode_t(mode))
+}
+func (l Link) RemoteSndSettleMode() SndSettleMode {
+ return SndSettleMode(C.pn_link_remote_snd_settle_mode(l.pn))
+}
+func (l Link) RemoteRcvSettleMode() RcvSettleMode {
+ return RcvSettleMode(C.pn_link_remote_rcv_settle_mode(l.pn))
+}
+func (l Link) Unsettled() int {
+ return int(C.pn_link_unsettled(l.pn))
+}
+func (l Link) Offered(credit int) {
+ C.pn_link_offered(l.pn, C.int(credit))
+}
+func (l Link) Flow(credit int) {
+ C.pn_link_flow(l.pn, C.int(credit))
+}
+func (l Link) Drain(credit int) {
+ C.pn_link_drain(l.pn, C.int(credit))
+}
+func (l Link) SetDrain(drain bool) {
+ C.pn_link_set_drain(l.pn, C.bool(drain))
+}
+func (l Link) Draining() bool {
+ return bool(C.pn_link_draining(l.pn))
+}
+
+// Wrappers for declarations in delivery.h
+
+type Delivery struct{ pn *C.pn_delivery_t }
+
+func (d Delivery) IsNil() bool { return d.pn == nil }
+func (d Delivery) Tag() DeliveryTag {
+ return DeliveryTag{C.pn_delivery_tag(d.pn)}
+}
+func (d Delivery) Link() Link {
+ return Link{C.pn_delivery_link(d.pn)}
+}
+func (d Delivery) Local() Disposition {
+ return Disposition{C.pn_delivery_local(d.pn)}
+}
+func (d Delivery) LocalState() uint64 {
+ return uint64(C.pn_delivery_local_state(d.pn))
+}
+func (d Delivery) Remote() Disposition {
+ return Disposition{C.pn_delivery_remote(d.pn)}
+}
+func (d Delivery) RemoteState() uint64 {
+ return uint64(C.pn_delivery_remote_state(d.pn))
+}
+func (d Delivery) Settled() bool {
+ return bool(C.pn_delivery_settled(d.pn))
+}
+func (d Delivery) Pending() uint {
+ return uint(C.pn_delivery_pending(d.pn))
+}
+func (d Delivery) Partial() bool {
+ return bool(C.pn_delivery_partial(d.pn))
+}
+func (d Delivery) Writable() bool {
+ return bool(C.pn_delivery_writable(d.pn))
+}
+func (d Delivery) Readable() bool {
+ return bool(C.pn_delivery_readable(d.pn))
+}
+func (d Delivery) Updated() bool {
+ return bool(C.pn_delivery_updated(d.pn))
+}
+func (d Delivery) Update(state uint64) {
+ C.pn_delivery_update(d.pn, C.uint64_t(state))
+}
+func (d Delivery) Clear() {
+ C.pn_delivery_clear(d.pn)
+}
+func (d Delivery) Current() bool {
+ return bool(C.pn_delivery_current(d.pn))
+}
+func (d Delivery) Settle() {
+ C.pn_delivery_settle(d.pn)
+}
+func (d Delivery) Dump() {
+ C.pn_delivery_dump(d.pn)
+}
+func (d Delivery) Buffered() bool {
+ return bool(C.pn_delivery_buffered(d.pn))
+}
+
+// Wrappers for declarations in disposition.h
+
+type Disposition struct{ pn *C.pn_disposition_t }
+
+func (d Disposition) IsNil() bool { return d.pn == nil }
+func (d Disposition) Type() uint64 {
+ return uint64(C.pn_disposition_type(d.pn))
+}
+func (d Disposition) Condition() Condition {
+ return Condition{C.pn_disposition_condition(d.pn)}
+}
+func (d Disposition) Data() Data {
+ return Data{C.pn_disposition_data(d.pn)}
+}
+func (d Disposition) SectionNumber() uint16 {
+ return uint16(C.pn_disposition_get_section_number(d.pn))
+}
+func (d Disposition) SetSectionNumber(section_number uint16) {
+ C.pn_disposition_set_section_number(d.pn, C.uint32_t(section_number))
+}
+func (d Disposition) SectionOffset() uint64 {
+ return uint64(C.pn_disposition_get_section_offset(d.pn))
+}
+func (d Disposition) SetSectionOffset(section_offset uint64) {
+ C.pn_disposition_set_section_offset(d.pn, C.uint64_t(section_offset))
+}
+func (d Disposition) IsFailed() bool {
+ return bool(C.pn_disposition_is_failed(d.pn))
+}
+func (d Disposition) SetFailed(failed bool) {
+ C.pn_disposition_set_failed(d.pn, C.bool(failed))
+}
+func (d Disposition) IsUndeliverable() bool {
+ return bool(C.pn_disposition_is_undeliverable(d.pn))
+}
+func (d Disposition) SetUndeliverable(undeliverable bool) {
+ C.pn_disposition_set_undeliverable(d.pn, C.bool(undeliverable))
+}
+func (d Disposition) Annotations() Data {
+ return Data{C.pn_disposition_annotations(d.pn)}
+}
+
+// Wrappers for declarations in condition.h
+
+type Condition struct{ pn *C.pn_condition_t }
+
+func (c Condition) IsNil() bool { return c.pn == nil }
+func (c Condition) IsSet() bool {
+ return bool(C.pn_condition_is_set(c.pn))
+}
+func (c Condition) Clear() {
+ C.pn_condition_clear(c.pn)
+}
+func (c Condition) Name() string {
+ return C.GoString(C.pn_condition_get_name(c.pn))
+}
+func (c Condition) SetName(name string) int {
+ nameC := C.CString(name)
+ defer C.free(unsafe.Pointer(nameC))
+
+ return int(C.pn_condition_set_name(c.pn, nameC))
+}
+func (c Condition) Description() string {
+ return C.GoString(C.pn_condition_get_description(c.pn))
+}
+func (c Condition) SetDescription(description string) int {
+ descriptionC := C.CString(description)
+ defer C.free(unsafe.Pointer(descriptionC))
+
+ return int(C.pn_condition_set_description(c.pn, descriptionC))
+}
+func (c Condition) Info() Data {
+ return Data{C.pn_condition_info(c.pn)}
+}
+func (c Condition) IsRedirect() bool {
+ return bool(C.pn_condition_is_redirect(c.pn))
+}
+func (c Condition) RedirectHost() string {
+ return C.GoString(C.pn_condition_redirect_host(c.pn))
+}
+func (c Condition) RedirectPort() int {
+ return int(C.pn_condition_redirect_port(c.pn))
+}
+
+// Wrappers for declarations in terminus.h
+
+type TerminusType C.pn_terminus_type_t
+
+const (
+ PnUnspecified TerminusType = C.PN_UNSPECIFIED
+ PnSource TerminusType = C.PN_SOURCE
+ PnTarget TerminusType = C.PN_TARGET
+ PnCoordinator TerminusType = C.PN_COORDINATOR
+)
+
+func (e TerminusType) String() string {
+ switch e {
+
+ case C.PN_UNSPECIFIED:
+ return "Unspecified"
+ case C.PN_SOURCE:
+ return "Source"
+ case C.PN_TARGET:
+ return "Target"
+ case C.PN_COORDINATOR:
+ return "Coordinator"
+ }
+ return "unknown"
+}
+
+type Durability C.pn_durability_t
+
+const (
+ PnNondurable Durability = C.PN_NONDURABLE
+ PnConfiguration Durability = C.PN_CONFIGURATION
+ PnDeliveries Durability = C.PN_DELIVERIES
+)
+
+func (e Durability) String() string {
+ switch e {
+
+ case C.PN_NONDURABLE:
+ return "Nondurable"
+ case C.PN_CONFIGURATION:
+ return "Configuration"
+ case C.PN_DELIVERIES:
+ return "Deliveries"
+ }
+ return "unknown"
+}
+
+type ExpiryPolicy C.pn_expiry_policy_t
+
+const (
+ PnExpireWithLink ExpiryPolicy = C.PN_EXPIRE_WITH_LINK
+ PnExpireWithSession ExpiryPolicy = C.PN_EXPIRE_WITH_SESSION
+ PnExpireWithConnection ExpiryPolicy = C.PN_EXPIRE_WITH_CONNECTION
+ PnExpireNever ExpiryPolicy = C.PN_EXPIRE_NEVER
+)
+
+func (e ExpiryPolicy) String() string {
+ switch e {
+
+ case C.PN_EXPIRE_WITH_LINK:
+ return "ExpireWithLink"
+ case C.PN_EXPIRE_WITH_SESSION:
+ return "ExpireWithSession"
+ case C.PN_EXPIRE_WITH_CONNECTION:
+ return "ExpireWithConnection"
+ case C.PN_EXPIRE_NEVER:
+ return "ExpireNever"
+ }
+ return "unknown"
+}
+
+type DistributionMode C.pn_distribution_mode_t
+
+const (
+ PnDistModeUnspecified DistributionMode = C.PN_DIST_MODE_UNSPECIFIED
+ PnDistModeCopy DistributionMode = C.PN_DIST_MODE_COPY
+ PnDistModeMove DistributionMode = C.PN_DIST_MODE_MOVE
+)
+
+func (e DistributionMode) String() string {
+ switch e {
+
+ case C.PN_DIST_MODE_UNSPECIFIED:
+ return "DistModeUnspecified"
+ case C.PN_DIST_MODE_COPY:
+ return "DistModeCopy"
+ case C.PN_DIST_MODE_MOVE:
+ return "DistModeMove"
+ }
+ return "unknown"
+}
+
+type Terminus struct{ pn *C.pn_terminus_t }
+
+func (t Terminus) IsNil() bool { return t.pn == nil }
+func (t Terminus) Type() TerminusType {
+ return TerminusType(C.pn_terminus_get_type(t.pn))
+}
+func (t Terminus) SetType(type_ TerminusType) int {
+ return int(C.pn_terminus_set_type(t.pn, C.pn_terminus_type_t(type_)))
+}
+func (t Terminus) Address() string {
+ return C.GoString(C.pn_terminus_get_address(t.pn))
+}
+func (t Terminus) SetAddress(address string) int {
+ addressC := C.CString(address)
+ defer C.free(unsafe.Pointer(addressC))
+
+ return int(C.pn_terminus_set_address(t.pn, addressC))
+}
+func (t Terminus) SetDistributionMode(mode DistributionMode) int {
+ return int(C.pn_terminus_set_distribution_mode(t.pn, C.pn_distribution_mode_t(mode)))
+}
+func (t Terminus) Durability() Durability {
+ return Durability(C.pn_terminus_get_durability(t.pn))
+}
+func (t Terminus) SetDurability(durability Durability) int {
+ return int(C.pn_terminus_set_durability(t.pn, C.pn_durability_t(durability)))
+}
+func (t Terminus) ExpiryPolicy() ExpiryPolicy {
+ return ExpiryPolicy(C.pn_terminus_get_expiry_policy(t.pn))
+}
+func (t Terminus) SetExpiryPolicy(policy ExpiryPolicy) int {
+ return int(C.pn_terminus_set_expiry_policy(t.pn, C.pn_expiry_policy_t(policy)))
+}
+func (t Terminus) Timeout() time.Duration {
+ return (time.Duration(C.pn_terminus_get_timeout(t.pn)) * time.Second)
+}
+func (t Terminus) SetTimeout(timeout time.Duration) int {
+ return int(C.pn_terminus_set_timeout(t.pn, C.pn_seconds_t(timeout)))
+}
+func (t Terminus) IsDynamic() bool {
+ return bool(C.pn_terminus_is_dynamic(t.pn))
+}
+func (t Terminus) SetDynamic(dynamic bool) int {
+ return int(C.pn_terminus_set_dynamic(t.pn, C.bool(dynamic)))
+}
+func (t Terminus) Properties() Data {
+ return Data{C.pn_terminus_properties(t.pn)}
+}
+func (t Terminus) Capabilities() Data {
+ return Data{C.pn_terminus_capabilities(t.pn)}
+}
+func (t Terminus) Outcomes() Data {
+ return Data{C.pn_terminus_outcomes(t.pn)}
+}
+func (t Terminus) Filter() Data {
+ return Data{C.pn_terminus_filter(t.pn)}
+}
+func (t Terminus) Copy(src Terminus) int {
+ return int(C.pn_terminus_copy(t.pn, src.pn))
+}
+
+// Wrappers for declarations in connection.h
+
+type Connection struct{ pn *C.pn_connection_t }
+
+func (c Connection) IsNil() bool { return c.pn == nil }
+func (c Connection) Free() {
+ C.pn_connection_free(c.pn)
+}
+func (c Connection) Release() {
+ C.pn_connection_release(c.pn)
+}
+func (c Connection) Error() error {
+ return internal.PnError(unsafe.Pointer(C.pn_connection_error(c.pn)))
+}
+func (c Connection) State() State {
+ return State(C.pn_connection_state(c.pn))
+}
+func (c Connection) Open() {
+ C.pn_connection_open(c.pn)
+}
+func (c Connection) Close() {
+ C.pn_connection_close(c.pn)
+}
+func (c Connection) Reset() {
+ C.pn_connection_reset(c.pn)
+}
+func (c Connection) Condition() Condition {
+ return Condition{C.pn_connection_condition(c.pn)}
+}
+func (c Connection) RemoteCondition() Condition {
+ return Condition{C.pn_connection_remote_condition(c.pn)}
+}
+func (c Connection) Container() string {
+ return C.GoString(C.pn_connection_get_container(c.pn))
+}
+func (c Connection) SetContainer(container string) {
+ containerC := C.CString(container)
+ defer C.free(unsafe.Pointer(containerC))
+
+ C.pn_connection_set_container(c.pn, containerC)
+}
+func (c Connection) SetUser(user string) {
+ userC := C.CString(user)
+ defer C.free(unsafe.Pointer(userC))
+
+ C.pn_connection_set_user(c.pn, userC)
+}
+func (c Connection) SetPassword(password string) {
+ passwordC := C.CString(password)
+ defer C.free(unsafe.Pointer(passwordC))
+
+ C.pn_connection_set_password(c.pn, passwordC)
+}
+func (c Connection) User() string {
+ return C.GoString(C.pn_connection_get_user(c.pn))
+}
+func (c Connection) Hostname() string {
+ return C.GoString(C.pn_connection_get_hostname(c.pn))
+}
+func (c Connection) SetHostname(hostname string) {
+ hostnameC := C.CString(hostname)
+ defer C.free(unsafe.Pointer(hostnameC))
+
+ C.pn_connection_set_hostname(c.pn, hostnameC)
+}
+func (c Connection) RemoteContainer() string {
+ return C.GoString(C.pn_connection_remote_container(c.pn))
+}
+func (c Connection) RemoteHostname() string {
+ return C.GoString(C.pn_connection_remote_hostname(c.pn))
+}
+func (c Connection) OfferedCapabilities() Data {
+ return Data{C.pn_connection_offered_capabilities(c.pn)}
+}
+func (c Connection) DesiredCapabilities() Data {
+ return Data{C.pn_connection_desired_capabilities(c.pn)}
+}
+func (c Connection) Properties() Data {
+ return Data{C.pn_connection_properties(c.pn)}
+}
+func (c Connection) RemoteOfferedCapabilities() Data {
+ return Data{C.pn_connection_remote_offered_capabilities(c.pn)}
+}
+func (c Connection) RemoteDesiredCapabilities() Data {
+ return Data{C.pn_connection_remote_desired_capabilities(c.pn)}
+}
+func (c Connection) RemoteProperties() Data {
+ return Data{C.pn_connection_remote_properties(c.pn)}
+}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/internal/error.go
----------------------------------------------------------------------
diff --git a/go/internal/error.go b/go/internal/error.go
new file mode 100644
index 0000000..01ba890
--- /dev/null
+++ b/go/internal/error.go
@@ -0,0 +1,125 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+// Internal implementation details - ignore.
+package internal
+
+// #cgo LDFLAGS: -lqpid-proton
+// #include <proton/error.h>
+// #include <proton/codec.h>
+import "C"
+
+import (
+ "fmt"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "unsafe"
+)
+
+// Error type for all proton errors.
+type Error string
+
+// Error prefixes error message with proton:
+func (e Error) Error() string {
+ return "proton: " + string(e)
+}
+
+// Errorf creates an Error with a formatted message
+func Errorf(format string, a ...interface{}) Error {
+ return Error(fmt.Sprintf(format, a...))
+}
+
+type PnErrorCode int
+
+func (e PnErrorCode) String() string {
+ switch e {
+ case C.PN_EOS:
+ return "end-of-data"
+ case C.PN_ERR:
+ return "error"
+ case C.PN_OVERFLOW:
+ return "overflow"
+ case C.PN_UNDERFLOW:
+ return "underflow"
+ case C.PN_STATE_ERR:
+ return "bad-state"
+ case C.PN_ARG_ERR:
+ return "invalid-argument"
+ case C.PN_TIMEOUT:
+ return "timeout"
+ case C.PN_INTR:
+ return "interrupted"
+ case C.PN_INPROGRESS:
+ return "in-progress"
+ default:
+ return fmt.Sprintf("unknown-error(%d)", e)
+ }
+}
+
+func PnError(p unsafe.Pointer) error {
+ e := (*C.pn_error_t)(p)
+ if e == nil || C.pn_error_code(e) == 0 {
+ return nil
+ }
+ return Errorf("%s: %s", PnErrorCode(C.pn_error_code(e)), C.GoString(C.pn_error_text(e)))
+}
+
+// DoRecover is called to recover from internal panics
+func DoRecover(err *error) {
+ r := recover()
+ switch r := r.(type) {
+ case nil: // We are not recovering
+ return
+ case runtime.Error: // Don't catch runtime.Error
+ panic(r)
+ case error:
+ *err = r
+ default:
+ panic(r)
+ }
+}
+
+// panicIf panics if condition is true, the panic value is Errorf(fmt, args...)
+func panicIf(condition bool, fmt string, args ...interface{}) {
+ if condition {
+ panic(Errorf(fmt, args...))
+ }
+}
+
+// FirstError is a goroutine-safe error holder that keeps the first error that is set.
+type FirstError struct {
+ err atomic.Value
+ once sync.Once
+}
+
+// Set the error if not allread set.
+func (e *FirstError) Set(err error) {
+ e.once.Do(func() { e.err.Store(err) })
+}
+
+// Get the error.
+func (e *FirstError) Get() error {
+ v := e.err.Load()
+ if v != nil {
+ return v.(error)
+ } else {
+ return nil
+ }
+}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/messaging/doc.go
----------------------------------------------------------------------
diff --git a/go/messaging/doc.go b/go/messaging/doc.go
new file mode 100644
index 0000000..c815f4e
--- /dev/null
+++ b/go/messaging/doc.go
@@ -0,0 +1,28 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+/*
+Package messaging provides a procedural, concurrent Go API for exchanging AMQP messages.
+*/
+package messaging
+
+// #cgo LDFLAGS: -lqpid-proton
+import "C"
+
+// Just for package comment
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/messaging/handler.go
----------------------------------------------------------------------
diff --git a/go/messaging/handler.go b/go/messaging/handler.go
new file mode 100644
index 0000000..4a97b9d
--- /dev/null
+++ b/go/messaging/handler.go
@@ -0,0 +1,70 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package messaging
+
+import (
+ "qpid.apache.org/proton/go/amqp"
+ "qpid.apache.org/proton/go/event"
+)
+
+// FIXME aconway 2015-04-28: cleanup - exposing delivery vs. disposition.
+
+type acksMap map[event.Delivery]chan Disposition
+type receiverMap map[event.Link]chan amqp.Message
+
+type handler struct {
+ connection *Connection
+ acks acksMap
+ receivers receiverMap
+}
+
+func newHandler(c *Connection) *handler {
+ return &handler{c, make(acksMap), make(receiverMap)}
+}
+
+func (h *handler) HandleMessagingEvent(t event.MessagingEventType, e event.Event) error {
+ switch t {
+ // FIXME aconway 2015-04-29: handle errors.
+ case event.MConnectionClosed:
+ for _, ack := range h.acks {
+ // FIXME aconway 2015-04-29: communicate error info
+ close(ack)
+ }
+
+ case event.MSettled:
+ ack := h.acks[e.Delivery()]
+ if ack != nil {
+ ack <- Disposition(e.Delivery().Remote().Type())
+ close(ack)
+ delete(h.acks, e.Delivery())
+ }
+
+ case event.MMessage:
+ r := h.receivers[e.Link()]
+ if r != nil {
+ m, _ := event.DecodeMessage(e)
+ // FIXME aconway 2015-04-29: hack, direct send, possible blocking.
+ r <- m
+ } else {
+ // FIXME aconway 2015-04-29: Message with no receiver - log? panic? deadletter? drop?
+ }
+ }
+ return nil
+}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/go/messaging/messaging.go
----------------------------------------------------------------------
diff --git a/go/messaging/messaging.go b/go/messaging/messaging.go
new file mode 100644
index 0000000..e653de2
--- /dev/null
+++ b/go/messaging/messaging.go
@@ -0,0 +1,250 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package messaging
+
+// #include <proton/disposition.h>
+import "C"
+
+import (
+ "net"
+ "qpid.apache.org/proton/go/amqp"
+ "qpid.apache.org/proton/go/event"
+)
+
+// Connection is a connection to a remote AMQP endpoint.
+//
+// You can set exported fields to configure the connection before calling
+// Connection.Open()
+//
+type Connection struct {
+ // Server = true means a the connection will do automatic protocol detection.
+ Server bool
+
+ // FIXME aconway 2015-04-17: Other parameters to set up SSL, SASL etc.
+
+ handler *handler
+ pump *event.Pump
+ session Session
+}
+
+// Make an AMQP connection over a net.Conn connection.
+//
+// Use Connection.Close() to close the Connection, this will also close conn.
+// Using conn.Close() directly will cause an abrupt disconnect rather than an
+// orderly AMQP close.
+//
+func (c *Connection) Open(conn net.Conn) (err error) {
+ c.handler = newHandler(c)
+ c.pump, err = event.NewPump(conn,
+ event.NewMessagingDelegator(c.handler),
+ )
+ if err != nil {
+ return err
+ }
+ if c.Server {
+ c.pump.Server()
+ }
+ go c.pump.Run()
+ return nil
+}
+
+// Connect opens a default client connection. It is a shortcut for
+// c := &Connection
+// c.Open()
+//
+func Connect(conn net.Conn) (*Connection, error) {
+ c := &Connection{}
+ err := c.Open(conn)
+ return c, err
+}
+
+// Close the connection.
+//
+// Connections must be closed to clean up resources and stop associated goroutines.
+func (c *Connection) Close() error { return c.pump.Close() }
+
+// DefaultSession returns a default session for the connection.
+//
+// It is created on the first call to DefaultSession() and returned from all subsequent calls.
+// Use Session() for more control over creating sessions.
+//
+func (c *Connection) DefaultSession() (s Session, err error) {
+ if c.session.e.IsNil() {
+ c.session, err = c.Session()
+ }
+ return c.session, err
+}
+
+type sessionErr struct {
+ s event.Session
+ err error
+}
+
+// Session creates a new session.
+func (c *Connection) Session() (Session, error) {
+ connection := c.pump.Connection()
+ result := make(chan sessionErr)
+ c.pump.Inject <- func() {
+ s, err := connection.Session()
+ if err == nil {
+ s.Open()
+ }
+ result <- sessionErr{s, err}
+ }
+ se := <-result
+ return Session{se.s, c.pump}, se.err
+}
+
+// FIXME aconway 2015-04-27: set sender name, options etc.
+
+// Sender creates a Sender that will send messages to the address addr.
+func (c *Connection) Sender(addr string) (s Sender, err error) {
+ session, err := c.DefaultSession()
+ if err != nil {
+ return Sender{}, err
+ }
+ result := make(chan Sender)
+ c.pump.Inject <- func() {
+ link := session.e.Sender(linkNames.Next())
+ if link.IsNil() {
+ err = session.e.Error()
+ } else {
+ link.Target().SetAddress(addr)
+ // FIXME aconway 2015-04-27: link options?
+ link.Open()
+ }
+ result <- Sender{Link{c, link}}
+ }
+ return <-result, err
+}
+
+// Receiver returns a receiver that will receive messages sent to address addr.
+func (c *Connection) Receiver(addr string) (r Receiver, err error) {
+ // FIXME aconway 2015-04-29: move code to session, in link.go?
+ session, err := c.DefaultSession()
+ if err != nil {
+ return Receiver{}, err
+ }
+ result := make(chan Receiver)
+ c.pump.Inject <- func() {
+ link := session.e.Receiver(linkNames.Next())
+ if link.IsNil() {
+ err = session.e.Error()
+ } else {
+ link.Source().SetAddress(addr)
+ // FIXME aconway 2015-04-27: link options?
+ link.Open()
+ }
+ // FIXME aconway 2015-04-29: hack to avoid blocking, need proper buffering linked to flow control
+ rchan := make(chan amqp.Message, 1000)
+ c.handler.receivers[link] = rchan
+ result <- Receiver{Link{c, link}, rchan}
+ }
+ return <-result, err
+}
+
+// FIXME aconway 2015-04-29: counter per session.
+var linkNames amqp.UidCounter
+
+// Session is an AMQP session, it contains Senders and Receivers.
+// Every Connection has a DefaultSession, you can create additional sessions
+// with Connection.Session()
+type Session struct {
+ e event.Session
+ pump *event.Pump
+}
+
+// FIXME aconway 2015-05-05: REWORK Sender/receiver/session.
+
+// Disposition indicates the outcome of a settled message delivery.
+type Disposition uint64
+
+const (
+ // Message was accepted by the receiver
+ Accepted Disposition = C.PN_ACCEPTED
+ // Message was rejected as invalid by the receiver
+ Rejected = C.PN_REJECTED
+ // Message was not processed by the receiver but may be processed by some other receiver.
+ Released = C.PN_RELEASED
+)
+
+// String human readable name for a Disposition.
+func (d Disposition) String() string {
+ switch d {
+ case Accepted:
+ return "Accepted"
+ case Rejected:
+ return "Rejected"
+ case Released:
+ return "Released"
+ default:
+ return "Unknown"
+ }
+}
+
+// FIXME aconway 2015-04-29: How to signal errors via ack channels.
+
+// An Acknowledgement is a channel which will receive the Disposition of the message
+// when it is acknowledged. The channel is closed after the disposition is sent.
+type Acknowledgement <-chan Disposition
+
+// Link has common data and methods for Sender and Receiver links.
+type Link struct {
+ connection *Connection
+ elink event.Link
+}
+
+// Sender sends messages.
+type Sender struct {
+ Link
+}
+
+// FIXME aconway 2015-04-28: allow user to specify delivery tag.
+// FIXME aconway 2015-04-28: should we provide a sending channel rather than a send function?
+
+// Send sends a message. If d is not nil, the disposition is retured on d.
+// If d is nil the message is sent pre-settled and no disposition is returned.
+func (s *Sender) Send(m amqp.Message) (ack Acknowledgement, err error) {
+ ackChan := make(chan Disposition, 1)
+ ack = ackChan
+ s.connection.pump.Inject <- func() {
+ // FIXME aconway 2015-04-28: flow control & credit, buffer or fail?
+ delivery, err := s.elink.Send(m)
+ if err == nil { // FIXME aconway 2015-04-28: error handling
+ s.connection.handler.acks[delivery] = ackChan
+ }
+ }
+ return ack, nil
+}
+
+// Close the sender.
+func (s *Sender) Close() error { return nil } // FIXME aconway 2015-04-27: close/free
+
+// Receiver receives messages via the channel Receive.
+type Receiver struct {
+ Link
+ // Channel of messag
+ Receive <-chan amqp.Message
+}
+
+// FIXME aconway 2015-04-29: settlement - ReceivedMessage with Settle() method?
+
+// Close the Receiver.
+func (r *Receiver) Close() error { return nil } // FIXME aconway 2015-04-29: close/free
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/proton-c/bindings/go/README.md
----------------------------------------------------------------------
diff --git a/proton-c/bindings/go/README.md b/proton-c/bindings/go/README.md
deleted file mode 100644
index 0449d68..0000000
--- a/proton-c/bindings/go/README.md
+++ /dev/null
@@ -1,138 +0,0 @@
-# *EXPERIMENTAL* Go binding for proton
-
-This is the beginning of a [Go](http://golang.org) binding for proton.
-
-This work is in early *experimental* stages, *everything* may change in future.
-Comments and contributions are strongly encouraged, this experiment is public so
-early feedback can guide development.
-
-- Email <pr...@qpid.apache.org>
-- Create issues <https://issues.apache.org/jira/browse/PROTON>, attach patches to an issue.
-
-There are working [examples](../../../examples/go/README.md) and the examples README file
-explains how to install the packages in your go workspace and read the documentation.
-
-## Goals
-
-The API should
-
-- be idiomatic, unsurprising, and easy to use for Go developers.
-- support client and server development.
-- make simple tasks simple.
-- provide deep access to AMQP protocol when that is required.
-
-There are two types of developer we want to support
-
-1. Go developers using AMQP as a message transport:
- - Straightforward conversions between Go built-in types and AMQP types.
- - Easy message exchange via Go channels to support use in goroutines.
-
-2. AMQP-aware developers using Go as an implementation language:
- - Go types to exactly represent all AMQP types and encoding details.
- - Full access to detailed AMQP concepts: sessions, links, deliveries etc.
-
-## Status
-
-There are 3 go packages for proton:
-
-- qpid.apache.org/proton/go/amqp: converts AMQP messages and data types to and from Go data types.
-- qpid.apache.org/proton/go/messaging: easy-to-use, concurrent API for messaging clients and servers.
-- qpid.apache.org/proton/go/event: full low-level access to the proton engine.
-
-Most applications should use the `messaging` package. The `event` package is for
-applications that need low-level access to the proton engine.
-
-The `event` package is fairly complete, with the exception of the proton
-reactor. It's unclear if the reactor is important for go.
-
-The `messaging` package can run the examples but probably not much else. There
-is work to do on error handling and the API may change.
-
-There are working [examples](../../../examples/go/README.md) of a broker using `event` and
-a sender and receiver using `messaging`.
-
-## The event driven API
-
-See the package documentation for details.
-
-## The Go API
-
-The goal: A procedural API that allows any user goroutine to send and receive
-AMQP messages and other information (acknowledgments, flow control instructions
-etc.) using channels. There will be no user-visible locks and no need to run
-user code in special goroutines, e.g. as handlers in a proton event loop.
-
-See the package documentation for emerging details.
-
-Currently using a channel to receive messages, a function to send them (channels
-internally) and a channel as a "future" for acknowledgements to senders. This
-may change.
-
-## Why a separate API for Go?
-
-Go is a concurrent language and encourages applications to be divided into
-concurrent *goroutines*. It provides traditional locking but it encourages the
-use *channels* to communicate between goroutines without explicit locks:
-
- "Share memory by communicating, don't communicate by sharing memory"
-
-The idea is that a given value is only operated on by one goroutine at a time,
-but values can easily be passed from one goroutine to another. This removes much
-of the need for locking.
-
-Go literature distinguishes between:
-
-- *concurrency*: "keeping track of things that could be done in parallel"
-- *parallelism*: "actually doing things in parallel"
-
-The application expresses concurrency by starting goroutines for potentially
-concurrent tasks. The Go run-times schedule the activity of goroutines onto a
-small number (possibly one) of actual parallel executions.
-
-Even with *no* parallelism, concurrency lets the Go run-times *order* work with
-respect to events like file descriptors being readable/writable, channels having
-data, timers firing etc. Go automatically takes care of switching out goroutines
-that block or sleep so it is normal to write code in terms of blocking calls.
-
-Event-driven API (like poll, epoll, select or the proton event API) also
-channel unpredictably ordered events to actions in one or a small pool of
-execution threads. However this requires a different style of programming:
-"event-driven" or "reactive" programming. Go developers call it "inside-out"
-programming. In an event-driven architecture blocking is a big problem as it
-consumes a scarce thread of execution, so actions that take time to complete
-have to be re-structured in terms of future event delivery.
-
-The promise of Go is that you can express your application in concurrent,
-procedural terms with simple blocking calls and the Go run-times will turn it
-inside-out for you. Write as many goroutines as you want, and let Go interleave
-and schedule them efficiently.
-
-For example: the Go equivalent of listening for connections is a goroutine with
-a simple endless loop that calls a blocking Listen() function and starts a
-goroutine for each new connection. Each connection has its own goroutine that
-deals with just that connection till it closes.
-
-The benefit is that the variables and logic live closer together. Once you're in
-a goroutine, you have everything you need in local variables, and they are
-preserved across blocking calls. There's no need to store details in context
-objects that you have to look up when handling a later event to figure out how
-to continue where you left off.
-
-So a Go-like proton API does not force the users code to run in an event-loop
-goroutine. Instead user goroutines communicate with the event loop(s) via
-channels. There's no need to funnel connections into one event loop, in fact it
-makes no sense. Connections can be processed concurrently so they should be
-processed in separate goroutines and left to Go to schedule. User goroutines can
-have simple loops that block channels till messages are available, the user can
-start as many or as few such goroutines as they wish to implement concurrency as
-simple or as complex as they wish. For example blocking request-response
-vs. asynchronous flows of messages and acknowledgments.
-
-## New to Go?
-
-If you are new to Go then these are a good place to start:
-
-- [A Tour of Go](http://tour.golang.org)
-- [Effective Go](http://golang.org/doc/effective_go.html)
-
-Then look at the tools and library docs at <http://golang.org> as you need them.
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/proton-c/bindings/go/amqp/doc.go
----------------------------------------------------------------------
diff --git a/proton-c/bindings/go/amqp/doc.go b/proton-c/bindings/go/amqp/doc.go
deleted file mode 100644
index 7c00aa0..0000000
--- a/proton-c/bindings/go/amqp/doc.go
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
-*/
-
-/*
-Package amqp encodes and decodes AMQP messages and data as Go types.
-
-It follows the standard 'encoding' libraries pattern. The mapping between AMQP
-and Go types is described in the documentation of the Marshal and Unmarshal
-functions.
-
-The sub-packages 'event' and 'messaging' provide two alternative ways to write
-AMQP clients and servers. 'messaging' is easier for general purpose use. 'event'
-gives complete low-level control of the underlying proton C engine.
-
-AMQP is an open standard for inter-operable message exchange, see <http://www.amqp.org/>
-*/
-package amqp
-
-// #cgo LDFLAGS: -lqpid-proton
-import "C"
-
-// This file is just for the package comment.
-
-// FIXME aconway 2015-04-28: need to re-organize the package, it's not very intuitive.
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/proton-c/bindings/go/amqp/interop
----------------------------------------------------------------------
diff --git a/proton-c/bindings/go/amqp/interop b/proton-c/bindings/go/amqp/interop
deleted file mode 120000
index 8f50d0e..0000000
--- a/proton-c/bindings/go/amqp/interop
+++ /dev/null
@@ -1 +0,0 @@
-../../../../tests/interop
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/proton-c/bindings/go/amqp/interop_test.go
----------------------------------------------------------------------
diff --git a/proton-c/bindings/go/amqp/interop_test.go b/proton-c/bindings/go/amqp/interop_test.go
deleted file mode 100644
index 11049f7..0000000
--- a/proton-c/bindings/go/amqp/interop_test.go
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
-*/
-
-// Test that conversion of Go type to/from AMQP is compatible with other
-// bindings.
-//
-package amqp
-
-import (
- "bytes"
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "reflect"
- "strings"
- "testing"
-)
-
-func assertEqual(want interface{}, got interface{}) {
- if !reflect.DeepEqual(want, got) {
- panic(fmt.Errorf("%#v != %#v", want, got))
- }
-}
-
-func assertNil(err interface{}) {
- if err != nil {
- panic(err)
- }
-}
-
-func getReader(name string) (r io.Reader) {
- r, err := os.Open("interop/" + name + ".amqp")
- if err != nil {
- panic(fmt.Errorf("Can't open %#v: %v", name, err))
- }
- return
-}
-
-func remaining(d *Decoder) string {
- remainder, _ := ioutil.ReadAll(io.MultiReader(d.Buffered(), d.reader))
- return string(remainder)
-}
-
-// assertDecode: want is the expected value, gotPtr is a pointer to a
-// instance of the same type for Decode.
-func assertDecode(d *Decoder, want interface{}, gotPtr interface{}) {
-
- assertNil(d.Decode(gotPtr))
-
- got := reflect.ValueOf(gotPtr).Elem().Interface()
- assertEqual(want, got)
-
- // Try round trip encoding
- bytes, err := Marshal(want, nil)
- assertNil(err)
- n, err := Unmarshal(bytes, gotPtr)
- assertNil(err)
- assertEqual(n, len(bytes))
- got = reflect.ValueOf(gotPtr).Elem().Interface()
- assertEqual(want, got)
-}
-
-func TestUnmarshal(t *testing.T) {
- bytes, err := ioutil.ReadAll(getReader("strings"))
- if err != nil {
- t.Error(err)
- }
- for _, want := range []string{"abc\000defg", "abcdefg", "abcdefg", "", "", ""} {
- var got string
- n, err := Unmarshal(bytes, &got)
- if err != nil {
- t.Error(err)
- }
- if want != got {
- t.Errorf("%#v != %#v", want, got)
- }
- bytes = bytes[n:]
- }
-}
-
-func TestPrimitivesExact(t *testing.T) {
- d := NewDecoder(getReader("primitives"))
- // Decoding into exact types
- var b bool
- assertDecode(d, true, &b)
- assertDecode(d, false, &b)
- var u8 uint8
- assertDecode(d, uint8(42), &u8)
- var u16 uint16
- assertDecode(d, uint16(42), &u16)
- var i16 int16
- assertDecode(d, int16(-42), &i16)
- var u32 uint32
- assertDecode(d, uint32(12345), &u32)
- var i32 int32
- assertDecode(d, int32(-12345), &i32)
- var u64 uint64
- assertDecode(d, uint64(12345), &u64)
- var i64 int64
- assertDecode(d, int64(-12345), &i64)
- var f32 float32
- assertDecode(d, float32(0.125), &f32)
- var f64 float64
- assertDecode(d, float64(0.125), &f64)
-}
-
-func TestPrimitivesCompatible(t *testing.T) {
- d := NewDecoder(getReader("primitives"))
- // Decoding into compatible types
- var b bool
- var i int
- var u uint
- var f float64
- assertDecode(d, true, &b)
- assertDecode(d, false, &b)
- assertDecode(d, uint(42), &u)
- assertDecode(d, uint(42), &u)
- assertDecode(d, -42, &i)
- assertDecode(d, uint(12345), &u)
- assertDecode(d, -12345, &i)
- assertDecode(d, uint(12345), &u)
- assertDecode(d, -12345, &i)
- assertDecode(d, 0.125, &f)
- assertDecode(d, 0.125, &f)
-}
-
-// assertDecodeValue: want is the expected value, decode into a reflect.Value
-func assertDecodeInterface(d *Decoder, want interface{}) {
-
- var got, got2 interface{}
- assertNil(d.Decode(&got))
-
- assertEqual(want, got)
-
- // Try round trip encoding
- bytes, err := Marshal(got, nil)
- assertNil(err)
- n, err := Unmarshal(bytes, &got2)
- assertNil(err)
- assertEqual(n, len(bytes))
- assertEqual(want, got2)
-}
-
-func TestPrimitivesInterface(t *testing.T) {
- d := NewDecoder(getReader("primitives"))
- assertDecodeInterface(d, true)
- assertDecodeInterface(d, false)
- assertDecodeInterface(d, uint8(42))
- assertDecodeInterface(d, uint16(42))
- assertDecodeInterface(d, int16(-42))
- assertDecodeInterface(d, uint32(12345))
- assertDecodeInterface(d, int32(-12345))
- assertDecodeInterface(d, uint64(12345))
- assertDecodeInterface(d, int64(-12345))
- assertDecodeInterface(d, float32(0.125))
- assertDecodeInterface(d, float64(0.125))
-}
-
-func TestStrings(t *testing.T) {
- d := NewDecoder(getReader("strings"))
- // Test decoding as plain Go strings
- for _, want := range []string{"abc\000defg", "abcdefg", "abcdefg", "", "", ""} {
- var got string
- assertDecode(d, want, &got)
- }
- remains := remaining(d)
- if remains != "" {
- t.Errorf("leftover: %s", remains)
- }
-
- // Test decoding as specific string types
- d = NewDecoder(getReader("strings"))
- var bytes []byte
- var str, sym string
- assertDecode(d, []byte("abc\000defg"), &bytes)
- assertDecode(d, "abcdefg", &str)
- assertDecode(d, "abcdefg", &sym)
- assertDecode(d, make([]byte, 0), &bytes)
- assertDecode(d, "", &str)
- assertDecode(d, "", &sym)
- remains = remaining(d)
- if remains != "" {
- t.Fatalf("leftover: %s", remains)
- }
-
- // Test some error handling
- d = NewDecoder(getReader("strings"))
- var s string
- err := d.Decode(s)
- if err == nil {
- t.Fatal("Expected error")
- }
- if !strings.Contains(err.Error(), "not a pointer") {
- t.Error(err)
- }
- var i int
- err = d.Decode(&i)
- if !strings.Contains(err.Error(), "cannot unmarshal") {
- t.Error(err)
- }
- _, err = Unmarshal([]byte{}, nil)
- if !strings.Contains(err.Error(), "not enough data") {
- t.Error(err)
- }
- _, err = Unmarshal([]byte("foobar"), nil)
- if !strings.Contains(err.Error(), "invalid-argument") {
- t.Error(err)
- }
-}
-
-func TestEncodeDecode(t *testing.T) {
- type data struct {
- s string
- i int
- u8 uint8
- b bool
- f float32
- v interface{}
- }
-
- in := data{"foo", 42, 9, true, 1.234, "thing"}
-
- buf := bytes.Buffer{}
- e := NewEncoder(&buf)
- assertNil(e.Encode(in.s))
- assertNil(e.Encode(in.i))
- assertNil(e.Encode(in.u8))
- assertNil(e.Encode(in.b))
- assertNil(e.Encode(in.f))
- assertNil(e.Encode(in.v))
-
- var out data
- d := NewDecoder(&buf)
- assertNil(d.Decode(&out.s))
- assertNil(d.Decode(&out.i))
- assertNil(d.Decode(&out.u8))
- assertNil(d.Decode(&out.b))
- assertNil(d.Decode(&out.f))
- assertNil(d.Decode(&out.v))
-
- assertEqual(in, out)
-}
-
-func TestMap(t *testing.T) {
- d := NewDecoder(getReader("maps"))
-
- // Generic map
- var m Map
- assertDecode(d, Map{"one": int32(1), "two": int32(2), "three": int32(3)}, &m)
-
- // Interface as map
- var i interface{}
- assertDecode(d, Map{int32(1): "one", int32(2): "two", int32(3): "three"}, &i)
-
- d = NewDecoder(getReader("maps"))
- // Specific typed map
- var m2 map[string]int
- assertDecode(d, map[string]int{"one": 1, "two": 2, "three": 3}, &m2)
-
- // Round trip a nested map
- m = Map{int64(1): "one", "two": int32(2), true: Map{uint8(1): true, uint8(2): false}}
- bytes, err := Marshal(m, nil)
- assertNil(err)
- _, err = Unmarshal(bytes, &i)
- assertNil(err)
- assertEqual(m, i)
-}
-
-func TestList(t *testing.T) {
- d := NewDecoder(getReader("lists"))
- var l List
- assertDecode(d, List{int32(32), "foo", true}, &l)
- assertDecode(d, List{}, &l)
-}
-
-func FIXMETestMessage(t *testing.T) {
- // FIXME aconway 2015-04-09: integrate Message encoding under marshal/unmarshal API.
- bytes, err := ioutil.ReadAll(getReader("message"))
- assertNil(err)
- m, err := DecodeMessage(bytes)
- assertNil(err)
- fmt.Printf("%+v\n", m)
- assertEqual(m.Body(), "hello")
-
- bytes2 := make([]byte, len(bytes))
- bytes2, err = m.Encode(bytes2)
- assertNil(err)
- assertEqual(bytes, bytes2)
-}
-
-// FIXME aconway 2015-03-13: finish the full interop test
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/9276ae33/proton-c/bindings/go/amqp/marshal.go
----------------------------------------------------------------------
diff --git a/proton-c/bindings/go/amqp/marshal.go b/proton-c/bindings/go/amqp/marshal.go
deleted file mode 100644
index e5c2945..0000000
--- a/proton-c/bindings/go/amqp/marshal.go
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
-*/
-
-package amqp
-
-// #include <proton/codec.h>
-import "C"
-
-import (
- "io"
- "qpid.apache.org/proton/go/internal"
- "reflect"
- "unsafe"
-)
-
-func dataError(prefix string, data *C.pn_data_t) error {
- err := internal.PnError(unsafe.Pointer(C.pn_data_error(data)))
- if err != nil {
- err = internal.Errorf("%s: %s", prefix, err.(internal.Error))
- }
- return err
-}
-
-/*
-Marshal encodes a Go value as AMQP data in buffer.
-If buffer is nil, or is not large enough, a new buffer is created.
-
-Returns the buffer used for encoding with len() adjusted to the actual size of data.
-
-Go types are encoded as follows
-
- +-------------------------------------+--------------------------------------------+
- |Go type |AMQP type |
- +-------------------------------------+--------------------------------------------+
- |bool |bool |
- +-------------------------------------+--------------------------------------------+
- |int8, int16, int32, int64 (int) |byte, short, int, long (int or long) |
- +-------------------------------------+--------------------------------------------+
- |uint8, uint16, uint32, uint64 (uint) |ubyte, ushort, uint, ulong (uint or ulong) |
- +-------------------------------------+--------------------------------------------+
- |float32, float64 |float, double. |
- +-------------------------------------+--------------------------------------------+
- |string |string |
- +-------------------------------------+--------------------------------------------+
- |[]byte, Binary |binary |
- +-------------------------------------+--------------------------------------------+
- |Symbol |symbol |
- +-------------------------------------+--------------------------------------------+
- |interface{} |the contained type |
- +-------------------------------------+--------------------------------------------+
- |nil |null |
- +-------------------------------------+--------------------------------------------+
- |map[K]T |map with K and T converted as above |
- +-------------------------------------+--------------------------------------------+
- |Map |map, may have mixed types for keys, values |
- +-------------------------------------+--------------------------------------------+
- |[]T |list with T converted as above |
- +-------------------------------------+--------------------------------------------+
- |List |list, may have mixed types values |
- +-------------------------------------+--------------------------------------------+
-
-TODO Go types: array, slice, struct
-
-Go types that cannot be marshaled: complex64/128, uintptr, function, interface, channel
-*/
-func Marshal(v interface{}, buffer []byte) (outbuf []byte, err error) {
- defer internal.DoRecover(&err)
- data := C.pn_data(0)
- defer C.pn_data_free(data)
- put(data, v)
- encode := func(buf []byte) ([]byte, error) {
- n := int(C.pn_data_encode(data, cPtr(buf), cLen(buf)))
- switch {
- case n == int(C.PN_OVERFLOW):
- return buf, overflow
- case n < 0:
- return buf, dataError("marshal error", data)
- default:
- return buf[:n], nil
- }
- }
- return encodeGrow(buffer, encode)
-}
-
-const minEncode = 256
-
-// overflow is returned when an encoding function can't fit data in the buffer.
-var overflow = internal.Errorf("buffer too small")
-
-// encodeFn encodes into buffer[0:len(buffer)].
-// Returns buffer with length adjusted for data encoded.
-// If buffer too small, returns overflow as error.
-type encodeFn func(buffer []byte) ([]byte, error)
-
-// encodeGrow calls encode() into buffer, if it returns overflow grows the buffer.
-// Returns the final buffer.
-func encodeGrow(buffer []byte, encode encodeFn) ([]byte, error) {
- if buffer == nil || len(buffer) == 0 {
- buffer = make([]byte, minEncode)
- }
- var err error
- for buffer, err = encode(buffer); err == overflow; buffer, err = encode(buffer) {
- buffer = make([]byte, 2*len(buffer))
- }
- return buffer, err
-}
-
-func put(data *C.pn_data_t, v interface{}) {
- switch v := v.(type) {
- case nil:
- C.pn_data_put_null(data)
- case bool:
- C.pn_data_put_bool(data, C.bool(v))
- case int8:
- C.pn_data_put_byte(data, C.int8_t(v))
- case int16:
- C.pn_data_put_short(data, C.int16_t(v))
- case int32:
- C.pn_data_put_int(data, C.int32_t(v))
- case int64:
- C.pn_data_put_long(data, C.int64_t(v))
- case int:
- if unsafe.Sizeof(0) == 8 {
- C.pn_data_put_long(data, C.int64_t(v))
- } else {
- C.pn_data_put_int(data, C.int32_t(v))
- }
- case uint8:
- C.pn_data_put_ubyte(data, C.uint8_t(v))
- case uint16:
- C.pn_data_put_ushort(data, C.uint16_t(v))
- case uint32:
- C.pn_data_put_uint(data, C.uint32_t(v))
- case uint64:
- C.pn_data_put_ulong(data, C.uint64_t(v))
- case uint:
- if unsafe.Sizeof(0) == 8 {
- C.pn_data_put_ulong(data, C.uint64_t(v))
- } else {
- C.pn_data_put_uint(data, C.uint32_t(v))
- }
- case float32:
- C.pn_data_put_float(data, C.float(v))
- case float64:
- C.pn_data_put_double(data, C.double(v))
- case string:
- C.pn_data_put_string(data, pnBytes([]byte(v)))
- case []byte:
- C.pn_data_put_binary(data, pnBytes(v))
- case Binary:
- C.pn_data_put_binary(data, pnBytes([]byte(v)))
- case Symbol:
- C.pn_data_put_symbol(data, pnBytes([]byte(v)))
- case Map: // Special map type
- C.pn_data_put_map(data)
- C.pn_data_enter(data)
- for key, val := range v {
- put(data, key)
- put(data, val)
- }
- C.pn_data_exit(data)
- default:
- switch reflect.TypeOf(v).Kind() {
- case reflect.Map:
- putMap(data, v)
- case reflect.Slice:
- putList(data, v)
- default:
- panic(internal.Errorf("cannot marshal %s to AMQP", reflect.TypeOf(v)))
- }
- }
- err := dataError("marshal", data)
- if err != nil {
- panic(err)
- }
- return
-}
-
-func putMap(data *C.pn_data_t, v interface{}) {
- mapValue := reflect.ValueOf(v)
- C.pn_data_put_map(data)
- C.pn_data_enter(data)
- for _, key := range mapValue.MapKeys() {
- put(data, key.Interface())
- put(data, mapValue.MapIndex(key).Interface())
- }
- C.pn_data_exit(data)
-}
-
-func putList(data *C.pn_data_t, v interface{}) {
- listValue := reflect.ValueOf(v)
- C.pn_data_put_list(data)
- C.pn_data_enter(data)
- for i := 0; i < listValue.Len(); i++ {
- put(data, listValue.Index(i).Interface())
- }
- C.pn_data_exit(data)
-}
-
-// Encoder encodes AMQP values to an io.Writer
-type Encoder struct {
- writer io.Writer
- buffer []byte
-}
-
-// New encoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- return &Encoder{w, make([]byte, minEncode)}
-}
-
-func (e *Encoder) Encode(v interface{}) (err error) {
- e.buffer, err = Marshal(v, e.buffer)
- if err == nil {
- e.writer.Write(e.buffer)
- }
- return err
-}
-
-func replace(data *C.pn_data_t, v interface{}) {
- C.pn_data_clear(data)
- put(data, v)
-}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org