├── .chglog
    ├── CHANGELOG.tpl.md
    └── config.yml
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── connection
    └── connection.go
├── example
    ├── multichannel
    │   ├── consumer
    │   │   └── consumer.go
    │   └── publisher
    │   │   └── publisher.go
    └── simple
    │   ├── consumer
    │       └── consumer.go
    │   └── publisher
    │       └── publisher.go
├── exchange
    └── exchange.go
├── go.mod
├── go.sum
├── mq.go
├── publish.go
├── queue
    ├── bind.go
    ├── consumer.go
    └── queue.go
└── rabbitmq.go


/.chglog/CHANGELOG.tpl.md:
--------------------------------------------------------------------------------
 1 | {{ range .Versions }}
 2 | <a name="{{ .Tag.Name }}"></a>
 3 | ## {{ if .Tag.Previous }}[{{ .Tag.Name }}]({{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}){{ else }}{{ .Tag.Name }}{{ end }} ({{ datetime "2006-01-02" .Tag.Date }})
 4 | 
 5 | {{ range .CommitGroups -}}
 6 | ### {{ .Title }}
 7 | 
 8 | {{ range .Commits -}}
 9 | * {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
10 | {{ end }}
11 | {{ end -}}
12 | 
13 | {{- if .NoteGroups -}}
14 | {{ range .NoteGroups -}}
15 | ### {{ .Title }}
16 | 
17 | {{ range .Notes }}
18 | {{ .Body }}
19 | {{ end }}
20 | {{ end -}}
21 | {{ end -}}
22 | {{ end -}}


--------------------------------------------------------------------------------
/.chglog/config.yml:
--------------------------------------------------------------------------------
 1 | style: github
 2 | template: CHANGELOG.tpl.md
 3 | info:
 4 |   title: CHANGELOG
 5 |   repository_url: https://github.com/hadihammurabi/go-rabbitmq
 6 | options:
 7 |   commits:
 8 |     # filters:
 9 |     #   Type:
10 |     #     - feat
11 |     #     - fix
12 |     #     - perf
13 |     #     - refactor
14 |   commit_groups:
15 |     # title_maps:
16 |     #   feat: Features
17 |     #   fix: Bug Fixes
18 |     #   perf: Performance Improvements
19 |     #   refactor: Code Refactoring
20 |   header:
21 |     pattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$"
22 |     pattern_maps:
23 |       - Type
24 |       - Scope
25 |       - Subject
26 |   notes:
27 |     keywords:
28 |       - BREAKING CHANGE


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hadihammurabi/go-rabbitmq/bf7ae8da96bec355af834dbf48fa682382862bc5/.gitignore


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | 
  2 | <a name="0.1.2"></a>
  3 | ## [0.1.2](https://github.com/hadihammurabi/go-rabbitmq/compare/0.1.1...0.1.2) (2021-07-11)
  4 | 
  5 | ### Chore
  6 | 
  7 | * add type for ChannelDefault const
  8 | 
  9 | ### Docs
 10 | 
 11 | * fix formatting for publish message example
 12 | * update code example with new options API
 13 | * update multiple channel feature
 14 | 
 15 | ### Feat
 16 | 
 17 | * **channel:** add WithChannel to get mq with named channel
 18 | * **connection:** func to create options
 19 | * **example:** simple consumer
 20 | * **example:** simple publisher
 21 | * **exchange:** func to create options
 22 | * **mq:** multiple channel
 23 | * **publish:** func to create options
 24 | * **queue:** func to create options
 25 | * **queue-bind:** func to create options
 26 | 
 27 | ### Refactor
 28 | 
 29 | * rename MQConfigBind to MQConfigQueueBind
 30 | * only one MQ type (needed for now)
 31 | 
 32 | 
 33 | <a name="0.1.1"></a>
 34 | ## [0.1.1](https://github.com/hadihammurabi/go-rabbitmq/compare/0.1.0...0.1.1) (2021-07-07)
 35 | 
 36 | ### Chore
 37 | 
 38 | * generate change log
 39 | 
 40 | ### Docs
 41 | 
 42 | * how it works
 43 | * update mq Consume guide
 44 | * update mq Close guide
 45 | * update QueueBind with new API
 46 | * update NewMQ, DeclareQueue, and DeclareExchange with new API
 47 | * consume messages guide
 48 | * publish a message guide
 49 | * bind queue to exchange guide
 50 | * declare queue guide
 51 | * connect to rabbitmq guide
 52 | * installation guide
 53 | * put list of features
 54 | * put background
 55 | * add license
 56 | * contributions guide
 57 | * readme content structure
 58 | 
 59 | ### Feat
 60 | 
 61 | * **mq:** can close connection and channel from mq object
 62 | * **mq:** can bind queue from mq object
 63 | * **mq:** can declare exchange from mq object
 64 | * **mq:** can declare queue from mq object
 65 | 
 66 | ### Fix
 67 | 
 68 | * **docs:** code highlight for some examples
 69 | 
 70 | ### Refactor
 71 | 
 72 | * mq Consume queue itself
 73 | * new mq only need url
 74 | 
 75 | 
 76 | <a name="0.1.0"></a>
 77 | ## 0.1.0 (2021-07-06)
 78 | 
 79 | ### Chore
 80 | 
 81 | * configure git chglog
 82 | 
 83 | ### Feat
 84 | 
 85 | * **connection:** can connect
 86 | * **mq:** builder pattern
 87 | * **mq:** can publish and subscribe (fanout)
 88 | * **mq:** can publish and subscribe (direct)
 89 | * **queue:** can create/declare queue
 90 | 
 91 | ### Refactor
 92 | 
 93 | * manual consumer data listening
 94 | * rename MQWithExchangeConfig to MQConfigWithExchange
 95 | * rename MQWithQueueConfig to MQConfigWithQueue
 96 | * GetQueue contract for mq
 97 | * add contract for all mq
 98 | * separate new mq and new mq with a queue
 99 | 
100 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Mozilla Public License Version 2.0
  2 | ==================================
  3 | 
  4 | 1. Definitions
  5 | --------------
  6 | 
  7 | 1.1. "Contributor"
  8 |     means each individual or legal entity that creates, contributes to
  9 |     the creation of, or owns Covered Software.
 10 | 
 11 | 1.2. "Contributor Version"
 12 |     means the combination of the Contributions of others (if any) used
 13 |     by a Contributor and that particular Contributor's Contribution.
 14 | 
 15 | 1.3. "Contribution"
 16 |     means Covered Software of a particular Contributor.
 17 | 
 18 | 1.4. "Covered Software"
 19 |     means Source Code Form to which the initial Contributor has attached
 20 |     the notice in Exhibit A, the Executable Form of such Source Code
 21 |     Form, and Modifications of such Source Code Form, in each case
 22 |     including portions thereof.
 23 | 
 24 | 1.5. "Incompatible With Secondary Licenses"
 25 |     means
 26 | 
 27 |     (a) that the initial Contributor has attached the notice described
 28 |         in Exhibit B to the Covered Software; or
 29 | 
 30 |     (b) that the Covered Software was made available under the terms of
 31 |         version 1.1 or earlier of the License, but not also under the
 32 |         terms of a Secondary License.
 33 | 
 34 | 1.6. "Executable Form"
 35 |     means any form of the work other than Source Code Form.
 36 | 
 37 | 1.7. "Larger Work"
 38 |     means a work that combines Covered Software with other material, in
 39 |     a separate file or files, that is not Covered Software.
 40 | 
 41 | 1.8. "License"
 42 |     means this document.
 43 | 
 44 | 1.9. "Licensable"
 45 |     means having the right to grant, to the maximum extent possible,
 46 |     whether at the time of the initial grant or subsequently, any and
 47 |     all of the rights conveyed by this License.
 48 | 
 49 | 1.10. "Modifications"
 50 |     means any of the following:
 51 | 
 52 |     (a) any file in Source Code Form that results from an addition to,
 53 |         deletion from, or modification of the contents of Covered
 54 |         Software; or
 55 | 
 56 |     (b) any new file in Source Code Form that contains any Covered
 57 |         Software.
 58 | 
 59 | 1.11. "Patent Claims" of a Contributor
 60 |     means any patent claim(s), including without limitation, method,
 61 |     process, and apparatus claims, in any patent Licensable by such
 62 |     Contributor that would be infringed, but for the grant of the
 63 |     License, by the making, using, selling, offering for sale, having
 64 |     made, import, or transfer of either its Contributions or its
 65 |     Contributor Version.
 66 | 
 67 | 1.12. "Secondary License"
 68 |     means either the GNU General Public License, Version 2.0, the GNU
 69 |     Lesser General Public License, Version 2.1, the GNU Affero General
 70 |     Public License, Version 3.0, or any later versions of those
 71 |     licenses.
 72 | 
 73 | 1.13. "Source Code Form"
 74 |     means the form of the work preferred for making modifications.
 75 | 
 76 | 1.14. "You" (or "Your")
 77 |     means an individual or a legal entity exercising rights under this
 78 |     License. For legal entities, "You" includes any entity that
 79 |     controls, is controlled by, or is under common control with You. For
 80 |     purposes of this definition, "control" means (a) the power, direct
 81 |     or indirect, to cause the direction or management of such entity,
 82 |     whether by contract or otherwise, or (b) ownership of more than
 83 |     fifty percent (50%) of the outstanding shares or beneficial
 84 |     ownership of such entity.
 85 | 
 86 | 2. License Grants and Conditions
 87 | --------------------------------
 88 | 
 89 | 2.1. Grants
 90 | 
 91 | Each Contributor hereby grants You a world-wide, royalty-free,
 92 | non-exclusive license:
 93 | 
 94 | (a) under intellectual property rights (other than patent or trademark)
 95 |     Licensable by such Contributor to use, reproduce, make available,
 96 |     modify, display, perform, distribute, and otherwise exploit its
 97 |     Contributions, either on an unmodified basis, with Modifications, or
 98 |     as part of a Larger Work; and
 99 | 
100 | (b) under Patent Claims of such Contributor to make, use, sell, offer
101 |     for sale, have made, import, and otherwise transfer either its
102 |     Contributions or its Contributor Version.
103 | 
104 | 2.2. Effective Date
105 | 
106 | The licenses granted in Section 2.1 with respect to any Contribution
107 | become effective for each Contribution on the date the Contributor first
108 | distributes such Contribution.
109 | 
110 | 2.3. Limitations on Grant Scope
111 | 
112 | The licenses granted in this Section 2 are the only rights granted under
113 | this License. No additional rights or licenses will be implied from the
114 | distribution or licensing of Covered Software under this License.
115 | Notwithstanding Section 2.1(b) above, no patent license is granted by a
116 | Contributor:
117 | 
118 | (a) for any code that a Contributor has removed from Covered Software;
119 |     or
120 | 
121 | (b) for infringements caused by: (i) Your and any other third party's
122 |     modifications of Covered Software, or (ii) the combination of its
123 |     Contributions with other software (except as part of its Contributor
124 |     Version); or
125 | 
126 | (c) under Patent Claims infringed by Covered Software in the absence of
127 |     its Contributions.
128 | 
129 | This License does not grant any rights in the trademarks, service marks,
130 | or logos of any Contributor (except as may be necessary to comply with
131 | the notice requirements in Section 3.4).
132 | 
133 | 2.4. Subsequent Licenses
134 | 
135 | No Contributor makes additional grants as a result of Your choice to
136 | distribute the Covered Software under a subsequent version of this
137 | License (see Section 10.2) or under the terms of a Secondary License (if
138 | permitted under the terms of Section 3.3).
139 | 
140 | 2.5. Representation
141 | 
142 | Each Contributor represents that the Contributor believes its
143 | Contributions are its original creation(s) or it has sufficient rights
144 | to grant the rights to its Contributions conveyed by this License.
145 | 
146 | 2.6. Fair Use
147 | 
148 | This License is not intended to limit any rights You have under
149 | applicable copyright doctrines of fair use, fair dealing, or other
150 | equivalents.
151 | 
152 | 2.7. Conditions
153 | 
154 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
155 | in Section 2.1.
156 | 
157 | 3. Responsibilities
158 | -------------------
159 | 
160 | 3.1. Distribution of Source Form
161 | 
162 | All distribution of Covered Software in Source Code Form, including any
163 | Modifications that You create or to which You contribute, must be under
164 | the terms of this License. You must inform recipients that the Source
165 | Code Form of the Covered Software is governed by the terms of this
166 | License, and how they can obtain a copy of this License. You may not
167 | attempt to alter or restrict the recipients' rights in the Source Code
168 | Form.
169 | 
170 | 3.2. Distribution of Executable Form
171 | 
172 | If You distribute Covered Software in Executable Form then:
173 | 
174 | (a) such Covered Software must also be made available in Source Code
175 |     Form, as described in Section 3.1, and You must inform recipients of
176 |     the Executable Form how they can obtain a copy of such Source Code
177 |     Form by reasonable means in a timely manner, at a charge no more
178 |     than the cost of distribution to the recipient; and
179 | 
180 | (b) You may distribute such Executable Form under the terms of this
181 |     License, or sublicense it under different terms, provided that the
182 |     license for the Executable Form does not attempt to limit or alter
183 |     the recipients' rights in the Source Code Form under this License.
184 | 
185 | 3.3. Distribution of a Larger Work
186 | 
187 | You may create and distribute a Larger Work under terms of Your choice,
188 | provided that You also comply with the requirements of this License for
189 | the Covered Software. If the Larger Work is a combination of Covered
190 | Software with a work governed by one or more Secondary Licenses, and the
191 | Covered Software is not Incompatible With Secondary Licenses, this
192 | License permits You to additionally distribute such Covered Software
193 | under the terms of such Secondary License(s), so that the recipient of
194 | the Larger Work may, at their option, further distribute the Covered
195 | Software under the terms of either this License or such Secondary
196 | License(s).
197 | 
198 | 3.4. Notices
199 | 
200 | You may not remove or alter the substance of any license notices
201 | (including copyright notices, patent notices, disclaimers of warranty,
202 | or limitations of liability) contained within the Source Code Form of
203 | the Covered Software, except that You may alter any license notices to
204 | the extent required to remedy known factual inaccuracies.
205 | 
206 | 3.5. Application of Additional Terms
207 | 
208 | You may choose to offer, and to charge a fee for, warranty, support,
209 | indemnity or liability obligations to one or more recipients of Covered
210 | Software. However, You may do so only on Your own behalf, and not on
211 | behalf of any Contributor. You must make it absolutely clear that any
212 | such warranty, support, indemnity, or liability obligation is offered by
213 | You alone, and You hereby agree to indemnify every Contributor for any
214 | liability incurred by such Contributor as a result of warranty, support,
215 | indemnity or liability terms You offer. You may include additional
216 | disclaimers of warranty and limitations of liability specific to any
217 | jurisdiction.
218 | 
219 | 4. Inability to Comply Due to Statute or Regulation
220 | ---------------------------------------------------
221 | 
222 | If it is impossible for You to comply with any of the terms of this
223 | License with respect to some or all of the Covered Software due to
224 | statute, judicial order, or regulation then You must: (a) comply with
225 | the terms of this License to the maximum extent possible; and (b)
226 | describe the limitations and the code they affect. Such description must
227 | be placed in a text file included with all distributions of the Covered
228 | Software under this License. Except to the extent prohibited by statute
229 | or regulation, such description must be sufficiently detailed for a
230 | recipient of ordinary skill to be able to understand it.
231 | 
232 | 5. Termination
233 | --------------
234 | 
235 | 5.1. The rights granted under this License will terminate automatically
236 | if You fail to comply with any of its terms. However, if You become
237 | compliant, then the rights granted under this License from a particular
238 | Contributor are reinstated (a) provisionally, unless and until such
239 | Contributor explicitly and finally terminates Your grants, and (b) on an
240 | ongoing basis, if such Contributor fails to notify You of the
241 | non-compliance by some reasonable means prior to 60 days after You have
242 | come back into compliance. Moreover, Your grants from a particular
243 | Contributor are reinstated on an ongoing basis if such Contributor
244 | notifies You of the non-compliance by some reasonable means, this is the
245 | first time You have received notice of non-compliance with this License
246 | from such Contributor, and You become compliant prior to 30 days after
247 | Your receipt of the notice.
248 | 
249 | 5.2. If You initiate litigation against any entity by asserting a patent
250 | infringement claim (excluding declaratory judgment actions,
251 | counter-claims, and cross-claims) alleging that a Contributor Version
252 | directly or indirectly infringes any patent, then the rights granted to
253 | You by any and all Contributors for the Covered Software under Section
254 | 2.1 of this License shall terminate.
255 | 
256 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
257 | end user license agreements (excluding distributors and resellers) which
258 | have been validly granted by You or Your distributors under this License
259 | prior to termination shall survive termination.
260 | 
261 | ************************************************************************
262 | *                                                                      *
263 | *  6. Disclaimer of Warranty                                           *
264 | *  -------------------------                                           *
265 | *                                                                      *
266 | *  Covered Software is provided under this License on an "as is"       *
267 | *  basis, without warranty of any kind, either expressed, implied, or  *
268 | *  statutory, including, without limitation, warranties that the       *
269 | *  Covered Software is free of defects, merchantable, fit for a        *
270 | *  particular purpose or non-infringing. The entire risk as to the     *
271 | *  quality and performance of the Covered Software is with You.        *
272 | *  Should any Covered Software prove defective in any respect, You     *
273 | *  (not any Contributor) assume the cost of any necessary servicing,   *
274 | *  repair, or correction. This disclaimer of warranty constitutes an   *
275 | *  essential part of this License. No use of any Covered Software is   *
276 | *  authorized under this License except under this disclaimer.         *
277 | *                                                                      *
278 | ************************************************************************
279 | 
280 | ************************************************************************
281 | *                                                                      *
282 | *  7. Limitation of Liability                                          *
283 | *  --------------------------                                          *
284 | *                                                                      *
285 | *  Under no circumstances and under no legal theory, whether tort      *
286 | *  (including negligence), contract, or otherwise, shall any           *
287 | *  Contributor, or anyone who distributes Covered Software as          *
288 | *  permitted above, be liable to You for any direct, indirect,         *
289 | *  special, incidental, or consequential damages of any character      *
290 | *  including, without limitation, damages for lost profits, loss of    *
291 | *  goodwill, work stoppage, computer failure or malfunction, or any    *
292 | *  and all other commercial damages or losses, even if such party      *
293 | *  shall have been informed of the possibility of such damages. This   *
294 | *  limitation of liability shall not apply to liability for death or   *
295 | *  personal injury resulting from such party's negligence to the       *
296 | *  extent applicable law prohibits such limitation. Some               *
297 | *  jurisdictions do not allow the exclusion or limitation of           *
298 | *  incidental or consequential damages, so this exclusion and          *
299 | *  limitation may not apply to You.                                    *
300 | *                                                                      *
301 | ************************************************************************
302 | 
303 | 8. Litigation
304 | -------------
305 | 
306 | Any litigation relating to this License may be brought only in the
307 | courts of a jurisdiction where the defendant maintains its principal
308 | place of business and such litigation shall be governed by laws of that
309 | jurisdiction, without reference to its conflict-of-law provisions.
310 | Nothing in this Section shall prevent a party's ability to bring
311 | cross-claims or counter-claims.
312 | 
313 | 9. Miscellaneous
314 | ----------------
315 | 
316 | This License represents the complete agreement concerning the subject
317 | matter hereof. If any provision of this License is held to be
318 | unenforceable, such provision shall be reformed only to the extent
319 | necessary to make it enforceable. Any law or regulation which provides
320 | that the language of a contract shall be construed against the drafter
321 | shall not be used to construe this License against a Contributor.
322 | 
323 | 10. Versions of the License
324 | ---------------------------
325 | 
326 | 10.1. New Versions
327 | 
328 | Mozilla Foundation is the license steward. Except as provided in Section
329 | 10.3, no one other than the license steward has the right to modify or
330 | publish new versions of this License. Each version will be given a
331 | distinguishing version number.
332 | 
333 | 10.2. Effect of New Versions
334 | 
335 | You may distribute the Covered Software under the terms of the version
336 | of the License under which You originally received the Covered Software,
337 | or under the terms of any subsequent version published by the license
338 | steward.
339 | 
340 | 10.3. Modified Versions
341 | 
342 | If you create software not governed by this License, and you want to
343 | create a new license for such software, you may create and use a
344 | modified version of this License if you rename the license and remove
345 | any references to the name of the license steward (except to note that
346 | such modified license differs from this License).
347 | 
348 | 10.4. Distributing Source Code Form that is Incompatible With Secondary
349 | Licenses
350 | 
351 | If You choose to distribute Source Code Form that is Incompatible With
352 | Secondary Licenses under the terms of this version of the License, the
353 | notice described in Exhibit B of this License must be attached.
354 | 
355 | Exhibit A - Source Code Form License Notice
356 | -------------------------------------------
357 | 
358 |   This Source Code Form is subject to the terms of the Mozilla Public
359 |   License, v. 2.0. If a copy of the MPL was not distributed with this
360 |   file, You can obtain one at http://mozilla.org/MPL/2.0/.
361 | 
362 | If it is not possible or desirable to put the notice in a particular
363 | file, then You may include the notice in a location (such as a LICENSE
364 | file in a relevant directory) where a recipient would be likely to look
365 | for such a notice.
366 | 
367 | You may add additional accurate notices of copyright ownership.
368 | 
369 | Exhibit B - "Incompatible With Secondary Licenses" Notice
370 | ---------------------------------------------------------
371 | 
372 |   This Source Code Form is "Incompatible With Secondary Licenses", as
373 |   defined by the Mozilla Public License, v. 2.0.
374 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # go-rabbitmq
  2 | Golang AMQP wrapper for RabbitMQ with better API 
  3 | 
  4 | # Table of Contents
  5 | * [Background](#background)
  6 | * [Features](#features)
  7 | * [Usage](#usage)
  8 |   * [Installation](#installation)
  9 |   * [Connect to RabbitMQ](#connect-to-rabbitmq)
 10 |   * [Declare Queue](#declare-queue)
 11 |   * [Declare Exchange](#declare-exchange)
 12 |   * [Bind Queue to Exchange](#bind-queue-to-exchange)
 13 |   * [Publish a Message](#publish-a-message)
 14 |   * [Consume Messages](#consume-messages)
 15 | * [How It Works](#how-it-works)
 16 | * [License](#license)
 17 | * [Contributing](#contributing)
 18 | 
 19 | # Background
 20 | In [Golang](https://golang.org), to use [RabbitMQ](https://www.rabbitmq.com) with [AMQP](https://www.amqp.org) has advantages, especially in messaging systems.
 21 | It's done with the [AMQP connector](https://github.com/streadway/amqp).
 22 | But, the problem is it has a less convenient API.
 23 | Programmers have to write something that should be set by default.
 24 | For example, when creating a queue on RabbitMQ.
 25 | We have to do this.
 26 | ```go
 27 | q, err := ch.QueueDeclare(
 28 |   "hello", // name
 29 |   false,   // durable
 30 |   false,   // delete when unused
 31 |   false,   // exclusive
 32 |   false,   // no-wait
 33 |   nil,     // arguments
 34 | )
 35 | failOnError(err, "Failed to declare a queue")
 36 | ```
 37 | Too many `false` in there, which should be set as the default value.
 38 | 
 39 | By using [this](.) module, we can do same think with less code. See above.
 40 | ```go
 41 | q, err := mq.Queue().
 42 | 	WithName("hello").
 43 | 	Declare()
 44 | failOnError(err, "Failed to declare a queue")
 45 | ```
 46 | No need to write `false`, because it is the default value.
 47 | 
 48 | So, to conclude, this module makes it easy to use amqp for rabbitmq.
 49 | 
 50 | # Features
 51 | * Built on top of famous [AMQP connector](https://github.com/streadway/amqp) in Go.
 52 | * Connection, channel, queue, or any original objects by the AMQP connector are publicly exposed, so that can be controlled manually.
 53 | * It use construction API.
 54 | * Reuse connection to create MQ stuff.
 55 | 
 56 | # Usage
 57 | ## Installation
 58 | Inside terminal emulator, simply run command below.
 59 | ```sh
 60 | go get github.com/hadihammurabi/go-rabbitmq
 61 | ```
 62 | 
 63 | After installation it can be imported into any Go project.
 64 | For example.
 65 | ```go
 66 | package main
 67 | 
 68 | import (
 69 |  rabbitmq "github.com/hadihammurabi/go-rabbitmq"
 70 | )
 71 | ```
 72 | 
 73 | ## Connect to RabbitMQ
 74 | It can do as below.
 75 | ```go
 76 | mq, err := rabbitmq.New("amqp://guest:guest@localhost:5672/")
 77 | if err != nil {
 78 |  log.Fatal(err)
 79 | }
 80 | 
 81 | // don't forget to close the connection and channel
 82 | defer mq.Close()
 83 | ```
 84 | 
 85 | ## Declare Queue
 86 | Queue declaration can be done like this, after connecting to mq of course.
 87 | > It only connects to the queue if the queue exists or create one if it doesn't exist. (RabbitMQ behavior)
 88 | ```go
 89 | q, err := mq.Queue().
 90 | 	WithName("hello").
 91 | 	Declare()
 92 | if err != nil {
 93 |  log.Fatal(err)
 94 | }
 95 | ```
 96 | 
 97 | ## Declare Exchange
 98 | Exchange declaration can be done like this, after connecting to mq of course.
 99 | ```go
100 | err := mq.Exchange().
101 | 	WithName("hello").
102 | 	WithType(exchange.TypeFanout)).
103 | 	Declare()
104 | if err != nil {
105 |  log.Fatal(err)
106 | }
107 | ```
108 | 
109 | ## Bind Queue to Exchange
110 | Every message published to exchange will be distributed to every bound queue.
111 | To bind queue with exchange, follow example below.
112 | ```go
113 | err := q.Binding().
114 | 	WithExchange("hello").
115 | 	Bind()
116 | if err != nil {
117 |  log.Fatal(err)
118 | }
119 | ```
120 | 
121 | ## Publish a Message
122 | A message can be sent to exchange by mentioning the name exchange.
123 | Publishing a message can do like this.
124 | ```go
125 | err := mq.Publish(
126 |   rabbitmq.NewPublishOptions().
127 |         SetExchange("hello").
128 | 	SetMessage(amqp.Publishing{
129 | 		ContentType: "text/plain",
130 | 		Body:        []byte(body),
131 | 	}),
132 | )
133 | if err != nil {
134 |  log.Fatal(err)
135 | }
136 | ```
137 | 
138 | ## Consume Messages
139 | Every message in the queue can be consumed by the queue consumer.
140 | To consume messages in queue can do like this.
141 | 
142 | > The following code will run forever to listen for new message in queue.
143 | ```go
144 | msgs, err := mq.Consumer().Consume()
145 | if err != nil {
146 |  log.Fatal(err)
147 | }
148 | 
149 | forever := make(chan bool)
150 | go func() {
151 |   for msg := range msgs {
152 |     fmt.Println(string(msg.Body))
153 |     msg.Ack(false)
154 |   }
155 | }()
156 | <-forever
157 | ```
158 | 
159 | # How It Works
160 | Every AMQP related function call will invoke the AMQP connector function.
161 | For example when creating a new MQ, it will call the AMQP connection function.
162 | Declare queue, declare exchange, publish, consume, etc will do the same.
163 | 
164 | > Please use any references made previously to prevent too many function calls.
165 | 
166 | # License
167 | This project is under [Mozilla Public License 2.0](./LICENSE).
168 | 
169 | # Contributing
170 | Realy love any contribution. Feel free to create a [Pull Request](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) with following this [commit convention](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit). 
171 | 


--------------------------------------------------------------------------------
/connection/connection.go:
--------------------------------------------------------------------------------
 1 | package connection
 2 | 
 3 | import "github.com/streadway/amqp"
 4 | 
 5 | type Connection struct {
 6 | 	URL string
 7 | 
 8 | 	connection *amqp.Connection
 9 | }
10 | 
11 | func New(url string) (*Connection, error) {
12 | 	connData := &Connection{
13 | 		URL: url,
14 | 	}
15 | 	conn, err := connData.Dial()
16 | 	if err != nil {
17 | 		return nil, err
18 | 	}
19 | 
20 | 	return conn, nil
21 | }
22 | 
23 | func (c *Connection) Channel() (*amqp.Channel, error) {
24 | 	return c.connection.Channel()
25 | }
26 | 
27 | func (c *Connection) Close() error {
28 | 	return c.connection.Close()
29 | }
30 | 
31 | func (c *Connection) Raw() *amqp.Connection {
32 | 	return c.connection
33 | }
34 | 
35 | func (c *Connection) Dial() (*Connection, error) {
36 | 	amqpConn, err := amqp.Dial(c.URL)
37 | 	if err != nil {
38 | 		return nil, err
39 | 	}
40 | 
41 | 	conn := &Connection{
42 | 		connection: amqpConn,
43 | 		URL:        c.URL,
44 | 	}
45 | 
46 | 	return conn, nil
47 | }
48 | 
49 | func From(connection *Connection) *Connection {
50 | 	return &Connection{
51 | 		connection: connection.connection,
52 | 		URL:        connection.URL,
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/example/multichannel/consumer/consumer.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | // this is an example of consuming message from queue
 4 | // steps to do here are same as https://www.rabbitmq.com/tutorials/tutorial-one-go.html
 5 | // but using the wrapper API
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"log"
10 | 
11 | 	rabbitmq "github.com/hadihammurabi/go-rabbitmq"
12 | )
13 | 
14 | func failOnError(err error, msg string) {
15 | 	if err != nil {
16 | 		log.Fatalf("%s: %s", msg, err)
17 | 	}
18 | }
19 | 
20 | func main() {
21 | 	def, err := rabbitmq.New("amqp://guest:guest@localhost:5672/")
22 | 	failOnError(err, "Failed to create a MQ")
23 | 	defer def.Close()
24 | 
25 | 	del, err := rabbitmq.NewFromConnection(def.Connection())
26 | 	failOnError(err, fmt.Sprintf("%v", err))
27 | 	defer del.Close()
28 | 
29 | 	q, err := del.Queue().
30 | 		WithName("hello").
31 | 		WithChannel(del.Channel()).
32 | 		Declare()
33 | 	failOnError(err, "Failed to declare a queue")
34 | 
35 | 	log.Println(" [*] Waiting for messages. To exit press CTRL+C")
36 | 
37 | 	results, err := q.Consumer().Consume()
38 | 	failOnError(err, "Failed to register a consumer")
39 | 
40 | 	for result := range results {
41 | 		log.Println("result: ", string(result.Body))
42 | 		result.Ack(false)
43 | 	}
44 | 	forever := make(chan bool)
45 | 	<-forever
46 | }
47 | 


--------------------------------------------------------------------------------
/example/multichannel/publisher/publisher.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | // this is an example of publising message directly into queue with multi channel
 4 | // steps to do here are same as https://www.rabbitmq.com/tutorials/tutorial-one-go.html
 5 | // but using the wrapper API
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"log"
10 | 	"sync"
11 | 
12 | 	rabbitmq "github.com/hadihammurabi/go-rabbitmq"
13 | 	"github.com/streadway/amqp"
14 | )
15 | 
16 | func failOnError(err error, msg string) {
17 | 	if err != nil {
18 | 		log.Fatalf("%s: %s", msg, err)
19 | 	}
20 | }
21 | 
22 | func main() {
23 | 	def, err := rabbitmq.New("amqp://guest:guest@localhost:5672/")
24 | 	failOnError(err, fmt.Sprintf("%v", err))
25 | 	defer def.Close()
26 | 
27 | 	del, err := rabbitmq.NewFromConnection(def.Connection())
28 | 	failOnError(err, fmt.Sprintf("%v", err))
29 | 	defer del.Close()
30 | 
31 | 	_, err = del.Queue().
32 | 		WithName("hello").
33 | 		WithChannel(del.Channel()).
34 | 		Declare()
35 | 
36 | 	failOnError(err, fmt.Sprintf("%v", err))
37 | 
38 | 	var wg sync.WaitGroup
39 | 	max := 10
40 | 	wg.Add(max)
41 | 	for i := 0; i < max; i++ {
42 | 		go func(a int) {
43 | 			defer wg.Done()
44 | 			body := fmt.Sprintf("Hello World %d !", a)
45 | 			err = del.Publish(&rabbitmq.MQConfigPublish{
46 | 				RoutingKey: del.Queue().Name,
47 | 				Message: amqp.Publishing{
48 | 					ContentType: "text/plain",
49 | 					Body:        []byte(body),
50 | 				},
51 | 			})
52 | 		}(i)
53 | 	}
54 | 	wg.Wait()
55 | }
56 | 


--------------------------------------------------------------------------------
/example/simple/consumer/consumer.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | // this is an example of consuming message from queue
 4 | // steps to do here are same as https://www.rabbitmq.com/tutorials/tutorial-one-go.html
 5 | // but using the wrapper API
 6 | 
 7 | import (
 8 | 	"log"
 9 | 
10 | 	rabbitmq "github.com/hadihammurabi/go-rabbitmq"
11 | )
12 | 
13 | func failOnError(err error, msg string) {
14 | 	if err != nil {
15 | 		log.Fatalf("%s: %s", msg, err)
16 | 	}
17 | }
18 | 
19 | func main() {
20 | 	mq, err := rabbitmq.New("amqp://guest:guest@localhost:5672/")
21 | 	failOnError(err, "Failed to create a MQ")
22 | 	defer mq.Close()
23 | 
24 | 	q, err := mq.Queue().
25 | 		WithName("hello").
26 | 		WithChannel(mq.Channel()).
27 | 		Declare()
28 | 	failOnError(err, "Failed to declare a queue")
29 | 
30 | 	log.Println(" [*] Waiting for messages. To exit press CTRL+C")
31 | 
32 | 	results, err := q.Consumer().Consume()
33 | 	failOnError(err, "Failed to register a consumer")
34 | 
35 | 	for result := range results {
36 | 		log.Println("result: ", string(result.Body))
37 | 		result.Ack(false)
38 | 	}
39 | 	forever := make(chan bool)
40 | 	<-forever
41 | }
42 | 


--------------------------------------------------------------------------------
/example/simple/publisher/publisher.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | // this is an example of publising message directly into queue
 4 | // steps to do here are same as https://www.rabbitmq.com/tutorials/tutorial-one-go.html
 5 | // but using the wrapper API
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"log"
10 | 	"sync"
11 | 
12 | 	rabbitmq "github.com/hadihammurabi/go-rabbitmq"
13 | 	"github.com/hadihammurabi/go-rabbitmq/exchange"
14 | 	"github.com/streadway/amqp"
15 | )
16 | 
17 | func failOnError(err error, msg string) {
18 | 	if err != nil {
19 | 		log.Fatalf("%s: %s", msg, err)
20 | 	}
21 | }
22 | 
23 | func main() {
24 | 	mq, err := rabbitmq.New("amqp://guest:guest@localhost:5672/")
25 | 	failOnError(err, "Failed to create a MQ")
26 | 	defer mq.Close()
27 | 
28 | 	err = mq.Exchange().
29 | 		WithName("hello").
30 | 		WithType(exchange.TypeDirect).
31 | 		Declare()
32 | 	failOnError(err, "Failed to create a channel")
33 | 
34 | 	q, err := mq.Queue().
35 | 		WithName("hello").
36 | 		Declare()
37 | 	failOnError(err, "Failed to create a queue")
38 | 
39 | 	err = q.Binding().
40 | 		WithExchange("hello").
41 | 		Bind()
42 | 	failOnError(err, "Failed to bind queue")
43 | 
44 | 	var wg sync.WaitGroup
45 | 	max := 10
46 | 	wg.Add(max)
47 | 	for i := 0; i < max; i++ {
48 | 		go func(a int) {
49 | 			defer wg.Done()
50 | 			body := fmt.Sprintf("Hello World %d !", a)
51 | 			err = mq.Publish(&rabbitmq.MQConfigPublish{
52 | 				RoutingKey: mq.Queue().Name,
53 | 				Message: amqp.Publishing{
54 | 					ContentType: "text/plain",
55 | 					Body:        []byte(body),
56 | 				},
57 | 			})
58 | 		}(i)
59 | 	}
60 | 	wg.Wait()
61 | }
62 | 


--------------------------------------------------------------------------------
/exchange/exchange.go:
--------------------------------------------------------------------------------
  1 | package exchange
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 
  6 | 	"github.com/streadway/amqp"
  7 | )
  8 | 
  9 | type Type string
 10 | 
 11 | const (
 12 | 	TypeDirect Type = "direct"
 13 | 	TypeTopic  Type = "topic"
 14 | 	TypeFanout Type = "fanout"
 15 | )
 16 | 
 17 | type Exchange struct {
 18 | 	Name        string
 19 | 	Type        Type
 20 | 	Durable     bool
 21 | 	AutoDeleted bool
 22 | 	Internal    bool
 23 | 	NoWait      bool
 24 | 	Args        amqp.Table
 25 | 	Channel     *amqp.Channel
 26 | }
 27 | 
 28 | func New(Channel *amqp.Channel) *Exchange {
 29 | 	return &Exchange{
 30 | 		Channel: Channel,
 31 | 	}
 32 | }
 33 | 
 34 | func (config *Exchange) From(exchange *Exchange) *Exchange {
 35 | 	config.Name = exchange.Name
 36 | 	config.Type = exchange.Type
 37 | 	config.Durable = exchange.Durable
 38 | 	config.AutoDeleted = exchange.AutoDeleted
 39 | 	config.Internal = exchange.Internal
 40 | 	config.NoWait = exchange.NoWait
 41 | 	config.Args = exchange.Args
 42 | 	config.Channel = exchange.Channel
 43 | 	return config
 44 | }
 45 | 
 46 | func (config *Exchange) WithChannel(Channel *amqp.Channel) *Exchange {
 47 | 	config.Channel = Channel
 48 | 	return config
 49 | }
 50 | 
 51 | func (config *Exchange) WithName(Name string) *Exchange {
 52 | 	config.Name = Name
 53 | 	return config
 54 | }
 55 | 
 56 | func (config *Exchange) WithType(Type Type) *Exchange {
 57 | 	config.Type = Type
 58 | 	return config
 59 | }
 60 | 
 61 | func (config *Exchange) WithDurable(Durable bool) *Exchange {
 62 | 	config.Durable = Durable
 63 | 	return config
 64 | }
 65 | 
 66 | func (config *Exchange) WithAutoDeleted(AutoDeleted bool) *Exchange {
 67 | 	config.AutoDeleted = AutoDeleted
 68 | 	return config
 69 | }
 70 | 
 71 | func (config *Exchange) WithInternal(Internal bool) *Exchange {
 72 | 	config.Internal = Internal
 73 | 	return config
 74 | }
 75 | 
 76 | func (config *Exchange) WithNoWait(NoWait bool) *Exchange {
 77 | 	config.NoWait = NoWait
 78 | 	return config
 79 | }
 80 | 
 81 | func (config *Exchange) WithArgs(Args amqp.Table) *Exchange {
 82 | 	config.Args = Args
 83 | 	return config
 84 | }
 85 | 
 86 | func (config *Exchange) Declare() error {
 87 | 	if config.Channel == nil {
 88 | 		return errors.New("channel is nil")
 89 | 	}
 90 | 
 91 | 	return config.Channel.ExchangeDeclare(
 92 | 		config.Name,
 93 | 		string(config.Type),
 94 | 		config.Durable,
 95 | 		config.AutoDeleted,
 96 | 		config.Internal,
 97 | 		config.NoWait,
 98 | 		config.Args,
 99 | 	)
100 | }
101 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/hadihammurabi/go-rabbitmq
2 | 
3 | go 1.16
4 | 
5 | require github.com/streadway/amqp v1.0.0
6 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/streadway/amqp v1.0.0 h1:kuuDrUJFZL1QYL9hUNuCxNObNzB0bV/ZG5jV3RWAQgo=
2 | github.com/streadway/amqp v1.0.0/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
3 | 


--------------------------------------------------------------------------------
/mq.go:
--------------------------------------------------------------------------------
 1 | package gorabbitmq
 2 | 
 3 | import (
 4 | 	"github.com/streadway/amqp"
 5 | 
 6 | 	"github.com/hadihammurabi/go-rabbitmq/connection"
 7 | 	"github.com/hadihammurabi/go-rabbitmq/exchange"
 8 | 	"github.com/hadihammurabi/go-rabbitmq/queue"
 9 | )
10 | 
11 | type MQ struct {
12 | 	connection *connection.Connection
13 | 	channel    *amqp.Channel
14 | 	queue      *queue.Queue
15 | 	exchange   *exchange.Exchange
16 | }
17 | 
18 | func New(url string) (*MQ, error) {
19 | 	conn, err := connection.New(url)
20 | 	if err != nil {
21 | 		return nil, err
22 | 	}
23 | 
24 | 	ch, err := conn.Channel()
25 | 	if err != nil {
26 | 		return nil, err
27 | 	}
28 | 
29 | 	return &MQ{
30 | 		connection: conn,
31 | 		channel:    ch,
32 | 		queue:      queue.New(ch),
33 | 		exchange:   exchange.New(ch),
34 | 	}, nil
35 | }
36 | 
37 | func NewFromConnection(conn *connection.Connection) (*MQ, error) {
38 | 	ch, err := conn.Channel()
39 | 	if err != nil {
40 | 		return nil, err
41 | 	}
42 | 
43 | 	return &MQ{
44 | 		connection: conn,
45 | 		channel:    ch,
46 | 	}, nil
47 | }
48 | 
49 | func (mq *MQ) Connection() *connection.Connection {
50 | 	return mq.connection
51 | }
52 | 
53 | func (mq *MQ) Channel() *amqp.Channel {
54 | 	return mq.channel
55 | }
56 | 
57 | func (mq *MQ) Queue() *queue.Queue {
58 | 	return mq.queue
59 | }
60 | 
61 | func (mq *MQ) Exchange() *exchange.Exchange {
62 | 	return mq.exchange
63 | }
64 | 
65 | func (mq *MQ) Publish(publish *MQConfigPublish) error {
66 | 	return mq.channel.Publish(
67 | 		publish.Exchange,
68 | 		publish.RoutingKey,
69 | 		publish.Mandatory,
70 | 		publish.Immediate,
71 | 		publish.Message,
72 | 	)
73 | }
74 | 
75 | func (mq *MQ) Close() {
76 | 	mq.channel.Close()
77 | 	mq.connection.Close()
78 | }
79 | 


--------------------------------------------------------------------------------
/publish.go:
--------------------------------------------------------------------------------
 1 | package gorabbitmq
 2 | 
 3 | import "github.com/streadway/amqp"
 4 | 
 5 | type MQConfigPublish struct {
 6 | 	Exchange   string
 7 | 	RoutingKey string
 8 | 	Mandatory  bool
 9 | 	Immediate  bool
10 | 	Message    amqp.Publishing
11 | }
12 | 
13 | func NewPublishOptions() *MQConfigPublish {
14 | 	return &MQConfigPublish{}
15 | }
16 | 
17 | func (config *MQConfigPublish) SetExchange(Exchange string) *MQConfigPublish {
18 | 	config.Exchange = Exchange
19 | 	return config
20 | }
21 | 
22 | func (config *MQConfigPublish) SetRoutingKey(RoutingKey string) *MQConfigPublish {
23 | 	config.RoutingKey = RoutingKey
24 | 	return config
25 | }
26 | 
27 | func (config *MQConfigPublish) SetMandatory(Mandatory bool) *MQConfigPublish {
28 | 	config.Mandatory = Mandatory
29 | 	return config
30 | }
31 | 
32 | func (config *MQConfigPublish) SetImmediate(Immediate bool) *MQConfigPublish {
33 | 	config.Immediate = Immediate
34 | 	return config
35 | }
36 | 
37 | func (config *MQConfigPublish) SetMessage(Message amqp.Publishing) *MQConfigPublish {
38 | 	config.Message = Message
39 | 	return config
40 | }
41 | 


--------------------------------------------------------------------------------
/queue/bind.go:
--------------------------------------------------------------------------------
 1 | package queue
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 
 6 | 	"github.com/streadway/amqp"
 7 | )
 8 | 
 9 | type BindOptions struct {
10 | 	Name       string
11 | 	RoutingKey string
12 | 	Exchange   string
13 | 	NoWait     bool
14 | 	Args       amqp.Table
15 | 	Channel    *amqp.Channel
16 | }
17 | 
18 | func NewBind() *BindOptions {
19 | 	return &BindOptions{}
20 | }
21 | 
22 | func (config *BindOptions) WithChannel(Channel *amqp.Channel) *BindOptions {
23 | 	config.Channel = Channel
24 | 	return config
25 | }
26 | 
27 | func (config *BindOptions) WithQueue(Queue *Queue) *BindOptions {
28 | 	config.Name = Queue.Name
29 | 	return config
30 | }
31 | 
32 | func (config *BindOptions) WithRoutingKey(RoutingKey string) *BindOptions {
33 | 	config.RoutingKey = RoutingKey
34 | 	return config
35 | }
36 | 
37 | func (config *BindOptions) WithExchange(Exchange string) *BindOptions {
38 | 	config.Exchange = Exchange
39 | 	return config
40 | }
41 | 
42 | func (config *BindOptions) WithNoWait(NoWait bool) *BindOptions {
43 | 	config.NoWait = NoWait
44 | 	return config
45 | }
46 | 
47 | func (config *BindOptions) WithArgs(Args amqp.Table) *BindOptions {
48 | 	config.Args = Args
49 | 	return config
50 | }
51 | 
52 | func (config *BindOptions) Bind() error {
53 | 	if config.Channel == nil {
54 | 		return errors.New("channel is nil")
55 | 	}
56 | 
57 | 	if config.Name == "" {
58 | 		return errors.New("queue name is empty")
59 | 	}
60 | 
61 | 	return config.Channel.QueueBind(
62 | 		config.Name,
63 | 		config.RoutingKey,
64 | 		config.Exchange,
65 | 		config.NoWait,
66 | 		config.Args,
67 | 	)
68 | }
69 | 


--------------------------------------------------------------------------------
/queue/consumer.go:
--------------------------------------------------------------------------------
 1 | package queue
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 
 6 | 	"github.com/streadway/amqp"
 7 | )
 8 | 
 9 | type Consumer struct {
10 | 	Queue     *Queue
11 | 	Consumer  string
12 | 	AutoACK   bool
13 | 	Exclusive bool
14 | 	NoLocal   bool
15 | 	NoWait    bool
16 | 	Args      amqp.Table
17 | }
18 | 
19 | func NewConsumer() *Consumer {
20 | 	return &Consumer{}
21 | }
22 | 
23 | func (c *Consumer) WithQueue(Queue *Queue) *Consumer {
24 | 	c.Queue = Queue
25 | 	return c
26 | }
27 | 
28 | func (c *Consumer) WithAutoACK(AutoACK bool) *Consumer {
29 | 	c.AutoACK = AutoACK
30 | 	return c
31 | }
32 | 
33 | func (c *Consumer) WithExclusive(Exclusive bool) *Consumer {
34 | 	c.Exclusive = Exclusive
35 | 	return c
36 | }
37 | 
38 | func (c *Consumer) WithNoLocal(NoLocal bool) *Consumer {
39 | 	c.NoLocal = NoLocal
40 | 	return c
41 | }
42 | 
43 | func (c *Consumer) WithNoWait(NoWait bool) *Consumer {
44 | 	c.NoWait = NoWait
45 | 	return c
46 | }
47 | 
48 | func (c *Consumer) WithArgs(Args amqp.Table) *Consumer {
49 | 	c.Args = Args
50 | 	return c
51 | }
52 | 
53 | func (c Consumer) Consume() (<-chan amqp.Delivery, error) {
54 | 	if c.Queue == nil {
55 | 		return nil, errors.New("queue is nil")
56 | 	}
57 | 
58 | 	if c.Queue.Channel == nil {
59 | 		return nil, errors.New("channel is nil")
60 | 	}
61 | 
62 | 	consumer, err := c.Queue.Channel.Consume(
63 | 		c.Queue.Name,
64 | 		c.Consumer,
65 | 		c.AutoACK,
66 | 		c.Exclusive,
67 | 		c.NoLocal,
68 | 		c.NoWait,
69 | 		c.Args,
70 | 	)
71 | 	if err != nil {
72 | 		return nil, err
73 | 	}
74 | 
75 | 	return consumer, nil
76 | }
77 | 


--------------------------------------------------------------------------------
/queue/queue.go:
--------------------------------------------------------------------------------
  1 | package queue
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 
  6 | 	"github.com/streadway/amqp"
  7 | )
  8 | 
  9 | type Queue struct {
 10 | 	queue amqp.Queue
 11 | 
 12 | 	Name             string `binding:"required"`
 13 | 	Durable          bool
 14 | 	DeleteWhenUnused bool
 15 | 	Exclusive        bool
 16 | 	NoWait           bool
 17 | 	Args             amqp.Table
 18 | 	Channel          *amqp.Channel
 19 | 
 20 | 	bindOptions *BindOptions
 21 | 	consumer    *Consumer
 22 | }
 23 | 
 24 | func New(Channel *amqp.Channel) *Queue {
 25 | 	return &Queue{
 26 | 		Durable:          false,
 27 | 		DeleteWhenUnused: false,
 28 | 		Exclusive:        false,
 29 | 		NoWait:           false,
 30 | 		Channel:          Channel,
 31 | 		bindOptions:      &BindOptions{},
 32 | 	}
 33 | }
 34 | 
 35 | func (config *Queue) From(queue *Queue) *Queue {
 36 | 	config.Name = queue.Name
 37 | 	config.Durable = queue.Durable
 38 | 	config.DeleteWhenUnused = queue.DeleteWhenUnused
 39 | 	config.Exclusive = queue.Exclusive
 40 | 	config.NoWait = queue.NoWait
 41 | 	config.Args = queue.Args
 42 | 	config.Channel = queue.Channel
 43 | 	config.bindOptions = queue.bindOptions
 44 | 	return config
 45 | }
 46 | 
 47 | func (config *Queue) WithChannel(Channel *amqp.Channel) *Queue {
 48 | 	config.Channel = Channel
 49 | 	return config
 50 | }
 51 | 
 52 | func (config *Queue) WithName(Name string) *Queue {
 53 | 	config.Name = Name
 54 | 	return config
 55 | }
 56 | 
 57 | func (config *Queue) WithDurable(Durable bool) *Queue {
 58 | 	config.Durable = Durable
 59 | 	return config
 60 | }
 61 | 
 62 | func (config *Queue) WithDeleteWhenUnused(DeleteWhenUnused bool) *Queue {
 63 | 	config.DeleteWhenUnused = DeleteWhenUnused
 64 | 	return config
 65 | }
 66 | 
 67 | func (config *Queue) WithExclusive(Exclusive bool) *Queue {
 68 | 	config.Exclusive = Exclusive
 69 | 	return config
 70 | }
 71 | 
 72 | func (config *Queue) WithNoWait(NoWait bool) *Queue {
 73 | 	config.NoWait = NoWait
 74 | 	return config
 75 | }
 76 | 
 77 | func (config *Queue) WithArgs(Args amqp.Table) *Queue {
 78 | 	config.Args = Args
 79 | 	return config
 80 | }
 81 | 
 82 | func (config *Queue) Raw() amqp.Queue {
 83 | 	return config.queue
 84 | }
 85 | 
 86 | func (config *Queue) Declare() (*Queue, error) {
 87 | 	if config.Channel == nil {
 88 | 		return nil, errors.New("channel is nil")
 89 | 	}
 90 | 
 91 | 	q, err := config.Channel.QueueDeclare(
 92 | 		config.Name,
 93 | 		config.Durable,
 94 | 		config.DeleteWhenUnused,
 95 | 		config.Exclusive,
 96 | 		config.NoWait,
 97 | 		config.Args,
 98 | 	)
 99 | 
100 | 	config.bindOptions = NewBind().
101 | 		WithChannel(config.Channel).
102 | 		WithQueue(config)
103 | 
104 | 	config.consumer = NewConsumer().
105 | 		WithQueue(config)
106 | 
107 | 	if err != nil {
108 | 		return nil, err
109 | 	}
110 | 
111 | 	config.queue = q
112 | 	return config, nil
113 | }
114 | 
115 | func (config *Queue) Binding() *BindOptions {
116 | 	return config.bindOptions
117 | }
118 | 
119 | func (config *Queue) Consumer() *Consumer {
120 | 	return config.consumer
121 | }
122 | 


--------------------------------------------------------------------------------
/rabbitmq.go:
--------------------------------------------------------------------------------
 1 | package gorabbitmq
 2 | 
 3 | import (
 4 | 	"github.com/hadihammurabi/go-rabbitmq/connection"
 5 | 	"github.com/hadihammurabi/go-rabbitmq/exchange"
 6 | 	"github.com/streadway/amqp"
 7 | )
 8 | 
 9 | const (
10 | 	ChannelDefault string = "default"
11 | )
12 | 
13 | type MQConfig struct {
14 | 	Connection *connection.Connection
15 | 	Exchange   *exchange.Exchange
16 | }
17 | 
18 | type MQConfigConsume struct {
19 | 	Name      string
20 | 	Consumer  string
21 | 	AutoACK   bool
22 | 	Exclusive bool
23 | 	NoLocal   bool
24 | 	NoWait    bool
25 | 	Args      amqp.Table
26 | }
27 | 


--------------------------------------------------------------------------------