doc.go

/*
Package rabbithole is a Go client for the RabbitMQ HTTP API.

All HTTP API operations are accessible via `rabbithole.Client`, which
should be instantiated with `rabbithole.NewClient`.

	// URI, username, password
	rmqc, _ = NewClient("http://127.0.0.1:15672", "guest", "guest")

Getting Overview

	res, err := rmqc.Overview()

Node and Cluster Status

	var err error

	// => []NodeInfo, err
	xs, err := rmqc.ListNodes()

	node, err := rmqc.GetNode("rabbit@mercurio")
	// => NodeInfo, err

Operations on Connections

	xs, err := rmqc.ListConnections()
	// => []ConnectionInfo, err

	conn, err := rmqc.GetConnection("127.0.0.1:50545 -> 127.0.0.1:5672")
	// => ConnectionInfo, err

	// Forcefully close connection
	_, err := rmqc.CloseConnection("127.0.0.1:50545 -> 127.0.0.1:5672")
	// => *http.Response, err

Operations on Channels

	xs, err := rmqc.ListChannels()
	// => []ChannelInfo, err

	ch, err := rmqc.GetChannel("127.0.0.1:50545 -> 127.0.0.1:5672 (1)")
	// => ChannelInfo, err

Operations on Exchanges

	xs, err := rmqc.ListExchanges()
	// => []ExchangeInfo, err

	// list exchanges in a vhost
	xs, err := rmqc.ListExchangesIn("/")
	// => []ExchangeInfo, err

	// information about individual exchange
	x, err := rmqc.GetExchange("/", "amq.fanout")
	// => ExchangeInfo, err

	// declares an exchange
	resp, err := rmqc.DeclareExchange("/", "an.exchange", ExchangeSettings{Type: "fanout", Durable: false})
	// => *http.Response, err

	// deletes individual exchange
	resp, err := rmqc.DeleteExchange("/", "an.exchange")
	// => *http.Response, err

Operations on Queues

	xs, err := rmqc.ListQueues()
	// => []QueueInfo, err

	// list queues in a vhost
	xs, err := rmqc.ListQueuesIn("/")
	// => []QueueInfo, err

	// information about individual queue
	x, err := rmqc.GetQueue("/", "a.queue")
	// => QueueInfo, err

	// declares a queue
	resp, err := rmqc.DeclareQueue("/", "a.queue", QueueSettings{Durable: false})
	// => *http.Response, err

	// deletes individual queue
	resp, err := rmqc.DeleteQueue("/", "a.queue")
	// => *http.Response, err

	// purges all messages in queue
	resp, err := rmqc.PurgeQueue("/", "a.queue")
	// => *http.Response, err

Operations on Bindings

	bs, err := rmqc.ListBindings()
	// => []BindingInfo, err

	// list bindings in a vhost
	bs, err := rmqc.ListBindingsIn("/")
	// => []BindingInfo, err

	// list bindings of a queue
	bs, err := rmqc.ListQueueBindings("/", "a.queue")
	// => []BindingInfo, err

	// declare a binding
	resp, err := rmqc.DeclareBinding("/", BindingInfo{
	    Source: "an.exchange",
	    Destination: "a.queue",
	    DestinationType: "queue",
	    RoutingKey: "#",
	})
	// => *http.Response, err

	// deletes individual binding
	resp, err := rmqc.DeleteBinding("/", BindingInfo{
	    Source: "an.exchange",
	    Destination: "a.queue",
	    DestinationType: "queue",
	    RoutingKey: "#",
	    PropertiesKey: "%23",
	})
	// => *http.Response, err

Operations on Vhosts

	xs, err := rmqc.ListVhosts()
	// => []VhostInfo, err

	// information about individual vhost
	x, err := rmqc.GetVhost("/")
	// => VhostInfo, err

	// creates or updates individual vhost
	resp, err := rmqc.PutVhost("/", VhostSettings{Tracing: false})
	// => *http.Response, err

	// deletes individual vhost
	resp, err := rmqc.DeleteVhost("/")
	// => *http.Response, err

Managing Users

	xs, err := rmqc.ListUsers()
	// => []UserInfo, err

	// information about individual user
	x, err := rmqc.GetUser("my.user")
	// => UserInfo, err

	// creates or updates individual user
	resp, err := rmqc.PutUser("my.user", UserSettings{Password: "s3krE7", Tags: "management policymaker"})
	// => *http.Response, err

	// deletes individual user
	resp, err := rmqc.DeleteUser("my.user")
	// => *http.Response, err

Managing Permissions

	xs, err := rmqc.ListPermissions()
	// => []PermissionInfo, err

	// permissions of individual user
	x, err := rmqc.ListPermissionsOf("my.user")
	// => []PermissionInfo, err

	// permissions of individual user in vhost
	x, err := rmqc.GetPermissionsIn("/", "my.user")
	// => PermissionInfo, err

	// updates permissions of user in vhost
	resp, err := rmqc.UpdatePermissionsIn("/", "my.user", Permissions{Configure: ".*", Write: ".*", Read: ".*"})
	// => *http.Response, err

	// revokes permissions in vhost
	resp, err := rmqc.ClearPermissionsIn("/", "my.user")
	// => *http.Response, err

Managing Topic Permissions

	xs, err := rmqc.ListTopicPermissions()
	// => []TopicPermissionInfo, err

	// permissions of individual user
	x, err := rmqc.ListTopicPermissionsOf("my.user")
	// => []TopicPermissionInfo, err

	// permissions of individual user in vhost
	x, err := rmqc.GetTopicPermissionsIn("/", "my.user")
	// => []TopicPermissionInfo, err

	// updates permissions of user in vhost
	resp, err := rmqc.UpdateTopicPermissionsIn("/", "my.user", Permissions{Exchange: "amq.topic", Write: ".*", Read: ".*"})
	// => *http.Response, err

	// revokes permissions in vhost
	resp, err := rmqc.ClearTopicPermissionsIn("/", "my.user")
	// => *http.Response, err

	// revokes single permissions in vhost
	resp, err := rmqc.DeleteTopicPermissionsIn("/", "my.user", "exchange")
	// => *http.Response, err

Managing Runtime Parameters

	// list all runtime parameters
	params, err := rmqc.ListRuntimeParameters()
	// => []RuntimeParameter, error

	// list all runtime parameters for a component
	params, err := rmqc.ListRuntimeParametersFor("federation-upstream")
	// => []RuntimeParameter, error

	// list runtime parameters in a vhost
	params, err := rmqc.ListRuntimeParametersIn("federation-upstream", "/")
	// => []RuntimeParameter, error

	// information about a runtime parameter
	p, err := rmqc.GetRuntimeParameter("federation-upstream", "/", "name")
	// => *RuntimeParameter, error

	// declare or update a runtime parameter
	resp, err := rmqc.PutRuntimeParameter("federation-upstream", "/", "name", FederationDefinition{
	    Uri: "amqp://server-name",
	})
	// => *http.Response, error

	// remove a runtime parameter
	resp, err := rmqc.DeleteRuntimeParameter("federation-upstream", "/", "name")
	// => *http.Response, error

Managing Federation Upstreams

	// list all federation upstreams
	ups, err := rmqc.ListFederationUpstreams()
	// => []FederationUpstream, error

	// list federation upstreams in a vhost
	ups, err := rmqc.ListFederationUpstreamsIn("/")
	// => []FederationUpstream, error

	// information about a federated upstream
	up, err := rmqc.GetFederationUpstream("/", "upstream-name")
	// => *FederationUpstream, error

	// declare or update a federation upstream
	resp, err := rmqc.PutFederationUpstream("/", "upstream-name", FederationDefinition{
	  Uri: "amqp://server-name",
	})
	// => *http.Response, error

	// delete an upstream
	resp, err := rmqc.DeleteFederationUpstream("/", "upstream-name")
	// => *http.Response, error

Managing Global Parameters

	// list all global parameters
	params, err := rmqc.ListGlobalParameters()
	// => []GlobalRuntimeParameter, error

	// get a global parameter
	p, err := rmqc.GetGlobalParameter("name")
	// => *GlobalRuntimeParameter, error

	// declare or update a global parameter
	resp, err := rmqc.PutGlobalParameter("name", map[string]interface{
	    endpoints: "amqp://server-name",
	})
	// => *http.Response, error

	// delete a global parameter
	resp, err := rmqc.DeleteGlobalParameter("name")
	// => *http.Response, error

Operations on cluster name

	// Get cluster name
	cn, err := rmqc.GetClusterName()
	// => ClusterName, err

	// Rename cluster
	resp, err := rmqc.SetClusterName(ClusterName{Name: "rabbitmq@rabbit-hole"})
	// => *http.Response, err
*/
package rabbithole