├── .classpath ├── .gitignore ├── .project ├── .settings └── org.codehaus.groovy.eclipse.preferences.prefs ├── .travis.yml ├── LICENSE.txt ├── README.md ├── build.gradle ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── grails-app ├── conf │ ├── application.groovy │ ├── application.yml │ └── logback.groovy ├── controllers │ └── UrlMappings.groovy ├── init │ └── grails │ │ └── plugins │ │ └── rabbitmq │ │ └── Application.groovy └── views │ ├── error.gsp │ ├── index.gsp │ ├── layouts │ └── main.gsp │ └── notFound.gsp ├── src ├── docs │ ├── guide │ │ ├── configuration.gdoc │ │ ├── configuration │ │ │ ├── advancedConfig.gdoc │ │ │ ├── configuringExchanges.gdoc │ │ │ └── configuringQueues.gdoc │ │ ├── consumingMessages.gdoc │ │ ├── consumingMessages │ │ │ ├── manualQueueManagement.gdoc │ │ │ ├── messages.gdoc │ │ │ └── pubSub.gdoc │ │ ├── introduction.gdoc │ │ ├── introduction │ │ │ └── changeLog.gdoc │ │ ├── links.yml │ │ ├── rabbitTemplate.gdoc │ │ ├── rewriteRules.txt │ │ ├── sendingMessages.gdoc │ │ └── toc.yml │ └── ref │ │ └── All Classes │ │ └── rabbitSend.gdoc ├── main │ └── groovy │ │ └── grails.plugins.rabbitmq │ │ ├── AutoQueueMessageListenerContainer.groovy │ │ ├── RabbitConfigurationHolder.groovy │ │ ├── RabbitDynamicMethods.groovy │ │ ├── RabbitErrorHandler.groovy │ │ ├── RabbitQueueBuilder.groovy │ │ ├── RabbitServiceConfigurer.groovy │ │ └── RabbitmqGrailsPlugin.groovy └── test │ └── groovy │ └── grails │ └── plugins │ └── rabbitmq │ ├── AutoQueueMessageListenerContainerSpec.groovy │ ├── RabbitConfigurationHolderSpec.groovy │ ├── RabbitDynamicMethodsSpec.groovy │ ├── RabbitGrailsPluginSpec.groovy │ └── RabbitQueueBuilderSpec.groovy └── travis-build.sh /.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # JetBrains IntelliJ IDEA files 2 | .idea/ 3 | *.iml 4 | *.iws 5 | .gradle 6 | build/ 7 | 8 | # Log files 9 | *.log 10 | 11 | # Libraries and others 12 | *.zip 13 | 14 | # Target 15 | target/ 16 | target-eclipse/ 17 | 18 | .DS_Store 19 | 20 | docs/ 21 | plugin.xml 22 | .settings 23 | 24 | # Unused grails files 25 | .classpath 26 | .project 27 | test/reports 28 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | rabbitmq 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.wst.common.project.facet.core.builder 10 | 11 | 12 | 13 | 14 | org.eclipse.jdt.core.javabuilder 15 | 16 | 17 | 18 | 19 | 20 | com.springsource.sts.grails.core.nature 21 | org.eclipse.jdt.groovy.core.groovyNature 22 | org.eclipse.jdt.core.javanature 23 | org.eclipse.wst.common.project.facet.core.nature 24 | 25 | 26 | 27 | tomcat-1.3.4-src-groovy 28 | 2 29 | /Users/pledbrook/dev/projects/git/grails-plugins/grails-rabbitmq/target/plugins/tomcat-1.3.4/src/groovy 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /.settings/org.codehaus.groovy.eclipse.preferences.prefs: -------------------------------------------------------------------------------- 1 | #Created by grails 2 | eclipse.preferences.version=1 3 | groovy.dont.generate.class.files=true 4 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: groovy 2 | 3 | jdk: 4 | - oraclejdk7 5 | 6 | before_install: 7 | - rm -rf ~/.gvm 8 | - curl -s get.gvmtool.net > ~/install_gvm.sh 9 | - chmod 775 ~/install_gvm.sh 10 | - ~/install_gvm.sh 11 | - echo "gvm_auto_answer=true" > ~/.gvm/etc/config 12 | - source ~/.gvm/bin/gvm-init.sh 13 | - gvm install grails $GRAILS_VERSION || true 14 | - chmod 775 ./travis-build.sh 15 | 16 | branches: 17 | only: 18 | - master 19 | 20 | before_script: 21 | - rm -rf target 22 | 23 | script: ./travis-build.sh 24 | 25 | env: 26 | matrix: 27 | - GRAILS_VERSION=3.0.2 28 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | /* 2 | * Apache License 3 | * Version 2.0, January 2004 4 | * http://www.apache.org/licenses/ 5 | * 6 | * TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 7 | * 8 | * 1. Definitions. 9 | * 10 | * "License" shall mean the terms and conditions for use, reproduction, 11 | * and distribution as defined by Sections 1 through 9 of this document. 12 | * 13 | * "Licensor" shall mean the copyright owner or entity authorized by 14 | * the copyright owner that is granting the License. 15 | * 16 | * "Legal Entity" shall mean the union of the acting entity and all 17 | * other entities that control, are controlled by, or are under common 18 | * control with that entity. For the purposes of this definition, 19 | * "control" means (i) the power, direct or indirect, to cause the 20 | * direction or management of such entity, whether by contract or 21 | * otherwise, or (ii) ownership of fifty percent (50%) or more of the 22 | * outstanding shares, or (iii) beneficial ownership of such entity. 23 | * 24 | * "You" (or "Your") shall mean an individual or Legal Entity 25 | * exercising permissions granted by this License. 26 | * 27 | * "Source" form shall mean the preferred form for making modifications, 28 | * including but not limited to software source code, documentation 29 | * source, and configuration files. 30 | * 31 | * "Object" form shall mean any form resulting from mechanical 32 | * transformation or translation of a Source form, including but 33 | * not limited to compiled object code, generated documentation, 34 | * and conversions to other media types. 35 | * 36 | * "Work" shall mean the work of authorship, whether in Source or 37 | * Object form, made available under the License, as indicated by a 38 | * copyright notice that is included in or attached to the work 39 | * (an example is provided in the Appendix below). 40 | * 41 | * "Derivative Works" shall mean any work, whether in Source or Object 42 | * form, that is based on (or derived from) the Work and for which the 43 | * editorial revisions, annotations, elaborations, or other modifications 44 | * represent, as a whole, an original work of authorship. For the purposes 45 | * of this License, Derivative Works shall not include works that remain 46 | * separable from, or merely link (or bind by name) to the interfaces of, 47 | * the Work and Derivative Works thereof. 48 | * 49 | * "Contribution" shall mean any work of authorship, including 50 | * the original version of the Work and any modifications or additions 51 | * to that Work or Derivative Works thereof, that is intentionally 52 | * submitted to Licensor for inclusion in the Work by the copyright owner 53 | * or by an individual or Legal Entity authorized to submit on behalf of 54 | * the copyright owner. For the purposes of this definition, "submitted" 55 | * means any form of electronic, verbal, or written communication sent 56 | * to the Licensor or its representatives, including but not limited to 57 | * communication on electronic mailing lists, source code control systems, 58 | * and issue tracking systems that are managed by, or on behalf of, the 59 | * Licensor for the purpose of discussing and improving the Work, but 60 | * excluding communication that is conspicuously marked or otherwise 61 | * designated in writing by the copyright owner as "Not a Contribution." 62 | * 63 | * "Contributor" shall mean Licensor and any individual or Legal Entity 64 | * on behalf of whom a Contribution has been received by Licensor and 65 | * subsequently incorporated within the Work. 66 | * 67 | * 2. Grant of Copyright License. Subject to the terms and conditions of 68 | * this License, each Contributor hereby grants to You a perpetual, 69 | * worldwide, non-exclusive, no-charge, royalty-free, irrevocable 70 | * copyright license to reproduce, prepare Derivative Works of, 71 | * publicly display, publicly perform, sublicense, and distribute the 72 | * Work and such Derivative Works in Source or Object form. 73 | * 74 | * 3. Grant of Patent License. Subject to the terms and conditions of 75 | * this License, each Contributor hereby grants to You a perpetual, 76 | * worldwide, non-exclusive, no-charge, royalty-free, irrevocable 77 | * (except as stated in this section) patent license to make, have made, 78 | * use, offer to sell, sell, import, and otherwise transfer the Work, 79 | * where such license applies only to those patent claims licensable 80 | * by such Contributor that are necessarily infringed by their 81 | * Contribution(s) alone or by combination of their Contribution(s) 82 | * with the Work to which such Contribution(s) was submitted. If You 83 | * institute patent litigation against any entity (including a 84 | * cross-claim or counterclaim in a lawsuit) alleging that the Work 85 | * or a Contribution incorporated within the Work constitutes direct 86 | * or contributory patent infringement, then any patent licenses 87 | * granted to You under this License for that Work shall terminate 88 | * as of the date such litigation is filed. 89 | * 90 | * 4. Redistribution. You may reproduce and distribute copies of the 91 | * Work or Derivative Works thereof in any medium, with or without 92 | * modifications, and in Source or Object form, provided that You 93 | * meet the following conditions: 94 | * 95 | * (a) You must give any other recipients of the Work or 96 | * Derivative Works a copy of this License; and 97 | * 98 | * (b) You must cause any modified files to carry prominent notices 99 | * stating that You changed the files; and 100 | * 101 | * (c) You must retain, in the Source form of any Derivative Works 102 | * that You distribute, all copyright, patent, trademark, and 103 | * attribution notices from the Source form of the Work, 104 | * excluding those notices that do not pertain to any part of 105 | * the Derivative Works; and 106 | * 107 | * (d) If the Work includes a "NOTICE" text file as part of its 108 | * distribution, then any Derivative Works that You distribute must 109 | * include a readable copy of the attribution notices contained 110 | * within such NOTICE file, excluding those notices that do not 111 | * pertain to any part of the Derivative Works, in at least one 112 | * of the following places: within a NOTICE text file distributed 113 | * as part of the Derivative Works; within the Source form or 114 | * documentation, if provided along with the Derivative Works; or, 115 | * within a display generated by the Derivative Works, if and 116 | * wherever such third-party notices normally appear. The contents 117 | * of the NOTICE file are for informational purposes only and 118 | * do not modify the License. You may add Your own attribution 119 | * notices within Derivative Works that You distribute, alongside 120 | * or as an addendum to the NOTICE text from the Work, provided 121 | * that such additional attribution notices cannot be construed 122 | * as modifying the License. 123 | * 124 | * You may add Your own copyright statement to Your modifications and 125 | * may provide additional or different license terms and conditions 126 | * for use, reproduction, or distribution of Your modifications, or 127 | * for any such Derivative Works as a whole, provided Your use, 128 | * reproduction, and distribution of the Work otherwise complies with 129 | * the conditions stated in this License. 130 | * 131 | * 5. Submission of Contributions. Unless You explicitly state otherwise, 132 | * any Contribution intentionally submitted for inclusion in the Work 133 | * by You to the Licensor shall be under the terms and conditions of 134 | * this License, without any additional terms or conditions. 135 | * Notwithstanding the above, nothing herein shall supersede or modify 136 | * the terms of any separate license agreement you may have executed 137 | * with Licensor regarding such Contributions. 138 | * 139 | * 6. Trademarks. This License does not grant permission to use the trade 140 | * names, trademarks, service marks, or product names of the Licensor, 141 | * except as required for reasonable and customary use in describing the 142 | * origin of the Work and reproducing the content of the NOTICE file. 143 | * 144 | * 7. Disclaimer of Warranty. Unless required by applicable law or 145 | * agreed to in writing, Licensor provides the Work (and each 146 | * Contributor provides its Contributions) on an "AS IS" BASIS, 147 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 148 | * implied, including, without limitation, any warranties or conditions 149 | * of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 150 | * PARTICULAR PURPOSE. You are solely responsible for determining the 151 | * appropriateness of using or redistributing the Work and assume any 152 | * risks associated with Your exercise of permissions under this License. 153 | * 154 | * 8. Limitation of Liability. In no event and under no legal theory, 155 | * whether in tort (including negligence), contract, or otherwise, 156 | * unless required by applicable law (such as deliberate and grossly 157 | * negligent acts) or agreed to in writing, shall any Contributor be 158 | * liable to You for damages, including any direct, indirect, special, 159 | * incidental, or consequential damages of any character arising as a 160 | * result of this License or out of the use or inability to use the 161 | * Work (including but not limited to damages for loss of goodwill, 162 | * work stoppage, computer failure or malfunction, or any and all 163 | * other commercial damages or losses), even if such Contributor 164 | * has been advised of the possibility of such damages. 165 | * 166 | * 9. Accepting Warranty or Additional Liability. While redistributing 167 | * the Work or Derivative Works thereof, You may choose to offer, 168 | * and charge a fee for, acceptance of support, warranty, indemnity, 169 | * or other liability obligations and/or rights consistent with this 170 | * License. However, in accepting such obligations, You may act only 171 | * on Your own behalf and on Your sole responsibility, not on behalf 172 | * of any other Contributor, and only if You agree to indemnify, 173 | * defend, and hold each Contributor harmless for any liability 174 | * incurred by, or claims asserted against, such Contributor by reason 175 | * of your accepting any such warranty or additional liability. 176 | * 177 | * END OF TERMS AND CONDITIONS 178 | * 179 | * APPENDIX: How to apply the Apache License to your work. 180 | * 181 | * To apply the Apache License to your work, attach the following 182 | * boilerplate notice, with the fields enclosed by brackets "[]" 183 | * replaced with your own identifying information. (Don't include 184 | * the brackets!) The text should be enclosed in the appropriate 185 | * comment syntax for the file format. We also recommend that a 186 | * file or class name and description of purpose be included on the 187 | * same "printed page" as the copyright notice for easier 188 | * identification within third-party archives. 189 | * 190 | * Copyright [yyyy] [name of copyright owner] 191 | * 192 | * Licensed under the Apache License, Version 2.0 (the "License"); 193 | * you may not use this file except in compliance with the License. 194 | * You may obtain a copy of the License at 195 | * 196 | * http://www.apache.org/licenses/LICENSE-2.0 197 | * 198 | * Unless required by applicable law or agreed to in writing, software 199 | * distributed under the License is distributed on an "AS IS" BASIS, 200 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 201 | * See the License for the specific language governing permissions and 202 | * limitations under the License. 203 | */ 204 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | [![Build Status](https://travis-ci.org/grails-plugins/grails-rabbitmq.svg?branch=master)](http://travis-ci.org/grails-plugins/grails-rabbitmq) 3 | 4 | 5 | grails-rabbitmq 6 | =============== 7 | 8 | Grails RabbitMQ Plugin 9 | 10 | [Sample Applicatoin](https://github.com/puneetbehl/rabbitmqDemo.git) 11 | -------------------------------------------------------------------------------- /build.gradle: -------------------------------------------------------------------------------- 1 | buildscript { 2 | ext { 3 | grailsVersion = project.grailsVersion 4 | } 5 | repositories { 6 | mavenLocal() 7 | maven { url "https://repo.grails.org/grails/core" } 8 | } 9 | dependencies { 10 | classpath "org.grails:grails-gradle-plugin:$grailsVersion" 11 | } 12 | } 13 | 14 | plugins { 15 | id "io.spring.dependency-management" version "0.5.1.RELEASE" 16 | id "com.jfrog.bintray" version "1.1" 17 | } 18 | 19 | version "2.0.0-SNAPSHOT" 20 | group "org.grails.plugins" 21 | 22 | apply plugin: 'maven-publish' 23 | apply plugin: 'eclipse' 24 | apply plugin: 'idea' 25 | apply plugin: "spring-boot" 26 | apply plugin: "org.grails.grails-plugin" 27 | apply plugin: "org.grails.grails-gsp" 28 | // Used for publishing to central repository, remove if not needed 29 | apply from:'https://raw.githubusercontent.com/grails/grails-profile-repository/master/profiles/plugin/templates/grailsCentralPublishing.gradle' 30 | apply from:'https://raw.githubusercontent.com/grails/grails-profile-repository/master/profiles/plugin/templates/bintrayPublishing.gradle' 31 | 32 | ext { 33 | grailsVersion = project.grailsVersion 34 | gradleWrapperVersion = project.gradleWrapperVersion 35 | } 36 | 37 | sourceCompatibility = 1.7 38 | targetCompatibility = 1.7 39 | 40 | 41 | repositories { 42 | mavenLocal() 43 | mavenCentral() 44 | maven { url "https://repo.grails.org/grails/core" } 45 | } 46 | 47 | dependencyManagement { 48 | imports { 49 | mavenBom "org.grails:grails-bom:$grailsVersion" 50 | } 51 | applyMavenExclusions false 52 | } 53 | 54 | dependencies { 55 | provided 'org.springframework.boot:spring-boot-starter-logging' 56 | provided "org.springframework.boot:spring-boot-starter-actuator" 57 | provided "org.springframework.boot:spring-boot-autoconfigure" 58 | provided "org.springframework.boot:spring-boot-starter-tomcat" 59 | 60 | provided "org.grails:grails-web-boot" 61 | provided "org.grails:grails-dependencies" 62 | provided 'javax.servlet:javax.servlet-api:3.1.0' 63 | 64 | testCompile "org.grails:grails-plugin-testing" 65 | 66 | compile("org.springframework.amqp:spring-rabbit:1.4.5.RELEASE") { 67 | exclude module: 'junit' 68 | exclude module: 'sprint-aop' 69 | exclude module: 'spring-core' 70 | exclude module: 'spring-oxm' 71 | exclude module: 'spring-test' 72 | exclude module: 'spring-tx' 73 | exclude module: 'slf4j-log4j12' 74 | exclude module: 'log4j' 75 | } 76 | runtime 'org.springframework.retry:spring-retry:1.1.2.RELEASE' 77 | 78 | console "org.grails:grails-console" 79 | } 80 | 81 | task wrapper(type: Wrapper) { 82 | gradleVersion = gradleWrapperVersion 83 | } 84 | -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | grailsVersion=3.0.2 2 | gradleWrapperVersion=2.3 3 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grails-plugins/grails-rabbitmq/281ef68ce2d008ee35af9c8a31134e329998331d/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Wed Feb 04 17:05:29 CST 2015 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-bin.zip 7 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | ############################################################################## 4 | ## 5 | ## Gradle start up script for UN*X 6 | ## 7 | ############################################################################## 8 | 9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 10 | DEFAULT_JVM_OPTS="" 11 | 12 | APP_NAME="Gradle" 13 | APP_BASE_NAME=`basename "$0"` 14 | 15 | # Use the maximum available, or set MAX_FD != -1 to use that value. 16 | MAX_FD="maximum" 17 | 18 | warn ( ) { 19 | echo "$*" 20 | } 21 | 22 | die ( ) { 23 | echo 24 | echo "$*" 25 | echo 26 | exit 1 27 | } 28 | 29 | # OS specific support (must be 'true' or 'false'). 30 | cygwin=false 31 | msys=false 32 | darwin=false 33 | case "`uname`" in 34 | CYGWIN* ) 35 | cygwin=true 36 | ;; 37 | Darwin* ) 38 | darwin=true 39 | ;; 40 | MINGW* ) 41 | msys=true 42 | ;; 43 | esac 44 | 45 | # For Cygwin, ensure paths are in UNIX format before anything is touched. 46 | if $cygwin ; then 47 | [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` 48 | fi 49 | 50 | # Attempt to set APP_HOME 51 | # Resolve links: $0 may be a link 52 | PRG="$0" 53 | # Need this for relative symlinks. 54 | while [ -h "$PRG" ] ; do 55 | ls=`ls -ld "$PRG"` 56 | link=`expr "$ls" : '.*-> $.*$$'` 57 | if expr "$link" : '/.*' > /dev/null; then 58 | PRG="$link" 59 | else 60 | PRG=`dirname "$PRG"`"/$link" 61 | fi 62 | done 63 | SAVED="`pwd`" 64 | cd "`dirname \"$PRG\"`/" >&- 65 | APP_HOME="`pwd -P`" 66 | cd "$SAVED" >&- 67 | 68 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 69 | 70 | # Determine the Java command to use to start the JVM. 71 | if [ -n "$JAVA_HOME" ] ; then 72 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 73 | # IBM's JDK on AIX uses strange locations for the executables 74 | JAVACMD="$JAVA_HOME/jre/sh/java" 75 | else 76 | JAVACMD="$JAVA_HOME/bin/java" 77 | fi 78 | if [ ! -x "$JAVACMD" ] ; then 79 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 80 | 81 | Please set the JAVA_HOME variable in your environment to match the 82 | location of your Java installation." 83 | fi 84 | else 85 | JAVACMD="java" 86 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 87 | 88 | Please set the JAVA_HOME variable in your environment to match the 89 | location of your Java installation." 90 | fi 91 | 92 | # Increase the maximum file descriptors if we can. 93 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then 94 | MAX_FD_LIMIT=`ulimit -H -n` 95 | if [ $? -eq 0 ] ; then 96 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 97 | MAX_FD="$MAX_FD_LIMIT" 98 | fi 99 | ulimit -n $MAX_FD 100 | if [ $? -ne 0 ] ; then 101 | warn "Could not set maximum file descriptor limit: $MAX_FD" 102 | fi 103 | else 104 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 105 | fi 106 | fi 107 | 108 | # For Darwin, add options to specify how the application appears in the dock 109 | if $darwin; then 110 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 111 | fi 112 | 113 | # For Cygwin, switch paths to Windows format before running java 114 | if $cygwin ; then 115 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 116 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 117 | 118 | # We build the pattern for arguments to be converted via cygpath 119 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 120 | SEP="" 121 | for dir in $ROOTDIRSRAW ; do 122 | ROOTDIRS="$ROOTDIRS$SEP$dir" 123 | SEP="|" 124 | done 125 | OURCYGPATTERN="(^($ROOTDIRS))" 126 | # Add a user-defined pattern to the cygpath arguments 127 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 128 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 129 | fi 130 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 131 | i=0 132 | for arg in "$@" ; do 133 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 134 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 135 | 136 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 137 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 138 | else 139 | eval `echo args$i`="\"$arg\"" 140 | fi 141 | i=$((i+1)) 142 | done 143 | case $i in 144 | (0) set -- ;; 145 | (1) set -- "$args0" ;; 146 | (2) set -- "$args0" "$args1" ;; 147 | (3) set -- "$args0" "$args1" "$args2" ;; 148 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;; 149 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 150 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 151 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 152 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 153 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 154 | esac 155 | fi 156 | 157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules 158 | function splitJvmOpts() { 159 | JVM_OPTS=("$@") 160 | } 161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS 162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" 163 | 164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" 165 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @if "%DEBUG%" == "" @echo off 2 | @rem ########################################################################## 3 | @rem 4 | @rem Gradle startup script for Windows 5 | @rem 6 | @rem ########################################################################## 7 | 8 | @rem Set local scope for the variables with windows NT shell 9 | if "%OS%"=="Windows_NT" setlocal 10 | 11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 12 | set DEFAULT_JVM_OPTS= 13 | 14 | set DIRNAME=%~dp0 15 | if "%DIRNAME%" == "" set DIRNAME=. 16 | set APP_BASE_NAME=%~n0 17 | set APP_HOME=%DIRNAME% 18 | 19 | @rem Find java.exe 20 | if defined JAVA_HOME goto findJavaFromJavaHome 21 | 22 | set JAVA_EXE=java.exe 23 | %JAVA_EXE% -version >NUL 2>&1 24 | if "%ERRORLEVEL%" == "0" goto init 25 | 26 | echo. 27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 28 | echo. 29 | echo Please set the JAVA_HOME variable in your environment to match the 30 | echo location of your Java installation. 31 | 32 | goto fail 33 | 34 | :findJavaFromJavaHome 35 | set JAVA_HOME=%JAVA_HOME:"=% 36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 37 | 38 | if exist "%JAVA_EXE%" goto init 39 | 40 | echo. 41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 42 | echo. 43 | echo Please set the JAVA_HOME variable in your environment to match the 44 | echo location of your Java installation. 45 | 46 | goto fail 47 | 48 | :init 49 | @rem Get command-line arguments, handling Windowz variants 50 | 51 | if not "%OS%" == "Windows_NT" goto win9xME_args 52 | if "%@eval[2+2]" == "4" goto 4NT_args 53 | 54 | :win9xME_args 55 | @rem Slurp the command line arguments. 56 | set CMD_LINE_ARGS= 57 | set _SKIP=2 58 | 59 | :win9xME_args_slurp 60 | if "x%~1" == "x" goto execute 61 | 62 | set CMD_LINE_ARGS=%* 63 | goto execute 64 | 65 | :4NT_args 66 | @rem Get arguments from the 4NT Shell from JP Software 67 | set CMD_LINE_ARGS=%$ 68 | 69 | :execute 70 | @rem Setup the command line 71 | 72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 73 | 74 | @rem Execute Gradle 75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% 76 | 77 | :end 78 | @rem End local scope for the variables with windows NT shell 79 | if "%ERRORLEVEL%"=="0" goto mainEnd 80 | 81 | :fail 82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 83 | rem the _cmd.exe /c_ return code! 84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 85 | exit /b 1 86 | 87 | :mainEnd 88 | if "%OS%"=="Windows_NT" endlocal 89 | 90 | :omega 91 | -------------------------------------------------------------------------------- /grails-app/conf/application.groovy: -------------------------------------------------------------------------------- 1 | grails.doc.authors = 'Jeff Brown, Peter Ledbrook' 2 | grails.doc.license = 'Apache License 2.0' 3 | grails.doc.title = 'RabbitMQ Plugin' 4 | grails.doc.'api.org.springframework.amqp'='http://static.springsource.org/spring-amqp/docs/1.0.x/apidocs' -------------------------------------------------------------------------------- /grails-app/conf/application.yml: -------------------------------------------------------------------------------- 1 | --- 2 | grails: 3 | profile: web-plugin 4 | codegen: 5 | defaultPackage: grails.plugins.rabbitmq 6 | info: 7 | app: 8 | name: '@info.app.name@' 9 | version: '@info.app.version@' 10 | grailsVersion: '@info.app.grailsVersion@' 11 | spring: 12 | groovy: 13 | template: 14 | check-template-location: false 15 | 16 | --- 17 | grails: 18 | mime: 19 | disable: 20 | accept: 21 | header: 22 | userAgents: 23 | - Gecko 24 | - WebKit 25 | - Presto 26 | - Trident 27 | types: 28 | all: '*/*' 29 | atom: application/atom+xml 30 | css: text/css 31 | csv: text/csv 32 | form: application/x-www-form-urlencoded 33 | html: 34 | - text/html 35 | - application/xhtml+xml 36 | js: text/javascript 37 | json: 38 | - application/json 39 | - text/json 40 | multipartForm: multipart/form-data 41 | rss: application/rss+xml 42 | text: text/plain 43 | hal: 44 | - application/hal+json 45 | - application/hal+xml 46 | xml: 47 | - text/xml 48 | - application/xml 49 | urlmapping: 50 | cache: 51 | maxsize: 1000 52 | controllers: 53 | defaultScope: singleton 54 | converters: 55 | encoding: UTF-8 56 | views: 57 | default: 58 | codec: html 59 | gsp: 60 | encoding: UTF-8 61 | htmlcodec: xml 62 | codecs: 63 | expression: html 64 | scriptlets: html 65 | taglib: none 66 | staticparts: none 67 | hibernate: 68 | cache: 69 | queries: false 70 | --- 71 | dataSource: 72 | pooled: true 73 | jmxExport: true 74 | driverClassName: org.h2.Driver 75 | username: sa 76 | password: 77 | 78 | environments: 79 | development: 80 | dataSource: 81 | dbCreate: create-drop 82 | url: jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE 83 | test: 84 | dataSource: 85 | dbCreate: update 86 | url: jdbc:h2:mem:testDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE 87 | production: 88 | dataSource: 89 | dbCreate: update 90 | url: jdbc:h2:prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE 91 | properties: 92 | jmxEnabled: true 93 | initialSize: 5 94 | maxActive: 50 95 | minIdle: 5 96 | maxIdle: 25 97 | maxWait: 10000 98 | maxAge: 600000 99 | timeBetweenEvictionRunsMillis: 5000 100 | minEvictableIdleTimeMillis: 60000 101 | validationQuery: SELECT 1 102 | validationQueryTimeout: 3 103 | validationInterval: 15000 104 | testOnBorrow: true 105 | testWhileIdle: true 106 | testOnReturn: false 107 | jdbcInterceptors: ConnectionState 108 | defaultTransactionIsolation: 2 # TRANSACTION_READ_COMMITTED 109 | -------------------------------------------------------------------------------- /grails-app/conf/logback.groovy: -------------------------------------------------------------------------------- 1 | import grails.util.BuildSettings 2 | import grails.util.Environment 3 | 4 | 5 | // See http://logback.qos.ch/manual/groovy.html for details on configuration 6 | appender('STDOUT', ConsoleAppender) { 7 | encoder(PatternLayoutEncoder) { 8 | pattern = "%level %logger - %msg%n" 9 | } 10 | } 11 | 12 | root(ERROR, ['STDOUT']) 13 | 14 | if(Environment.current == Environment.DEVELOPMENT) { 15 | def targetDir = BuildSettings.TARGET_DIR 16 | if(targetDir) { 17 | 18 | appender("FULL_STACKTRACE", FileAppender) { 19 | 20 | file = "${targetDir}/stacktrace.log" 21 | append = true 22 | encoder(PatternLayoutEncoder) { 23 | pattern = "%level %logger - %msg%n" 24 | } 25 | } 26 | logger("StackTrace", ERROR, ['FULL_STACKTRACE'], false ) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /grails-app/controllers/UrlMappings.groovy: -------------------------------------------------------------------------------- 1 | class UrlMappings { 2 | static mappings = { 3 | "/$controller/$action?/$id?"{ 4 | constraints { 5 | // apply constraints here 6 | } 7 | } 8 | "/"(view:"/index") 9 | "500"(view:'/error') 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /grails-app/init/grails/plugins/rabbitmq/Application.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import grails.boot.GrailsApp 4 | import grails.boot.config.GrailsAutoConfiguration 5 | 6 | class Application extends GrailsAutoConfiguration { 7 | static void main(String[] args) { 8 | GrailsApp.run(Application, args) 9 | } 10 | } -------------------------------------------------------------------------------- /grails-app/views/error.gsp: -------------------------------------------------------------------------------- 1 | 2 | 3 | Grails Runtime Exception 4 | 24 | 25 | 26 | 27 |

Grails Runtime Exception

28 |

Error Details

29 | 30 |

31 | Error ${request.'javax.servlet.error.status_code'}: ${request.'javax.servlet.error.message'.encodeAsHTML()}
32 | Servlet: ${request.'javax.servlet.error.servlet_name'}
33 | URI: ${request.'javax.servlet.error.request_uri'}
34 | 35 | Exception Message: ${exception.message?.encodeAsHTML()}
36 | Caused by: ${exception.cause?.message?.encodeAsHTML()}
37 | Class: ${exception.className}
38 | At Line: [${exception.lineNumber}]
39 | Code Snippet:
40 |

41 | 42 | ${cs?.encodeAsHTML()}
43 | 44 |

45 | 46 |

47 | 48 |

Stack Trace

49 |

50 |

${it.encodeAsHTML()}

51 |

52 | 53 | 54 | -------------------------------------------------------------------------------- /grails-app/views/index.gsp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Welcome to Grails 6 | 78 | 79 | 80 | 81 | 106 |

107 |

Welcome to Grails

108 |

Congratulations, you have successfully started your first Grails application! At the moment 109 | this is the default page, feel free to modify it to either redirect to a controller or display whatever 110 | content you may choose. Below is a list of controllers that are currently deployed in this application, 111 | click on each to execute its default action:

112 | 113 | 121 |

122 | 123 | 124 | -------------------------------------------------------------------------------- /grails-app/views/layouts/main.gsp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | <g:layoutTitle default="Grails"/> 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /grails-app/views/notFound.gsp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Page Not Found 5 | 6 | 7 | 8 | 9 |

Error: Page Not Found (404)
Path: ${request.forwardURI}

13 | 14 | 15 | -------------------------------------------------------------------------------- /src/docs/guide/configuration.gdoc: -------------------------------------------------------------------------------- 1 | The plugin supports a number of configuration options which all may be expressed in @grails-app/conf/Config.groovy@. A basic configuration might look something like this: 2 | 3 | {code} 4 | // grails-app/conf/Config.groovy 5 | rabbitmq { 6 | connectionfactory { 7 | username = 'guest' 8 | password = 'guest' 9 | hostname = 'localhost' 10 | } 11 | } 12 | {code} 13 | 14 | Those are settings which are necessary in order for the plugin to be able to connect to and communicate with a RabbitMQ server. 15 | 16 | Following is a list of other configuration settings supported by the plugin. 17 | 18 | {table} 19 | *Configuration Property* | *Description* | *Default* 20 | rabbitmq.connectionfactory.username | The user name for connection to the server | (none) 21 | rabbitmq.connectionfactory.password | The password for connection to the server | (none) 22 | rabbitmq.connectionfactory.hostname | The host name of the server | (none) 23 | rabbitmq.connectionfactory.virtualHost | The name of the virtual host to connect to | '/' 24 | rabbitmq.connectionfactory.channelCacheSize | The connection channel cache size | 10 25 | rabbitmq.concurrentConsumers | The number of concurrent consumers to create per message handler. Raising the number is recommended in order to scale the consumption of messages coming in from a queue. Note that ordering guarantees are lost when multiple consumers are registered. | 1 26 | rabbitmq.disableListening | Disables all service listeners so that they won't receive any messages. | false 27 | rabbitmq.retryPolicy.maxAttempts | Sets the maximum number of retries for failed message deliveries | 0 28 | {table} 29 | -------------------------------------------------------------------------------- /src/docs/guide/configuration/advancedConfig.gdoc: -------------------------------------------------------------------------------- 1 | When you need fine-grained control over your service listeners, you can tap into the power of Spring. Since each service listener is implemented as a set of Spring beans, you can use Grails' [bean property override|http://grails.org/doc/latest/guide/spring.html#propertyOverrideConfiguration] mechanism to provide your own low-level settings. 2 | 3 | So how are these beans set up? If a service has either a @rabbitQueue@ or @rabbitSubscribe@ property, then you will have these beans: 4 | 5 | * @_MessageListenerContainer@ of type [SimpleMessageListenerContainer|api:org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer] 6 | * @RabbitAdapter@ of type [MessageListenerAdapter|api:org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter] 7 | 8 | As an example, let's say you have a @MessageStoreService@ like so: 9 | 10 | {code} 11 | class MessageStoreService { 12 | static rabbitSubscribe = [exchange: "amq.topic", routingKey: "logs.#"] 13 | ... 14 | } 15 | {code} 16 | 17 | You can then customise things like the number of concurrent consumers, whether the channel is transacted, what the prefetch count should be, and more! Simply add code like this to your runtime configuration (Config.groovy): 18 | 19 | {code} 20 | beans { 21 | messageStoreService_MessageListenerContainer { 22 | channelTransacted = false 23 | concurrentConsumers = 10 24 | prefetchCount = 5 25 | queueNames = ["q1", "q2"] as String[] 26 | } 27 | 28 | messageStoreServiceRabbitAdapter { 29 | encoding = "UTF-8" 30 | responseRoutingKey = "replyQueue" 31 | } 32 | } 33 | {code} 34 | 35 | This approach works for any property that accepts a basic type. But what about bean references? In this case, you can't use the bean property overrides. Fortunately, the most common bean reference you are likely to want to override, the message converter, has a dedicated configuration option: 36 | 37 | {code} 38 | rabbitmq.messageConverterBean = "myCustomMessageConverter" 39 | {code} 40 | 41 | This is a global setting that accepts the name of a message converter bean. For the rare occasions that you need to override other bean references, you can declare your own @_MessageListenerContainer@ or @_RabbitAdapter@ beans in resources.groovy. 42 | 43 | Finally, you can override some of the global config options on a per-service basis: 44 | 45 | {code} 46 | rabbitmq { 47 | services { 48 | messageStoreService { 49 | concurrentConsumers = 50 50 | disableListening = true 51 | } 52 | } 53 | } 54 | {code} 55 | 56 | There are many options for customisation and we hope the above will get you started. 57 | -------------------------------------------------------------------------------- /src/docs/guide/configuration/configuringExchanges.gdoc: -------------------------------------------------------------------------------- 1 | Queues are the foundation of consuming messages, but what if you want to send messages? In AMQP, you send messages to an exchange and the exchange then routes those messages to the appropriate queues based on something called a binding. The key to setting up complex messaging systems lies in configuring these exchanges and queues appropriately. 2 | 3 | h3. Declaring an exchange 4 | 5 | Let's start with an example of how to set up a simple exchange (with no queues): 6 | 7 | {code} 8 | rabbitmq { 9 | connectionfactory { 10 | ... 11 | } 12 | queues = { 13 | exchange name: 'my.topic', type: topic 14 | } 15 | } 16 | {code} 17 | 18 | As you can probably guess, this will create a topic exchange with the name 'my.topic'. There are two things to note at this point: 19 | 20 | # the name and type are required 21 | # the type value is _not_ a string literal 22 | 23 | So what types are available to you? 24 | 25 | {table} 26 | *Type* | *Description* 27 | direct | An exchange that only routes messages that are bound to it with a key that matches the routing key of the message exactly. Typically this exchange is used for point-to-point messaging and the routing key is the queue name. 28 | fanout | Sends messages to all queues bound to it. It basically does a broadcast. 29 | topic | Similar to the @fanout@ exchange, this routes messages to the queues bound to it, but only queues whose binding matches a message's routing key will receive that message. Wildcards are supported in the binding. 30 | headers | Similar to topic, but messages can be filtered by other any message header, not just the routing key. 31 | {table} 32 | 33 | The exchange declaration also supports a couple of extra options that should be familiar from the queue declarations: 34 | 35 | {table} 36 | *Option* | *Description* 37 | autoDelete | If @true@, the exchange will be removed from the broker when there are no more queues bound to it. Note that this doesn't take effect until at least one queue is bound to the exchange. 38 | durable | If @true@, the exchange will survive a restart of the broker. 39 | {table} 40 | 41 | With the above syntax, it is up to you to bind queues to the exchange via another AMQP client or via the RabbitMQ management interface. In other words, this is most suitable if your Grails application is purely a publisher of messages and not a consumer (or at least not a consumer of 'my.topic' messages). 42 | 43 | What if you want to create queues and automatically bind them to the exchange? Don't worry, that's supported by the configuration DSL too. 44 | 45 | h3. Binding queues to exchanges 46 | 47 | An exchange on its own isn't particularly useful, but we can easily bind queues to it by declaring them as nested entries: 48 | 49 | {code} 50 | rabbitmq { 51 | connectionfactory { 52 | ... 53 | } 54 | queues = { 55 | exchange name: 'my.topic', type: topic, durable: false, { 56 | foo durable: true, binding: 'shares.#' 57 | bar durable: false, autoDelete: true, binding: 'shares.nyse.?' 58 | } 59 | } 60 | } 61 | {code} 62 | 63 | In the example above, we bind two queues ('foo' and 'bar') to the exchange 'my.topic'. Since this is a topic exchange, we can use a binding key to filter which messages go from 'my.topic' to each queue. So in this case, only messages with a routing key beginning with 'shares.' will end up on the 'foo' queue. 'bar' will only receive messages whose routing key begins with 'shares.nyse.'. 64 | 65 | This approach isn't limited to topic exchanges: you can automatically bind queues to any exchange type. There are a few things to bear in mind though: 66 | 67 | # the default binding for direct exchanges is the queue name (unless this is explicitly overridden by a 'binding' option); 68 | # the 'binding' is ignored for fanout exchanges; and 69 | # the headers exchange requires a map of message header names and values for its binding. 70 | 71 | {note} 72 | RabbitMQ has several built-in exchanges with names of the form 'amq.*', for example 'amq.direct'. If you want to bind to these, you currently have to declare them with the correct attributes, i.e. 73 | 74 | {code} 75 | exchange name: "amq.direct", type: direct, durable: true, autoDelete: false 76 | {code} 77 | {note} 78 | 79 | As you can imagine, these few building blocks allow you to configure some pretty complex messaging systems with very little effort. You can tailor the messaging system to your needs rather than tailor your applications to the messaging system. 80 | 81 | 82 | -------------------------------------------------------------------------------- /src/docs/guide/configuration/configuringQueues.gdoc: -------------------------------------------------------------------------------- 1 | Queues must be declared in the RabbitMQ server before consumers can be associated with those queues and before messages may be sent to those queues. If the Grails application will be sending messages to or receiving messages from queues that may not already be declared in the RabbitMQ server, the application needs to declare those queues up front. One way to do that is to add beans to the Spring application context of type @org.springframework.amqp.core.Queue@. That 2 | might look something like this: 3 | 4 | {code} 5 | // grails-app/conf/spring/resources.groovy 6 | beans = { 7 | myQueue(org.springframework.amqp.core.Queue, 'myQueueName') 8 | myOtherQueue(org.springframework.amqp.core.Queue, 'myOtherQueueName') { 9 | autoDelete = false 10 | durable = true 11 | exclusive = false 12 | arguments = [arg1: 'val1', arg2: 'val2'] 13 | } 14 | } 15 | {code} 16 | 17 | The plugin also supports a DSL for describing these queues. This DSL is expressed in @grails-app/conf/Config.groovy@. The code below configures the same queues as the previous code sample. 18 | 19 | {code} 20 | // grails-app/conf/Config.groovy 21 | rabbitmq { 22 | connectionfactory { 23 | username = 'guest' 24 | password = 'guest' 25 | hostname = 'localhost' 26 | } 27 | queues = { 28 | myQueueName() 29 | myOtherQueueName autoDelete: false, durable: true, exclusive: false, arguments: [arg1: 'val1', arg2: 'val2'] 30 | } 31 | } 32 | {code} 33 | 34 | {note} 35 | With both techniques, the @autoDelete@, @durable@ and @exclusive@ attributes default to @false@ and the @arguments@ attribute defaults to null. 36 | {note} 37 | 38 | So what do those queue options mean? 39 | 40 | {table} 41 | *Option* | *Description* 42 | autoDelete | If @true@, the queue will be removed from the broker when there are no more clients attached to it. Note that this doesn't take effect until after at least one client connects to the queue. 43 | durable | If @true@, the queue will survive a restart of the broker. 44 | exclusive | Only the client that created the queue can connect to it. 45 | {table} 46 | 47 | One final thing: when you declare a standalone queue like this, it automatically gets bound to the broker's default exchange, which has an implicit name of '', i.e. the empty string. You can easily send messages to this queue via the [rabbitSend|allClasses] method. 48 | -------------------------------------------------------------------------------- /src/docs/guide/consumingMessages.gdoc: -------------------------------------------------------------------------------- 1 | The plugin provides two simple ways of consuming messages: 2 | 3 | # from a named Queue 4 | # by subscribing to an exchange (the traditional pub/sub model) 5 | 6 | Which approach you take depends on whether you want to implement the pub/sub messaging model and how much control you need. 7 | -------------------------------------------------------------------------------- /src/docs/guide/consumingMessages/manualQueueManagement.gdoc: -------------------------------------------------------------------------------- 1 | The plugin provides a convention based mechanism for associating a listener with a queue. Any Grails Service may express that it wants to receive messages on a specific queue by defining a static property named @rabbitQueue@ and 2 | assigning the property a string which represents the name of a queue. 3 | 4 | {code} 5 | package org.grails.rabbitmq.test 6 | 7 | class DemoService { 8 | static rabbitQueue = 'someQueueName' 9 | 10 | void handleMessage(message) { 11 | // handle message... 12 | } 13 | } 14 | {code} 15 | 16 | As with the pub/sub model, messages are delivered to the service by invoking the @handleMessage()@ method. That's all there is to it! The real trick is to configure your exchanges and queues with appropriate bindings, as we described in the configuration section. 17 | 18 | If you want more say in the configuration of the underlying listener, then you can also specify a map: 19 | 20 | {code} 21 | static rabbitQueue = [queues: "someQueueName", channelTransacted: true] 22 | {code} 23 | 24 | The "queues" option can either be a simple queue name or a list of queue names. Again, have a look at the [advanced configuration section|guide:advancedConfig] for information about the extra properties you can set here. 25 | 26 | One last subject to discuss is the form that the messages take. 27 | -------------------------------------------------------------------------------- /src/docs/guide/consumingMessages/messages.gdoc: -------------------------------------------------------------------------------- 1 | What is a message? In the examples you've seen in this section, the message has been some arbitrary object but we haven't discussed what the type of that object might be. That's because, it can be pretty much anything! Within the messaging system, the content of a message is simply a byte array - it's up to the producer can consumer to interpret/convert that raw data. 2 | 3 | Fortunately the plugin (via [Spring AMQP|http://static.springsource.org/spring-amqp/docs/1.0.x/reference/html/#d0e335]) automatically handles messages whose content is in familiar forms, including: 4 | 5 | * strings 6 | * byte arrays 7 | * maps 8 | * other serializable types 9 | 10 | One manifestation of this support is that different message types may be handled with overloaded versions of @handleMessage()@: 11 | 12 | {code} 13 | package org.grails.rabbitmq.test 14 | 15 | class DemoService { 16 | static rabbitQueue = 'someQueueName' 17 | 18 | void handleMessage(String textMessage) { 19 | // handle String message... 20 | } 21 | 22 | void handleMessage(Map mapMessage) { 23 | // handle Map message... 24 | } 25 | 26 | void handleMessage(byte[] byteMessage) { 27 | // handle byte array message... 28 | } 29 | } 30 | {code} 31 | 32 | This is a great convenience, but be aware that using serializable Java objects limits the types of client you can interact with. If all the clients you're interested in are using Spring AMQP, then you should be fine, but don't expect Ruby or Python clients to handle @Map@ messages! For production systems, we recommend you use strings and byte arrays. 33 | 34 | Sometimes you want access to the raw message, particularly if you want to look at the message headers. If so, just change the signature of the @handleMessage()@ method and add an extra option to your @rabbitQueue@ or @rabbitSubscribe@ property: 35 | 36 | {code} 37 | package org.grails.rabbitmq.test 38 | 39 | import org.springframework.amqp.core.Message 40 | 41 | class DemoService { 42 | static rabbitQueue = [queues: 'someQueueName', messageConverterBean: ''] 43 | 44 | void handleMessage(Message msg) { 45 | // Do something with the message headers 46 | println "Received message with content type ${msg.contentType};${msg.encoding}" 47 | ... 48 | } 49 | } 50 | {code} 51 | 52 | As you can see, all you have to do is accept an argument of type @Message@ and add the @messageConverterBean@ option with an empty string as its value. This disables the automatic message conversion, allowing you to interrogate the raw message as required. 53 | -------------------------------------------------------------------------------- /src/docs/guide/consumingMessages/pubSub.gdoc: -------------------------------------------------------------------------------- 1 | One of the most common messaging models people use involves a producer broadcasting messages to all registered listeners (or more accurately, consumers). This is known as the publish/subscribe model, or pub/sub for short. There are two steps to getting this set up in Grails: 2 | 3 | # create the exchange you're going to publish messages to 4 | # create some consumers that subscribe to that exchange 5 | 6 | The first step can be done either outside of the Grails application or in the plugin's configuration. If the Grails application is the publisher, then it makes sense to declare the exchange in @grails-app/conf/Config.groovy@. 7 | 8 | The second step is dead easy with the plugin: create a service with a static @rabbitSubscribe@ property and a @handleMessage()@ method. Here's an example: 9 | 10 | {code} 11 | package org.example 12 | 13 | class SharesService { 14 | static rabbitSubscribe = 'shares' 15 | 16 | void handleMessage(message) { 17 | // handle message... 18 | } 19 | } 20 | {code} 21 | 22 | As long as the broker contains an exchange with the name @shares@, the @SharesService@ will receive all messages sent to that exchange. Every time a message is received from the broker, the service's @handleMessage()@ method is called with the message as its argument. We'll talk more about messages shortly. 23 | 24 | {note} 25 | The @rabbitSubscribe@ option only makes sense when applied to fanout and topic exchanges. 26 | {note} 27 | 28 | In the case of a topic exchange, you can filter messages based on the routing key. By default your service will receive all messages, but you can override this with an alternative syntax for @rabbitSubscribe@: 29 | 30 | {code} 31 | package org.example 32 | 33 | class SharesService { 34 | static rabbitSubscribe = [ name: 'shares', routingKey: 'NYSE.GE' ] 35 | ... 36 | } 37 | {code} 38 | 39 | In this example, the service will only receive messages that have a routing key of 'GE'. Of course, you can use standard AMQP wildcards too like 'NYSE.#', which will match all messages with a routing key that starts with 'NYSE.'. 40 | 41 | Under the hood, the plugin creates a temporary, exclusive queue for your service which is removed from the broker when your application shuts down. There is no way for you to control the name of the queue or attach another listener to it, but then that's the point in this case. If you do need more control, then you must manage the queues and their bindings yourself. 42 | 43 | The map syntax also allows you to customise the properties of the Spring message listener container and the corresponding listener adapter (see the section on [advanced configuration|guide:advancedConfig] for more details on these). For example, 44 | 45 | {code} 46 | static rabbitSubscribe = [ 47 | name: 'shares', 48 | routingKey: 'NYSE.GE', 49 | encoding: "ISO-8859-1", 50 | prefetchCount: 1] 51 | {code} 52 | 53 | will set the encoding and prefetch count for just this service listener. This technique is also possible for straight queue listeners as well. 54 | -------------------------------------------------------------------------------- /src/docs/guide/introduction.gdoc: -------------------------------------------------------------------------------- 1 | The RabbitMQ plugin provides integration with the RabbitMQ highly reliable enterprise messaging system. The 2 | plugin relies on [Spring AMQP|http://www.springsource.org/spring-amqp] as an implementation detail, which provides a high level abstraction 3 | for sending and receiving messages. 4 | 5 | This guide documents configuration details and usage details for the plugin. More information on 6 | RabbitMQ itself is available at [rabbitmq.com|http://www.rabbitmq.com/]. -------------------------------------------------------------------------------- /src/docs/guide/introduction/changeLog.gdoc: -------------------------------------------------------------------------------- 1 | h3. Version 0.3.2 - 16 Mar 2011 2 | 3 | * Upgrade to Spring AMQP 1.0.0.M3 4 | 5 | h3. Version 0.3.1 - 14 Feb 2011 6 | 7 | * spring-core dependency now excluded 8 | * Corrected the SCM and documentation URLs in the plugin descriptor 9 | 10 | h3. Version 0.3 - 7 Feb 2011 11 | 12 | * Upgraded to Spring AMQP 1.0.0 M2 13 | * Added transaction support 14 | * Added support for pub/sub model 15 | * Applications can now configure exchanges and bindings in addition to queues 16 | * Applications can now connect to any virtual host, not just '/' 17 | * Bug fixes: 18 | ** [GRAILSPLUGINS-2496|http://jira.codehaus.org/browse/GRAILSPLUGINS-2496] - Messages are now picked up when the application starts 19 | -------------------------------------------------------------------------------- /src/docs/guide/links.yml: -------------------------------------------------------------------------------- 1 | introduction: 1. Introduction To The RabbitMQ Plugin 2 | changeLog: 1.1 Change log 3 | configuration: 2. Configuration 4 | configuringQueues: 2.1 Configuring Queues 5 | configuringExchanges: 2.2 Configuring Exchanges 6 | sendingMessages: 3. Sending Messages 7 | consumingMessages: 4. Consuming Messages 8 | pubSub: 4.1 Pub-Sub 9 | manualQueueManagement: 4.2 Manual queue management 10 | messages: 4.3 Messages 11 | usingTheRabbitTemplateDirectly: 5. Using The RabbitTemplate Directly 12 | -------------------------------------------------------------------------------- /src/docs/guide/rabbitTemplate.gdoc: -------------------------------------------------------------------------------- 1 | Most of the interaction with the RabbitMQ server is being handled by an instance of [RabbitTemplate|api:org.springframework.amqp.rabbit.core.RabbitTemplate]. For many applications this is happening at a lower level than the application needs to be concerned with. The plugin does provide a Spring bean to the application context that is an instance of the @RabbitTemplate@ class which may be used directly. The bean name is @rabbitTemplate@. 2 | 3 | {code} 4 | class MessageController { 5 | 6 | def rabbitTemplate 7 | 8 | def sendMessage = { 9 | rabbitTemplate.convertAndSend('someQueueName', 'someMessage) 10 | ... 11 | } 12 | } 13 | {code} 14 | -------------------------------------------------------------------------------- /src/docs/guide/rewriteRules.txt: -------------------------------------------------------------------------------- 1 | 1.%20Introduction%20To%20The%20RabbitMQ%20Plugin.html -> introductionToTheRabbitMQPlugin.html 2 | 2.%20Configuration.html -> configuration.html 3 | 3.%20Sending%20Messages.html -> sendingMessages.html 4 | 4.%20Consuming%20Messages.html -> consumingMessages.html 5 | 5.%20Using%20The%20RabbitTemplate%20Directly.html -> usingTheRabbitTemplateDirectly.html 6 | -------------------------------------------------------------------------------- /src/docs/guide/sendingMessages.gdoc: -------------------------------------------------------------------------------- 1 | The plugin adds a method named @rabbitSend@ to all Grails artefacts (Controllers, Services, TagLibs, etc...). The @rabbitSend@ method accepts 2 parameters. The first parameter is a queue name and the second parameter is the message being sent. 2 | 3 | {code} 4 | class MessageController { 5 | 6 | def sendMessage = { 7 | rabbitSend 'someQueueName', 'someMessage' 8 | ... 9 | } 10 | } 11 | {code} 12 | 13 | Messages may also be sent by interacting with the @RabbitTemplate@ Spring bean directly. See the [Using The RabbitTemplate Directly|guide:rabbitTemplate] section for more information. 14 | -------------------------------------------------------------------------------- /src/docs/guide/toc.yml: -------------------------------------------------------------------------------- 1 | introduction: 2 | title: Introduction To The RabbitMQ Plugin 3 | changeLog: Change log 4 | configuration: 5 | title: Configuration 6 | configuringQueues: Configuring Queues 7 | configuringExchanges: Configuring Exchanges 8 | advancedConfig: Advanced Configuration 9 | sendingMessages: Sending Messages 10 | consumingMessages: 11 | title: Consuming Messages 12 | pubSub: Pub-Sub 13 | manualQueueManagement: Manual queue management 14 | messages: Messages 15 | rabbitTemplate: Using The RabbitTemplate Directly 16 | -------------------------------------------------------------------------------- /src/docs/ref/All Classes/rabbitSend.gdoc: -------------------------------------------------------------------------------- 1 | h1. rabbitSend 2 | 3 | h2. Purpose 4 | 5 | Sends a message to a RabbitMQ broker. 6 | 7 | h2. Examples 8 | 9 | {code} 10 | // Send a string message to the default direct exchange. It will be routed to any 11 | // queues that are bound to the default exchange with the key '' (an empty string). 12 | rabbitSend "Some message" 13 | 14 | // Send a map message to the default direct exchange. The message will be routed to 15 | // the queue with the name 'myQueue'. 16 | rabbitSend "myQueue", [cmd: "addBook", title: "The Shining", author: "Stephen King"] 17 | 18 | // Send a string message to a 'prices' exchange with a routing key of 'shares.NYSE.GE'. 19 | rabbitSend "prices", "shares.NYSE.GE", "$354.23" 20 | {code} 21 | 22 | h2. Description 23 | 24 | The @rabbitSend()@ method is basically a convenience over the [Spring AMQP convertAndSend()|http://static.springsource.org/spring-amqp/docs/1.0.x/reference/html/#d0e462] method. It has three basic forms: 25 | 26 | {code} 27 | rabbitSend message 28 | rabbitSend routingKey, message 29 | rabbitSend exchangeName, routingKey, message 30 | {code} 31 | 32 | If @routingKey@ is left out, it defaults to a value of '', i.e. the empty string. The same goes for @exchangeName@, in which case the message is routed to the queue with the same name as the routing key (if specified). 33 | 34 | The message can be any serializable type, although if you want to interoperate with non-Java clients, it's best to stick to string and byte array messages. 35 | 36 | For complex requirements, you can even pass in an object that processes the message after construction. See the Spring AMQP guide for more information on that. 37 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/AutoQueueMessageListenerContainer.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import org.slf4j.LoggerFactory 4 | import org.springframework.amqp.core.BindingBuilder 5 | import org.springframework.amqp.core.DirectExchange 6 | import org.springframework.amqp.core.FanoutExchange 7 | import org.springframework.amqp.core.TopicExchange 8 | import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer 9 | import org.springframework.context.ApplicationContext 10 | import org.springframework.context.ApplicationContextAware 11 | 12 | /** 13 | * Message listener container that creates a temporary, auto-delete queue and 14 | * binds it to a configured exchange. 15 | */ 16 | class AutoQueueMessageListenerContainer extends SimpleMessageListenerContainer implements ApplicationContextAware { 17 | private static final log = LoggerFactory.getLogger(AutoQueueMessageListenerContainer) 18 | 19 | String rabbitAdminBeanName = "adm" 20 | ApplicationContext applicationContext 21 | 22 | /** 23 | * The exchange to bind the temporary queue to. This can be a string 24 | * containing the name of the exchange, or a map containing the name 25 | * of the exchange (key: 'name') and the routing key (key: 'routing'). 26 | * If no routing key is specified, the match-all wildcard ('#') is used. 27 | */ 28 | String exchangeBeanName 29 | 30 | /** 31 | * The routing key to bind the queue to the exchange with. This is 32 | * the 'match-all' wildcard by default: '#'. 33 | */ 34 | String routingKey = '#' 35 | 36 | protected void doStart() { 37 | // Check the exchange name has been specified. 38 | if (!exchangeBeanName) { 39 | log.error "Property [exchangeBeanName] must have a value!" 40 | return 41 | } 42 | 43 | // First, create a broker-named, temporary queue. 44 | def adminBean = getApplicationContext().getBean(rabbitAdminBeanName) 45 | def queue = adminBean.declareQueue() 46 | 47 | // Now bind this queue to the named exchanged. If the exchange is a 48 | // fanout, then we don't bind with a routing key. If it's a topic, 49 | // we use the 'match-all' wildcard. Other exchange types are not 50 | // supported. 51 | def exchange = getApplicationContext().getBean(exchangeBeanName) 52 | 53 | def binding = null 54 | if (exchange instanceof FanoutExchange) { 55 | binding = BindingBuilder.bind(queue).to(exchange); 56 | } 57 | else if (exchange instanceof DirectExchange || exchange instanceof TopicExchange) { 58 | binding = BindingBuilder.bind(queue).to(exchange).with(routingKey); 59 | } 60 | else { 61 | log.error "Cannot subscribe to an exchange ('${exchange.name}') that is neither a fanout nor a topic" 62 | return 63 | } 64 | 65 | adminBean.declareBinding(binding) 66 | 67 | // Let the super class do the rest. 68 | super.setQueueNames(queue.name) 69 | super.doStart() 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/RabbitConfigurationHolder.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | class RabbitConfigurationHolder { 4 | 5 | def rabbitmqConfig 6 | 7 | public RabbitConfigurationHolder(rabbitmqConfig) { 8 | this.rabbitmqConfig = rabbitmqConfig 9 | } 10 | 11 | int getDefaultConcurrentConsumers() { 12 | return rabbitmqConfig.concurrentConsumers ?: 1 13 | } 14 | 15 | int getServiceConcurrentConsumers(def service) { 16 | def propertyName = service.propertyName 17 | return rabbitmqConfig.services?."${propertyName}"?.concurrentConsumers ?: defaultConcurrentConsumers 18 | } 19 | 20 | boolean isListeningDisabled() { 21 | return rabbitmqConfig.disableListening 22 | } 23 | 24 | boolean isServiceEnabled(def service) { 25 | if (listeningDisabled) return false 26 | def propertyName = service.propertyName 27 | return !rabbitmqConfig.services?."${propertyName}"?.disableListening 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/RabbitDynamicMethods.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import org.springframework.amqp.core.Address 4 | import org.springframework.amqp.core.Message 5 | import org.springframework.amqp.core.MessagePostProcessor 6 | 7 | /** 8 | * Class for applying the dynamic rabbitSend() and rabbitRpcSend() methods to 9 | * specified classes. Makes unit testing and reuse easier. 10 | */ 11 | class RabbitDynamicMethods { 12 | 13 | static void applyAllMethods(target, ctx) { 14 | applyRabbitSend(target, ctx) 15 | // applyRabbitRpcSend(target, ctx) 16 | } 17 | 18 | static void applyRabbitSend(target, ctx) { 19 | target.metaClass.rabbitSend = { Object[] args -> 20 | // The last argument of convertAndSend is of type Object so the 21 | // automatic conversion of GString to String doesn't happen as 22 | // it does for the other arguments. Since the code in that method 23 | // checks for String, we do the conversion manually. 24 | args = processArgs(args) 25 | ctx.rabbitTemplate.convertAndSend(*args) 26 | } 27 | } 28 | 29 | static void applyRabbitRpcSend(target, ctx) { 30 | target.metaClass.rabbitRpcSend = { Object[] args -> 31 | // Last argument is a reply queue name 32 | // TODO add support for a closure or a service listener as an alternative 33 | // to the reply queue name. In those cases, the reply queue should automatically 34 | // be created and the closure/listener invoked when the reply is received. 35 | def newArgs = args.toList() 36 | def reply = newArgs.pop() 37 | newArgs = processArgs(newArgs) 38 | 39 | newArgs << ({ Message msg -> 40 | msg.messageProperties.replyTo = new Address(reply) 41 | return msg 42 | } as MessagePostProcessor) 43 | 44 | ctx.rabbitTemplate.convertAndSend(newArgs) 45 | } 46 | } 47 | 48 | private static processArgs(args) { 49 | int i = args[-1] instanceof MessagePostProcessor ? -2 : -1 50 | if (args[i] instanceof GString) { 51 | args[i] = args[i].toString() 52 | } 53 | return args 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/RabbitErrorHandler.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import org.slf4j.Logger 4 | import org.slf4j.LoggerFactory 5 | import org.springframework.util.ErrorHandler 6 | 7 | /** 8 | * A simple error handler that logs exceptions via SLF4J. 9 | */ 10 | class RabbitErrorHandler implements ErrorHandler { 11 | private static final Logger log = LoggerFactory.getLogger(this) 12 | 13 | void handleError(Throwable t) { 14 | log.error "Rabbit service listener failed.", t 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/RabbitQueueBuilder.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import org.springframework.amqp.core.* 4 | import org.slf4j.LoggerFactory 5 | 6 | class RabbitQueueBuilder { 7 | 8 | private final static log = LoggerFactory.getLogger(RabbitQueueBuilder) 9 | 10 | List bindings = [] 11 | List exchanges = [] 12 | List queues = [] 13 | 14 | private currentExchange 15 | 16 | def methodMissing(String methodName, args) { 17 | Queue queue 18 | 19 | def argsMap = args ? args[0] : [:] 20 | if(argsMap) { 21 | Boolean autoDelete = Boolean.valueOf(argsMap.autoDelete) 22 | Boolean exclusive = Boolean.valueOf(argsMap.exclusive) 23 | Boolean durable = Boolean.valueOf(argsMap.durable) 24 | Map arguments 25 | if(argsMap.arguments instanceof Map) { 26 | arguments = argsMap.arguments 27 | } 28 | queue = new Queue(methodName, durable, exclusive, autoDelete, arguments) 29 | } else { 30 | queue = new Queue(methodName) 31 | } 32 | 33 | // If we are nested inside of an exchange definition, create 34 | // a binding between the queue and the exchange. 35 | if (currentExchange) { 36 | def newBinding = [ queue: methodName, exchange: currentExchange.name ] 37 | bindings << newBinding 38 | 39 | switch (currentExchange.type) { 40 | case DirectExchange: 41 | if (argsMap.binding && !(argsMap.binding instanceof CharSequence)) { 42 | throw new RuntimeException( 43 | "The binding for queue '${methodName}' to direct " + 44 | "exchange '${currentExchange.name}' must be a string.") 45 | } 46 | 47 | // Use the name of the queue as a default binding if no 48 | // explicit one is declared. 49 | newBinding.rule = argsMap.binding ?: queue.name 50 | break 51 | 52 | case FanoutExchange: 53 | // Any binding will be ignored. 54 | log.warn "'${currentExchange.name}' is a fanout exchange - binding for queue '${methodName}' ignored" 55 | newBinding.rule = "" // rabbit client API doesn't like a null binding 56 | break 57 | 58 | case HeadersExchange: 59 | if (!(argsMap.binding instanceof Map)) { 60 | throw new RuntimeException( 61 | "The binding for queue '${methodName}' to headers " + 62 | "exchange '${currentExchange.name}' must be declared " + 63 | "and must be a map.") 64 | } 65 | 66 | newBinding.rule = argsMap.binding 67 | break 68 | 69 | case TopicExchange: 70 | if (!(argsMap.binding instanceof CharSequence)) { 71 | throw new RuntimeException( 72 | "The binding for queue '${methodName}' to topic " + 73 | "exchange '${currentExchange.name}' must be declared " + 74 | "and must be a string.") 75 | } 76 | 77 | newBinding.rule = argsMap.binding 78 | break 79 | } 80 | } 81 | queues << queue 82 | } 83 | 84 | /** 85 | * Defines a new exchange. 86 | * @param args The properties of the exchange, such as its name 87 | * and whether it is durable or not. 88 | * @param c An optional closure that includes queue definitions. 89 | * If provided, the queues are bound to this exchange. 90 | */ 91 | def exchange(Map args, Closure c = null) { 92 | if (currentExchange) throw new RuntimeException("Cannot declare an exchange within another exchange") 93 | if (!args.name) throw new RuntimeException("A name must be provided for the exchange") 94 | if (!args.type) throw new RuntimeException("A type must be provided for the exchange '${args.name}'") 95 | exchanges << [ *:args ] 96 | 97 | if (c) { 98 | currentExchange = exchanges[-1] 99 | c = c.clone() 100 | c.delegate = this 101 | c() 102 | } 103 | 104 | // Clear the current exchange regardless of whether there was 105 | // a closure argument or not. Just an extra safety measure. 106 | currentExchange = null 107 | } 108 | 109 | def getDirect() { return DirectExchange } 110 | def getFanout() { return FanoutExchange } 111 | def getHeaders() { return HeadersExchange } 112 | def getTopic() { return TopicExchange } 113 | } 114 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/RabbitServiceConfigurer.groovy: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 the original author or authors 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package grails.plugins.rabbitmq 17 | 18 | import grails.util.GrailsClassUtils as GCU 19 | import org.slf4j.LoggerFactory 20 | import org.springframework.amqp.core.AcknowledgeMode 21 | 22 | import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer 23 | import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter 24 | 25 | /** 26 | *

Configures the Spring beans required to set up a service as an AMQP 27 | * listener. The service must have either a static rabbitQueue 28 | * property declared or a static rabbitSubscribe one (but not 29 | * both). If neither of these exist, nothing is configured. Otherwise, 30 | * it will configure a {@link SimpleMessageListenerContainer} and an 31 | * associated {@link MessageListenerAdapter}.

32 | */ 33 | class RabbitServiceConfigurer { 34 | 35 | private final static log = LoggerFactory.getLogger(RabbitServiceConfigurer) 36 | 37 | public static final String LISTENER_CONTAINER_SUFFIX = "_MessageListenerContainer" 38 | public static final String MESSAGE_CONVERTER_OPTION = "messageConverterBean" 39 | 40 | private static final String QUEUE = "rabbitQueue" 41 | private static final String SUBSCRIBE = "rabbitSubscribe" 42 | private static final Set ADAPTER_OPTIONS = [ 43 | MESSAGE_CONVERTER_OPTION, 44 | "defaultListenerMethod", 45 | "encoding", 46 | "immediatePublish", 47 | "mandatoryPublish", 48 | "responseExchange", 49 | "responseRoutingKey" ] 50 | 51 | private serviceGrailsClass 52 | private rabbitConfig 53 | private type 54 | private options = [:] 55 | private beanBuilder 56 | 57 | /** 58 | * Fairly cheap configurer construction. Create new ones as needed. If 59 | * the given service isn't declared as an AMPQ/Rabbit listener, then 60 | * the object is successfully created, but {@link #isListener()} will 61 | * return false. 62 | * @param serviceClass The GrailsServiceClass for the service 63 | * that requires configuration. 64 | * @param rabbitConfig The Rabbit config, i.e. everthing below 'rabbitmq' 65 | * in the project's Config.groovy. 66 | */ 67 | RabbitServiceConfigurer(serviceClass, rabbitConfig) { 68 | this.serviceGrailsClass = serviceClass 69 | this.rabbitConfig = rabbitConfig 70 | 71 | validateAndInit() 72 | } 73 | 74 | /** 75 | * Configures the Spring beans required to make the associated Grails 76 | * service an AMQP listener. 77 | * @param beanBuilder A BeanBuilder instance through which the required 78 | * Spring beans will be declared. 79 | */ 80 | def configure(beanBuilder) { 81 | if (!isListener()) return 82 | 83 | this.beanBuilder = beanBuilder 84 | 85 | def optionGroups = options.groupBy { (it.key in ADAPTER_OPTIONS) ? "adapter" : "container" } 86 | configureListener(optionGroups["container"], optionGroups["adapter"]) 87 | } 88 | 89 | /** 90 | * Returns true if the associated service is declared as an 91 | * AMQP listener, otherwise false. 92 | */ 93 | boolean isListener() { 94 | return type != null 95 | } 96 | 97 | protected validateAndInit(service) { 98 | def rabbitQueue = GCU.getStaticPropertyValue(serviceGrailsClass.clazz, QUEUE) 99 | def rabbitSubscribe = GCU.getStaticPropertyValue(serviceGrailsClass.clazz, SUBSCRIBE) 100 | 101 | if (rabbitQueue && rabbitSubscribe) { 102 | throw new IllegalStateException( 103 | "${serviceGrailsClass.shortName} declares both 'rabbitQueue' and 'rabbitSubscribe'. " + 104 | "You can only have one of them in a class.") 105 | } 106 | 107 | if (rabbitQueue) initForQueue(rabbitQueue) 108 | else if (rabbitSubscribe) initForSubscribe(rabbitSubscribe) 109 | } 110 | 111 | protected initForQueue(propertyValue) { 112 | type = QUEUE 113 | initOptionsForQueue(propertyValue) 114 | } 115 | 116 | protected initOptionsForQueue(String queue) { 117 | if (!queue) { 118 | throw new IllegalArgumentException( 119 | "${serviceGrailsClass.shortName} must declare a non-empty string for its " + 120 | "'rabbitQueue' property.") 121 | } 122 | 123 | initOptionsForQueue([queues: queue]) 124 | } 125 | 126 | protected initOptionsForQueue(Map queueOptions) { 127 | if (queueOptions.queues == null) { 128 | throw new IllegalArgumentException( 129 | "${serviceGrailsClass.shortName} must declare a 'queues' entry in its " + 130 | "'rabbitQueue' map. This must be a queue name or a collection/array of queue names.") 131 | } 132 | 133 | options << queueOptions 134 | 135 | def queueNames = options.remove("queues") 136 | if (queueNames instanceof CharSequence) options.queueNames = queueNames.toString() 137 | else options.queueNames = queueNames as String[] 138 | } 139 | 140 | protected initForSubscribe(propertyValue) { 141 | type = SUBSCRIBE 142 | initOptionsForSubscribe(propertyValue) 143 | } 144 | 145 | protected initOptionsForSubscribe(String exchange) { 146 | if (!exchange) { 147 | throw new IllegalArgumentException( 148 | "${serviceGrailsClass.shortName} must declare a non-empty string for its " + 149 | "'rabbitSubscribe' property.") 150 | } 151 | 152 | initOptionsForSubscribe([name: exchange]) 153 | } 154 | 155 | protected initOptionsForSubscribe(Map subscribeOptions) { 156 | if (!subscribeOptions.name) { 157 | throw new IllegalArgumentException( 158 | "${serviceGrailsClass.shortName} must declare a 'name' entry in its " + 159 | "'rabbitSubscribe' map. This must be the name of a valid exchange.") 160 | } 161 | 162 | options << subscribeOptions 163 | options.exchangeBeanName = "grails.rabbit.exchange.${options.remove("name")}" 164 | } 165 | 166 | protected configureListener(containerOptions, adapterOptions) { 167 | def configHolder = new RabbitConfigurationHolder(rabbitConfig) 168 | def propertyName = serviceGrailsClass.propertyName 169 | def serviceConcurrentConsumers = configHolder.getServiceConcurrentConsumers(serviceGrailsClass) 170 | log.info "Setting up rabbitmq listener for ${serviceGrailsClass.clazz} with " + 171 | "${serviceConcurrentConsumers} consumer(s)" 172 | 173 | containerOptions = containerOptions ?: [:] 174 | adapterOptions = adapterOptions ?: [:] 175 | 176 | processMessageConverterEntry(adapterOptions) 177 | 178 | // First add an adapter for the given service that exposes it as a listener. 179 | beanBuilder."${propertyName}RabbitAdapter"(MessageListenerAdapter) { 180 | delegate.delegate = ref(propertyName) 181 | 182 | for (entry in adapterOptions) { 183 | delegate."${entry.key}" = entry.value 184 | } 185 | } 186 | 187 | // Next, define the listener container, i.e. the object that receives the 188 | // messages and passes them on to the listener. 189 | def listenerClass = type == SUBSCRIBE ? AutoQueueMessageListenerContainer : SimpleMessageListenerContainer 190 | beanBuilder."${propertyName}${LISTENER_CONTAINER_SUFFIX}"(listenerClass) { 191 | // There seems to be a bug in Spring AMQP 1.0.0 that treats the default 192 | // AUTO acknowledge mode as if it's no auto-acking. So we use NONE. If 193 | // the bug is fixed, this workaround may break things! 194 | acknowledgeMode = isServiceTransactional() ? AcknowledgeMode.AUTO : AcknowledgeMode.NONE 195 | 196 | // Exceptions from listeners don't seem to be logged by Spring AMQP - 197 | // not very useful! This simple error handler just performs the logging. 198 | errorHandler = ref("rabbitErrorHandler") 199 | 200 | // We manually start the listener later, once we know the service is 201 | // ready to process messages. 202 | autoStartup = false 203 | channelTransacted = isServiceTransactional() 204 | connectionFactory = ref("rabbitConnectionFactory") 205 | concurrentConsumers = serviceConcurrentConsumers 206 | messageListener = ref("${propertyName}RabbitAdapter") 207 | for (entry in containerOptions) { 208 | delegate."${entry.key}" = entry.value 209 | } 210 | } 211 | } 212 | 213 | protected processMessageConverterEntry(adapterOptions) { 214 | def messageConverterBean = rabbitConfig.messageConverterBean 215 | 216 | if (adapterOptions.containsKey(MESSAGE_CONVERTER_OPTION)) { 217 | def optionValue = adapterOptions.remove(MESSAGE_CONVERTER_OPTION) 218 | adapterOptions.messageConverter = optionValue ? beanBuilder.ref(optionValue) : null 219 | } 220 | else if (messageConverterBean) { 221 | adapterOptions.messageConverter = beanBuilder.ref(messageConverterBean) 222 | } 223 | } 224 | 225 | protected boolean isServiceTransactional() { 226 | def propertyName = serviceGrailsClass.propertyName 227 | def txn = serviceGrailsClass.transactional 228 | if (!(rabbitConfig."${propertyName}".transactional instanceof ConfigObject)) { 229 | txn = rabbitConfig."${propertyName}".transactional as Boolean 230 | } 231 | 232 | return txn 233 | } 234 | } 235 | -------------------------------------------------------------------------------- /src/main/groovy/grails.plugins.rabbitmq/RabbitmqGrailsPlugin.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import grails.core.GrailsApplication 4 | import grails.plugins.Plugin 5 | import org.grails.core.artefact.ServiceArtefactHandler 6 | import org.springframework.context.ApplicationContext 7 | 8 | import static org.springframework.amqp.core.Binding.DestinationType.QUEUE 9 | 10 | import org.aopalliance.aop.Advice 11 | import org.springframework.amqp.core.Binding 12 | import org.springframework.amqp.core.Queue 13 | import org.springframework.amqp.rabbit.config.StatefulRetryOperationsInterceptorFactoryBean 14 | import org.springframework.amqp.rabbit.core.RabbitAdmin 15 | import org.springframework.amqp.rabbit.core.RabbitTemplate 16 | import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer 17 | import org.springframework.amqp.rabbit.retry.MissingMessageIdAdvice 18 | import org.springframework.amqp.support.converter.SimpleMessageConverter 19 | import org.springframework.retry.backoff.FixedBackOffPolicy 20 | import org.springframework.retry.policy.MapRetryContextCache 21 | import org.springframework.retry.policy.SimpleRetryPolicy 22 | import org.springframework.retry.support.RetryTemplate 23 | 24 | 25 | class RabbitmqGrailsPlugin extends Plugin { 26 | // the plugin version 27 | def version = "2.0.0-SNAPSHOT" 28 | // the version or versions of Grails the plugin is designed for 29 | def grailsVersion = "3.0.2 > *" 30 | // the other plugins this plugin depends on 31 | def dependsOn = [:] 32 | // resources that are excluded from plugin packaging 33 | def pluginExcludes = [ 34 | "grails-app/views/error.gsp", 35 | "grails-app/services/**", 36 | "grails-app/controllers/**", 37 | "grails-app/views/message/*", 38 | "grails-app/conf/application.groovy", 39 | "src/main/groovy/grails/plugins/rabbitmq/test/**", 40 | "**/.gitignore" 41 | ] 42 | 43 | def author = "Jeff Brown" 44 | def authorEmail = "jeff.brown@springsource.com" 45 | def title = "RabbitMQ Plugin" 46 | def description = "The RabbitMQ plugin provides integration with the RabbitMQ Messaging System." 47 | 48 | def license = "APACHE" 49 | def organization = [ name: "SpringSource", url: "http://www.springsource.org/" ] 50 | def developers = [ [ name: "Peter Ledbrook", email: "pledbrook@vmware.com" ], 51 | [ name: "Puneet Behl", email: "puneet.behl007@gmail.com" ]] 52 | def issueManagement = [ system: "JIRA", url: "http://jira.codehaus.org/browse/GRAILSPLUGINS" ] 53 | def scm = [ url: "https://github.com/grails-plugins/grails-rabbitmq" ] 54 | 55 | // URL to the plugin's documentation 56 | def documentation = "http://grails-plugins.github.com/grails-rabbitmq/" 57 | 58 | def loadAfter = ['services'] 59 | def observe = ['*'] 60 | 61 | Closure doWithSpring() {{ -> 62 | 63 | GrailsApplication application = grailsApplication 64 | def rabbitmqConfig = application.config.rabbitmq 65 | def configHolder = new RabbitConfigurationHolder(rabbitmqConfig) 66 | 67 | def connectionFactoryConfig = rabbitmqConfig?.connectionfactory 68 | 69 | def connectionFactoryUsername = connectionFactoryConfig?.username 70 | def connectionFactoryPassword = connectionFactoryConfig?.password 71 | def connectionFactoryVirtualHost = connectionFactoryConfig?.virtualHost 72 | def connectionFactoryHostname = connectionFactoryConfig?.hostname 73 | def connectionFactoryPort = connectionFactoryConfig?.port 74 | def connectionChannelCacheSize = connectionFactoryConfig?.channelCacheSize ?: 10 75 | 76 | def messageConverterBean = rabbitmqConfig?.messageConverterBean 77 | 78 | if(!connectionFactoryUsername || !connectionFactoryPassword || !connectionFactoryHostname) { 79 | log.error 'RabbitMQ connection factory settings (rabbitmq.connectionfactory.username, rabbitmq.connectionfactory.password and rabbitmq.connectionfactory.hostname) must be defined in Config.groovy' 80 | } else { 81 | 82 | log.debug "Connecting to rabbitmq ${connectionFactoryUsername}@${connectionFactoryHostname} with ${configHolder.getDefaultConcurrentConsumers()} consumers." 83 | 84 | def connectionFactoryClassName = connectionFactoryConfig?.className ?: 'org.springframework.amqp.rabbit.connection.CachingConnectionFactory' 85 | def parentClassLoader = getClass().classLoader 86 | def loader = new GroovyClassLoader(parentClassLoader) 87 | def connectionFactoryClass = loader.loadClass(connectionFactoryClassName) 88 | rabbitConnectionFactory(connectionFactoryClass, connectionFactoryHostname) { 89 | username = connectionFactoryUsername 90 | password = connectionFactoryPassword 91 | channelCacheSize = connectionChannelCacheSize 92 | 93 | if (connectionFactoryPort) { 94 | port = connectionFactoryPort 95 | } 96 | 97 | if (connectionFactoryVirtualHost) { 98 | virtualHost = connectionFactoryVirtualHost 99 | } 100 | } 101 | rabbitTemplate(RabbitTemplate) { 102 | connectionFactory = rabbitConnectionFactory 103 | if (messageConverterBean) { 104 | messageConverter = ref(messageConverterBean) 105 | } else { 106 | def converter = new SimpleMessageConverter() 107 | converter.createMessageIds = true 108 | messageConverter = converter 109 | } 110 | } 111 | adm(RabbitAdmin, rabbitConnectionFactory) 112 | rabbitErrorHandler(RabbitErrorHandler) 113 | 114 | // Add beans to hook up services as AMQP listeners. 115 | Set registeredServices = new HashSet() 116 | for(service in application.getServiceClasses()) { 117 | def serviceConfigurer = new RabbitServiceConfigurer(service, rabbitmqConfig) 118 | if(!serviceConfigurer.isListener() || !configHolder.isServiceEnabled(service)) continue 119 | 120 | def propertyName = service.propertyName 121 | if(!registeredServices.add(propertyName)) { 122 | throw new IllegalArgumentException( 123 | "Unable to initialize rabbitmq listeners properly." + 124 | " More than one service named ${propertyName}.") 125 | } 126 | 127 | serviceConfigurer.configure(delegate) 128 | } 129 | 130 | def queuesConfig = application.config.rabbitmq?.queues 131 | if(queuesConfig) { 132 | def queueBuilder = new RabbitQueueBuilder() 133 | queuesConfig = queuesConfig.clone() 134 | queuesConfig.delegate = queueBuilder 135 | queuesConfig.resolveStrategy = Closure.DELEGATE_FIRST 136 | queuesConfig() 137 | 138 | // Deal with declared exchanges first. 139 | queueBuilder.exchanges?.each { exchange -> 140 | if (log.debugEnabled) { 141 | log.debug "Registering exchange '${exchange.name}'" 142 | } 143 | 144 | "grails.rabbit.exchange.${exchange.name}"(exchange.type, exchange.name, 145 | Boolean.valueOf(exchange.durable), 146 | Boolean.valueOf(exchange.autoDelete), 147 | exchange.arguments) 148 | } 149 | 150 | // Next, the queues. 151 | queueBuilder.queues?.each { queue -> 152 | if (log.debugEnabled) { 153 | log.debug "Registering queue '${queue.name}'" 154 | } 155 | 156 | "grails.rabbit.queue.${queue.name}"(Queue, queue.name, 157 | Boolean.valueOf(queue.durable), 158 | Boolean.valueOf(queue.exclusive), 159 | Boolean.valueOf(queue.autoDelete), 160 | queue.arguments, 161 | ) 162 | } 163 | 164 | // Finally, the bindings between exchanges and queues. 165 | queueBuilder.bindings?.each { binding -> 166 | if (log.debugEnabled) { 167 | log.debug "Registering binding between exchange '${binding.exchange}' & queue '${binding.queue}'" 168 | } 169 | 170 | def args = [ ref("grails.rabbit.exchange.${binding.exchange}"), ref ("grails.rabbit.queue.${binding.queue}") ] 171 | if (binding.rule) { 172 | log.debug "Binding with rule '${binding.rule}'" 173 | 174 | // Support GString and String for the rule. Other types of rule (Map 175 | // is the only valid option atm) are passed through as is. 176 | args << (binding.rule instanceof CharSequence ? binding.rule.toString() : binding.rule) 177 | } 178 | 179 | "grails.rabbit.binding.${binding.exchange}.${binding.queue}"(Binding, binding.queue, QUEUE, binding.exchange, binding.rule, binding.arguments ) 180 | } 181 | } 182 | 183 | rabbitRetryHandler(StatefulRetryOperationsInterceptorFactoryBean) { 184 | def retryPolicy = new SimpleRetryPolicy() 185 | def maxRetryAttempts = 1 186 | if(rabbitmqConfig?.retryPolicy?.containsKey('maxAttempts')) { 187 | def maxAttemptsConfigValue = rabbitmqConfig.retryPolicy.maxAttempts 188 | if(maxAttemptsConfigValue instanceof Integer) { 189 | maxRetryAttempts = maxAttemptsConfigValue 190 | } else { 191 | log.error "rabbitmq.retryPolicy.maxAttempts [$maxAttemptsConfigValue] of type [${maxAttemptsConfigValue.getClass().getName()}] is not an Integer and will be ignored. The default value of [${maxRetryAttempts}] will be used" 192 | } 193 | } 194 | retryPolicy.maxAttempts = maxRetryAttempts 195 | 196 | def backOffPolicy = new FixedBackOffPolicy() 197 | backOffPolicy.backOffPeriod = 5000 198 | 199 | def retryTemplate = new RetryTemplate() 200 | retryTemplate.retryPolicy = retryPolicy 201 | retryTemplate.backOffPolicy = backOffPolicy 202 | 203 | retryOperations = retryTemplate 204 | } 205 | } 206 | } } 207 | 208 | void doWithDynamicMethods(){ 209 | GrailsApplication application = grailsApplication 210 | ApplicationContext appCtx = applicationContext 211 | addDynamicMessageSendingMethods application.getAllClasses(), appCtx 212 | } 213 | 214 | private addDynamicMessageSendingMethods(classes, ctx) { 215 | if(ctx.rabbitConnectionFactory) { 216 | classes.each { clz -> 217 | RabbitDynamicMethods.applyAllMethods(clz, ctx) 218 | } 219 | } 220 | } 221 | 222 | void doWithApplicationContext() { 223 | def containerBeans = applicationContext.getBeansOfType(SimpleMessageListenerContainer) 224 | if(applicationContext.rabbitTemplate?.messageConverter instanceof org.springframework.amqp.support.converter.AbstractMessageConverter) { 225 | applicationContext.rabbitTemplate.messageConverter.createMessageIds = true 226 | } 227 | containerBeans.each { beanName, bean -> 228 | if(isServiceListener(beanName)) { 229 | initialiseAdviceChain bean, applicationContext 230 | 231 | // Now that the listener is properly configured, we can start it. 232 | bean.start() 233 | } 234 | } 235 | } 236 | 237 | void onChange(Map event) { 238 | GrailsApplication application = grailsApplication 239 | Map evt = event 240 | if(evt.source instanceof Class) { 241 | addDynamicMessageSendingMethods ([evt.source], evt.ctx) 242 | 243 | // If a service has changed, reload the associated beans 244 | if(isServiceEventSource(application, evt.source)) { 245 | def serviceGrailsClass = application.addArtefact(ServiceArtefactHandler.TYPE, evt.source) 246 | def serviceConfigurer = new RabbitServiceConfigurer( 247 | serviceGrailsClass, 248 | application.config.rabbitmq) 249 | if (serviceConfigurer.isListener()) { 250 | def beans = beans { 251 | serviceConfigurer.configure(delegate) 252 | } 253 | beans.registerBeans(evt.ctx) 254 | startServiceListener(serviceGrailsClass.propertyName, evt.ctx) 255 | } 256 | } 257 | 258 | // Other listener containers may have been stopped if they were 259 | // affected by the re-registering of the changed class. For example, 260 | // if the Rabbitmq consumer service directly or indirectly depends 261 | // on a modified service. So we need to restart those that aren't 262 | // running. 263 | def containerBeans = applicationContext.getBeansOfType(SimpleMessageListenerContainer) 264 | containerBeans.each { beanName, bean -> 265 | if (!bean.running) { 266 | initialiseAdviceChain bean, applicationContext 267 | bean.start() 268 | } 269 | } 270 | } 271 | } 272 | 273 | protected isServiceListener(beanName) { 274 | return beanName.endsWith(RabbitServiceConfigurer.LISTENER_CONTAINER_SUFFIX) 275 | } 276 | 277 | protected isServiceEventSource(application, source) { 278 | return application.isArtefactOfType(ServiceArtefactHandler.TYPE, source) 279 | } 280 | 281 | protected startServiceListener(servicePropertyName, applicationContext) { 282 | def beanName = servicePropertyName + RabbitServiceConfigurer.LISTENER_CONTAINER_SUFFIX 283 | applicationContext.getBean(beanName).start() 284 | } 285 | 286 | protected initialiseAdviceChain(listenerBean, applicationContext) { 287 | def retryTemplate = applicationContext.rabbitRetryHandler.retryOperations 288 | def cache = new MapRetryContextCache() 289 | retryTemplate.retryContextCache = cache 290 | 291 | def missingIdAdvice = new MissingMessageIdAdvice(cache) 292 | listenerBean.adviceChain = [missingIdAdvice, applicationContext.rabbitRetryHandler] as Advice[] 293 | } 294 | } 295 | -------------------------------------------------------------------------------- /src/test/groovy/grails/plugins/rabbitmq/AutoQueueMessageListenerContainerSpec.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import com.rabbitmq.client.AMQP.Queue.DeclareOk 4 | import com.rabbitmq.client.Channel 5 | import com.rabbitmq.client.Consumer 6 | import org.grails.support.MockApplicationContext 7 | import org.springframework.amqp.core.DirectExchange 8 | import org.springframework.amqp.core.FanoutExchange 9 | import org.springframework.amqp.core.Queue 10 | import org.springframework.amqp.core.TopicExchange 11 | import org.springframework.amqp.rabbit.connection.Connection 12 | import org.springframework.amqp.rabbit.connection.ConnectionFactory 13 | import org.springframework.context.ApplicationContext 14 | import spock.lang.Shared 15 | import spock.lang.Specification 16 | 17 | class AutoQueueMessageListenerContainerSpec extends Specification { 18 | @Shared ApplicationContext mockContext = new MockApplicationContext() 19 | @Shared def mockAdminBean = new Expando() 20 | @Shared AutoQueueMessageListenerContainer testContainer = new AutoQueueMessageListenerContainer() 21 | 22 | void setupSpec() { 23 | mockContext = new MockApplicationContext() 24 | mockAdminBean = new Expando() 25 | testContainer = new AutoQueueMessageListenerContainer() 26 | } 27 | 28 | void setup() { 29 | mockContext.registerMockBean("adm", mockAdminBean) 30 | testContainer.applicationContext = mockContext 31 | testContainer.connectionFactory = [ 32 | createConnection: {-> [ 33 | createChannel: { boolean transactional -> [ 34 | basicQos: {int qos -> }, 35 | queueDeclarePassive: {String s -> [:] as DeclareOk }, 36 | basicConsume: {String s, boolean b, Consumer c -> "Test" } 37 | ] as Channel }, 38 | close: {-> /* Do nothing */ } 39 | ] as Connection } 40 | ] as ConnectionFactory 41 | } 42 | 43 | /** 44 | * Make sure that a temporary queue is created and that it is bound to the 45 | * topic exchange with the given name. 46 | */ 47 | void testDoStartWithTopicExchangeName() { 48 | when: 49 | def declareBindingCalled = false 50 | def tempQueueName = "dummy-1234" 51 | def exchangeName = "my.topic" 52 | 53 | mockAdminBean.declareQueue = {-> return new Queue(tempQueueName) } 54 | mockAdminBean.declareBinding = { binding -> 55 | assert binding.exchange == exchangeName 56 | assert binding.destination == tempQueueName 57 | assert binding.routingKey == '#' 58 | declareBindingCalled = true 59 | } 60 | 61 | mockContext.registerMockBean(exchangeName, new TopicExchange(exchangeName)) 62 | 63 | testContainer.exchangeBeanName = exchangeName 64 | testContainer.doStart() 65 | 66 | then: "declareBinding() not called" 67 | declareBindingCalled 68 | } 69 | 70 | 71 | /** 72 | * Make sure that a temporary queue is created and that it is bound to the 73 | * topic exchange with the given name and the given routing key. 74 | */ 75 | void testDoStartWithTopicExchangeAndRoutingKey() { 76 | when: 77 | def declareBindingCalled = false 78 | def tempQueueName = "dummy-1235" 79 | def exchangeName = "another.topic" 80 | def routingKey = "my.routing.#" 81 | 82 | mockAdminBean.declareQueue = {-> return new Queue(tempQueueName) } 83 | mockAdminBean.declareBinding = { binding -> 84 | assert binding.exchange == exchangeName 85 | assert binding.destination == tempQueueName 86 | assert binding.routingKey == routingKey 87 | declareBindingCalled = true 88 | } 89 | 90 | mockContext.registerMockBean(exchangeName, new TopicExchange(exchangeName)) 91 | 92 | testContainer.exchangeBeanName = exchangeName 93 | testContainer.routingKey = routingKey 94 | testContainer.doStart() 95 | 96 | then: "declareBinding() not called" 97 | declareBindingCalled 98 | } 99 | 100 | /** 101 | * Make sure that a temporary queue is created and that it is bound to the 102 | * fanout exchange with the given name. The routing key should not be set. 103 | */ 104 | void testDoStartWithFanoutExchangeName() { 105 | when: 106 | def declareBindingCalled = false 107 | def tempQueueName = "dummy-1234" 108 | def exchangeName = "my.fanout" 109 | 110 | mockAdminBean.declareQueue = {-> return new Queue(tempQueueName) } 111 | mockAdminBean.declareBinding = { binding -> 112 | assert binding.exchange == exchangeName 113 | assert binding.destination == tempQueueName 114 | assert !binding.routingKey 115 | declareBindingCalled = true 116 | } 117 | 118 | mockContext.registerMockBean(exchangeName, new FanoutExchange(exchangeName)) 119 | 120 | testContainer.exchangeBeanName = exchangeName 121 | testContainer.doStart() 122 | 123 | then: "declareBinding() not called" 124 | declareBindingCalled 125 | } 126 | 127 | /** 128 | * Make sure that a temporary queue is created and that it is bound to the 129 | * fanout exchange with the given name. Even if a routing key is given, it 130 | * should be ignored. 131 | */ 132 | void testDoStartWithFanoutExchangeAndRoutingKey() { 133 | when: 134 | def declareBindingCalled = false 135 | def tempQueueName = "dummy-1235" 136 | def exchangeName = "another.fanout" 137 | def routingKey = "my.routing.#" 138 | 139 | mockAdminBean.declareQueue = {-> return new Queue(tempQueueName) } 140 | mockAdminBean.declareBinding = { binding -> 141 | assert binding.exchange == exchangeName 142 | assert binding.destination == tempQueueName 143 | assert !binding.routingKey 144 | declareBindingCalled = true 145 | } 146 | 147 | mockContext.registerMockBean(exchangeName, new FanoutExchange(exchangeName)) 148 | 149 | testContainer.exchangeBeanName = exchangeName 150 | testContainer.routingKey = routingKey 151 | testContainer.doStart() 152 | 153 | then: "declareBinding() not called" 154 | declareBindingCalled 155 | } 156 | 157 | /** 158 | * No binding should be declared if the exchange is not a fanout or topic. 159 | */ 160 | void testDoStartWithDirectExchangeName() { 161 | when: 162 | def declareBindingCalled = false 163 | def tempQueueName = "dummy-1234" 164 | def exchangeName = "my.direct" 165 | 166 | mockAdminBean.declareQueue = {-> return new Queue(tempQueueName) } 167 | mockAdminBean.declareBinding = { binding -> 168 | assert binding.exchange == exchangeName 169 | assert binding.destination == tempQueueName 170 | declareBindingCalled = true 171 | } 172 | 173 | mockContext.registerMockBean(exchangeName, new DirectExchange(exchangeName)) 174 | 175 | testContainer.exchangeBeanName = exchangeName 176 | testContainer.doStart() 177 | 178 | then:"declareBinding() was not called" 179 | declareBindingCalled 180 | } 181 | 182 | } 183 | -------------------------------------------------------------------------------- /src/test/groovy/grails/plugins/rabbitmq/RabbitConfigurationHolderSpec.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import grails.core.GrailsClass 4 | import spock.lang.Shared 5 | import spock.lang.Specification 6 | 7 | class RabbitConfigurationHolderSpec extends Specification { 8 | 9 | @Shared def disabledConfig = toConfigHolder(""" 10 | rabbitmq { 11 | disableListening = true 12 | concurrentConsumers = 2 13 | services { 14 | redService { 15 | concurrentConsumers = 3 16 | disableListening = false 17 | } 18 | blueService { 19 | disableListening = true 20 | } 21 | } 22 | } 23 | """) 24 | 25 | @Shared def enabledConfig = toConfigHolder(""" 26 | rabbitmq { 27 | services { 28 | redService { 29 | concurrentConsumers = 5 30 | disableListening = false 31 | } 32 | blueService { 33 | disableListening = true 34 | } 35 | } 36 | } 37 | """) 38 | 39 | @Shared def blueService = [getPropertyName: {'blueService'}] as GrailsClass 40 | @Shared def redService = [getPropertyName: {'redService'}] as GrailsClass 41 | @Shared def pinkService = [getPropertyName: {'pinkService'}] as GrailsClass 42 | 43 | def toConfigHolder(String config) { 44 | return new RabbitConfigurationHolder(new ConfigSlurper().parse(config).rabbitmq) 45 | } 46 | 47 | void testGetDefaultConcurrentConsumers() { 48 | expect: 49 | disabledConfig.defaultConcurrentConsumers == 2 50 | enabledConfig.defaultConcurrentConsumers == 1 51 | } 52 | 53 | void testServiceConcurrentConsumers() { 54 | expect: 55 | disabledConfig.getServiceConcurrentConsumers(redService) == 3 56 | disabledConfig.getServiceConcurrentConsumers(blueService) == 2 57 | disabledConfig.getServiceConcurrentConsumers(pinkService) == 2 58 | 59 | enabledConfig.getServiceConcurrentConsumers(redService) == 5 60 | enabledConfig.getServiceConcurrentConsumers(blueService) == 1 61 | enabledConfig.getServiceConcurrentConsumers(pinkService) == 1 62 | } 63 | 64 | void testListeningDisabled() { 65 | expect: 66 | disabledConfig.listeningDisabled 67 | !enabledConfig.listeningDisabled 68 | } 69 | 70 | void testServiceEnabled() { 71 | expect: 72 | !disabledConfig.isServiceEnabled(redService) 73 | !disabledConfig.isServiceEnabled(blueService) 74 | !disabledConfig.isServiceEnabled(pinkService) 75 | 76 | enabledConfig.isServiceEnabled(redService) 77 | !enabledConfig.isServiceEnabled(blueService) 78 | enabledConfig.isServiceEnabled(pinkService) 79 | } 80 | 81 | } 82 | -------------------------------------------------------------------------------- /src/test/groovy/grails/plugins/rabbitmq/RabbitDynamicMethodsSpec.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import org.grails.support.MockApplicationContext 4 | import org.springframework.amqp.core.AmqpTemplate 5 | import spock.lang.Specification 6 | 7 | /** 8 | * Test case for {@link RabbitDynamicMethods}. 9 | */ 10 | class RabbitDynamicMethodsSpec extends Specification { 11 | void setupSpec() { 12 | // super.setup() 13 | 14 | // Ensures that the dynamic methods we add to Map are removed 15 | // once each test is complete. 16 | Mock(Map) 17 | } 18 | 19 | void testRabbitRpcSend() { 20 | setup: 21 | AmqpTemplate tmplControl = Mock() 22 | 23 | when: 24 | def testContext = new MockApplicationContext() 25 | testContext.registerMockBean "rabbitTemplate", tmplControl 26 | RabbitDynamicMethods.applyRabbitRpcSend(Map, testContext) 27 | 28 | def testObj = [:] 29 | testObj.rabbitRpcSend "ex", "myQ", "Some message", "replyQ" 30 | 31 | then: 32 | // Check that the convertAndSend() method was invoked. 33 | 1 * tmplControl.convertAndSend(_) 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/test/groovy/grails/plugins/rabbitmq/RabbitGrailsPluginSpec.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import grails.core.GrailsApplication 4 | import grails.spring.BeanBuilder 5 | import grails.test.mixin.TestMixin 6 | import grails.test.mixin.support.GrailsUnitTestMixin 7 | import org.springframework.amqp.core.Binding 8 | import org.springframework.amqp.core.Binding.DestinationType 9 | import org.springframework.amqp.core.Queue 10 | import org.springframework.amqp.core.TopicExchange 11 | import org.springframework.beans.factory.NoSuchBeanDefinitionException 12 | import spock.lang.Specification 13 | 14 | /** 15 | * Test cases for main plugin file setup. 16 | */ 17 | @TestMixin(GrailsUnitTestMixin) 18 | class RabbitGrailsPluginSpec extends Specification { 19 | 20 | def createPluginFileInstance(application = [:]) { 21 | def pluginClass = Class.forName('grails.plugins.rabbitmq.RabbitmqGrailsPlugin') 22 | def pluginInstance = pluginClass.newInstance() 23 | pluginInstance.metaClass.grailsApplication = application 24 | return pluginInstance 25 | } 26 | 27 | void testQueueAndExchangeSetup() { 28 | when: 29 | // mock up test configuration 30 | GrailsApplication application = grailsApplication 31 | 32 | application.metaClass.getServiceClasses = { 33 | return [] 34 | } 35 | application.config = new ConfigSlurper().parse(""" 36 | rabbitmq { 37 | connectionfactory { 38 | username = 'guest' 39 | password = 'guest' 40 | hostname = 'localhost' 41 | } 42 | 43 | queues = { 44 | exchange name: 'it_topic', durable: true, type: topic, autoDelete: false, { 45 | it_q1 autoDelete: false, durable: true, binding: '#', arguments: ['x-ha-policy' : 'all'] 46 | } 47 | } 48 | } 49 | """) 50 | RabbitmqGrailsPlugin base = createPluginFileInstance(application) 51 | 52 | // run a spring builder to create context 53 | def bb = new BeanBuilder() 54 | bb.beans base.doWithSpring() 55 | def ctx = bb.createApplicationContext() 56 | 57 | // test topic 58 | def itTopic = ctx.getBean("grails.rabbit.exchange.it_topic") 59 | 60 | then: 61 | itTopic.getClass() == TopicExchange.class 62 | itTopic.durable 63 | !itTopic.autoDelete 64 | itTopic.name == 'it_topic' 65 | 66 | when: 67 | def itQ1 = ctx.getBean("grails.rabbit.queue.it_q1") 68 | 69 | then: 70 | itQ1.getClass() == Queue.class 71 | itQ1.name == "it_q1" 72 | itQ1.durable == true 73 | itQ1.autoDelete == false 74 | itQ1.arguments['x-ha-policy'] == 'all' 75 | 76 | // test binding 77 | when: 78 | def ibBind = ctx.getBean("grails.rabbit.binding.it_topic.it_q1") 79 | 80 | then: 81 | ibBind.getClass() == Binding.class 82 | ibBind.destination == 'it_q1' 83 | ibBind.exchange == 'it_topic' 84 | ibBind.routingKey == '#' 85 | ibBind.destinationType == DestinationType.QUEUE 86 | } 87 | 88 | void testServiceDisabling() { 89 | when: 90 | def mockBlueService = new MockQueueService(propertyName: 'blueService') 91 | def mockPinkService = new MockQueueService(propertyName: 'pinkService') 92 | def mockRedService = new MockSubscribeService(propertyName: 'redService') 93 | def mockTealService = new MockSubscribeService(propertyName: 'tealService') 94 | 95 | GrailsApplication application = grailsApplication 96 | application.metaClass.getServiceClasses = { -> [mockBlueService, mockRedService, mockPinkService, mockTealService] } 97 | 98 | application.config = new ConfigSlurper().parse(""" 99 | rabbitmq { 100 | connectionfactory { 101 | username = 'guest' 102 | password = 'guest' 103 | hostname = 'localhost' 104 | } 105 | services { 106 | blueService { 107 | concurrentConsumers = 5 108 | disableListening = false 109 | } 110 | redService { 111 | concurrentConsumers = 4 112 | disableListening = true 113 | } 114 | } 115 | } 116 | """) 117 | 118 | RabbitmqGrailsPlugin base = createPluginFileInstance(application) 119 | 120 | def bb = new BeanBuilder() 121 | bb.beans { 122 | pinkService(MockQueueService) { 123 | propertyName = 'pinkService' 124 | } 125 | blueService(MockQueueService) { 126 | propertyName = 'blueService' 127 | } 128 | tealService(MockQueueService) { 129 | propertyName = 'tealService' 130 | } 131 | } 132 | bb.beans(base.doWithSpring()) 133 | def ctx = bb.createApplicationContext() 134 | 135 | then: 136 | ctx.getBean('blueService_MessageListenerContainer').concurrentConsumers == 5 137 | ctx.getBean('pinkService_MessageListenerContainer').concurrentConsumers == 1 138 | 139 | when: 140 | shouldFail(NoSuchBeanDefinitionException) { 141 | ctx.getBean('redService_MessageListenerContainer') 142 | } 143 | 144 | then: 145 | ctx.getBean('tealService_MessageListenerContainer') 146 | } 147 | 148 | void testQueueFailureWhenMultipleListenersHaveSameName() { 149 | when: 150 | def blueService1 = new MockQueueService(propertyName: 'blueService') 151 | def blueService2 = new MockQueueService(propertyName: 'blueService') 152 | def redService1 = new MockSubscribeService(propertyName: 'redService') 153 | def redService2 = new MockSubscribeService(propertyName: 'redService') 154 | 155 | GrailsApplication application = grailsApplication 156 | application.metaClass.getServiceClasses = { 157 | return [blueService1, blueService2] 158 | } 159 | 160 | application.metaClass.config = new ConfigSlurper().parse(""" 161 | rabbitmq { 162 | connectionfactory { 163 | username = 'guest' 164 | password = 'guest' 165 | hostname = 'localhost' 166 | } 167 | } 168 | """) 169 | 170 | RabbitmqGrailsPlugin queueServices = createPluginFileInstance(application) 171 | def msg = shouldFail(IllegalArgumentException) { 172 | new BeanBuilder().beans queueServices.doWithSpring() 173 | } 174 | 175 | then: 176 | msg.contains('blueService') 177 | 178 | when: 179 | application.metaClass.getServiceClasses = { 180 | return [redService1, redService2] 181 | } 182 | 183 | RabbitmqGrailsPlugin subscribeServices = createPluginFileInstance(application) 184 | msg = shouldFail(IllegalArgumentException) { 185 | new BeanBuilder().beans subscribeServices.doWithSpring() 186 | } 187 | 188 | then: 189 | msg.contains('redService') 190 | } 191 | } 192 | 193 | class MockSubscribeService { 194 | static rabbitSubscribe = 'blueExchange' 195 | static transactional = false 196 | def propertyName 197 | def clazz = MockSubscribeService.class 198 | } 199 | 200 | class MockQueueService { 201 | static rabbitQueue = 'blueQueue' 202 | static transactional = false 203 | def propertyName 204 | def clazz = MockQueueService.class 205 | } 206 | -------------------------------------------------------------------------------- /src/test/groovy/grails/plugins/rabbitmq/RabbitQueueBuilderSpec.groovy: -------------------------------------------------------------------------------- 1 | package grails.plugins.rabbitmq 2 | 3 | import grails.test.mixin.TestMixin 4 | import grails.test.mixin.support.GrailsUnitTestMixin 5 | import org.springframework.amqp.core.DirectExchange 6 | import org.springframework.amqp.core.FanoutExchange 7 | import org.springframework.amqp.core.TopicExchange 8 | import spock.lang.Specification 9 | 10 | @TestMixin(GrailsUnitTestMixin) 11 | class RabbitQueueBuilderSpec extends Specification { 12 | 13 | void testSimpleQueue() { 14 | when: 15 | def closure = { 16 | foo() 17 | } 18 | 19 | def builder = new RabbitQueueBuilder() 20 | 21 | closure.delegate = builder 22 | closure() 23 | 24 | def queues = builder.queues 25 | then: 'wrong number of queues' 26 | 1 == queues?.size() 27 | 28 | when: 29 | def queue = queues[0] 30 | 31 | then: 32 | 'foo' == queue.name // wrong queue name 33 | true == queue.durable // wrong durable value 34 | false == queue.autoDelete // wrong auto delete value 35 | false == queue.exclusive // wrong exclusive value 36 | null == queue.arguments // no arguments expected 37 | } 38 | 39 | void testQueueConfigurationDetails() { 40 | when: 41 | def closure = { 42 | foo autoDelete: true, durable: false, exclusive: true 43 | bar autoDelete: false, durable: true, exclusive: false 44 | baz autoDelete: true, arguments: [lang: 'Groovy', framework: 'Grails'] 45 | } 46 | 47 | def builder = new RabbitQueueBuilder() 48 | 49 | closure.delegate = builder 50 | closure() 51 | 52 | def queues = builder.queues 53 | 54 | then: 'wrong number of queues' 55 | 3 == queues?.size() 56 | 57 | when: 58 | def queue = queues[0] 59 | 60 | then: 61 | 'foo' == queue.name // wrong queue name 62 | false == queue.durable // wrong durable value 63 | true == queue.autoDelete // wrong auto delete value 64 | true == queue.exclusive // wrong exclusive value 65 | null == queue.arguments // no arguments expected 66 | 67 | when: 68 | queue = queues[1] 69 | 70 | then: 71 | 'bar' == queue.name // wrong queue name 72 | true == queue.durable // wrong durable value 73 | false == queue.autoDelete // wrong auto delete value 74 | false == queue.exclusive // wrong exclusive value 75 | null == queue.arguments // no arguments expected 76 | 77 | when: 78 | queue = queues[2] 79 | 80 | then: 81 | 'baz' == queue.name // wrong queue name 82 | false == queue.durable // wrong durable value 83 | true == queue.autoDelete // wrong auto delete value 84 | false == queue.exclusive // wrong exclusive value 85 | 2 == queue.arguments?.size() // wrong number of arguments 86 | 'Groovy' == queue.arguments.lang // lang argument had wrong value 87 | 'Grails' == queue.arguments.framework // framework argument had wrong value 88 | } 89 | 90 | void testFanoutExchangeDefinition() { 91 | when: 92 | def closure = { 93 | exchange name: 'my.fanout', type: fanout, durable: true, { 94 | foo autoDelete: true, durable: false, exclusive: true 95 | } 96 | } 97 | def builder = new RabbitQueueBuilder() 98 | closure.delegate = builder 99 | closure() 100 | def exchanges = builder.exchanges 101 | 102 | then: 103 | 1 == exchanges?.size() // wrong number of exchanges 104 | 'my.fanout' == exchanges[0].name // wrong exchange name 105 | FanoutExchange == exchanges[0].type // wrong exchange type 106 | true == exchanges[0].durable // exchange is not durable 107 | null == exchanges[0].autoDelete // exchange has auto-delete set 108 | null == exchanges[0].arguments // no arguments expected 109 | 110 | when: 111 | def queues = builder.queues 112 | then: 113 | 1 == queues?.size() // wrong number of queues 114 | 'foo' == queues[0].name // wrong queue name 115 | false == queues[0].durable // wrong durable value 116 | true == queues[0].autoDelete // wrong auto delete value 117 | true == queues[0].exclusive // wrong exclusive value 118 | null == queues[0].arguments // no arguments expected 119 | 120 | when: 121 | def bindings = builder.bindings 122 | then: 123 | 1 == bindings?.size() // wrong number of bindings 124 | 'my.fanout' == bindings[0].exchange // wrong exchange bound 125 | 'foo' == bindings[0].queue // wrong queue bound 126 | '' == bindings[0].rule // binding is set 127 | null == bindings[0].arguments // no arguments expected 128 | } 129 | 130 | void testStandaloneFanoutExchangeDefinition() { 131 | when: 132 | def closure = { 133 | exchange name: 'non.durable.fanout', type: fanout, durable: false, autoDelete: true 134 | } 135 | 136 | def builder = new RabbitQueueBuilder() 137 | 138 | closure.delegate = builder 139 | closure() 140 | 141 | def exchanges = builder.exchanges 142 | 143 | then: 144 | 1 == exchanges?.size() //wrong number of exchanges 145 | 'non.durable.fanout' == exchanges[0].name // wrong exchange name 146 | FanoutExchange == exchanges[0].type // wrong exchange type 147 | false == exchanges[0].durable // exchange is durable 148 | true == exchanges[0].autoDelete // exchange does not have auto-delete set 149 | null == exchanges[0].arguments // no arguments expected 150 | 0 == builder.queues?.size() // wrong number of queues 151 | 0 == builder.bindings?.size() // wrong number of bindings 152 | } 153 | 154 | void testTopicExchangeDefinition() { 155 | when: 156 | def closure = { 157 | exchange name: 'my.topic', type: topic, durable: false, { 158 | foo durable: true, binding: 'shares.#' 159 | bar durable: false, autoDelete: true, binding: 'shares.nyse.?' 160 | } 161 | } 162 | 163 | def builder = new RabbitQueueBuilder() 164 | 165 | closure.delegate = builder 166 | closure() 167 | 168 | def exchanges = builder.exchanges 169 | 170 | then: 171 | 1 == exchanges?.size() // wrong number of exchanges 172 | 'my.topic' == exchanges[0].name // wrong exchange name 173 | TopicExchange == exchanges[0].type // wrong exchange type 174 | false == exchanges[0].durable // exchange is durable 175 | null == exchanges[0].autoDelete // exchange has auto-delete set 176 | null == exchanges[0].arguments // no arguments expected 177 | 178 | when: 179 | def queues = builder.queues 180 | 181 | then: 182 | 2 == queues?.size() // wrong number of queues 183 | 'foo' == queues[0].name // wrong queue name 184 | true == queues[0].durable // wrong durable value 185 | false == queues[0].autoDelete // queue is auto delete 186 | false == queues[0].exclusive // queue is exclusive 187 | null == queues[0].arguments // no arguments expected 188 | 'bar' == queues[1].name // wrong queue name 189 | false == queues[1].durable // wrong durable value 190 | true == queues[1].autoDelete // queue is not auto delete 191 | false == queues[1].exclusive // queue is exclusive 192 | null == queues[1].arguments // no arguments expected 193 | 194 | when: 195 | def bindings = builder.bindings 196 | 197 | then: 198 | 2 == bindings?.size() // wrong number of bindings 199 | 'my.topic' == bindings[0].exchange // wrong exchange bound 200 | 'foo' == bindings[0].queue // wrong queue bound 201 | 'shares.#' == bindings[0].rule // wrong binding rule 202 | 'my.topic' == bindings[1].exchange // wrong exchange bound 203 | 'bar' == bindings[1].queue // wrong queue bound 204 | 'shares.nyse.?' == bindings[1].rule // wrong binding rule 205 | null == bindings[0].arguments // no arguments expected 206 | } 207 | 208 | void testStandaloneTopicExchangeDefinition() { 209 | when: 210 | def closure = { 211 | exchange name: 'another.topic', type: topic 212 | } 213 | 214 | def builder = new RabbitQueueBuilder() 215 | 216 | closure.delegate = builder 217 | closure() 218 | 219 | def exchanges = builder.exchanges 220 | 221 | then: 222 | 1 == exchanges?.size() // wrong number of exchanges 223 | 'another.topic' == exchanges[0].name // wrong exchange name 224 | TopicExchange == exchanges[0].type // wrong exchange type 225 | null == exchanges[0].durable // durable is set 226 | null == exchanges[0].autoDelete // auto delete is set 227 | 228 | 0 == builder.queues?.size() // wrong number of queues 229 | 0 == builder.bindings?.size() // wrong number of bindings 230 | } 231 | 232 | void testTopicExchangeDefinitionWithNoBinding() { 233 | when: 234 | def closure = { 235 | exchange name: 'bad.topic', type: topic, { 236 | foo durable: false, exclusive: true 237 | } 238 | } 239 | 240 | def builder = new RabbitQueueBuilder() 241 | 242 | closure.delegate = builder 243 | 244 | def msg = shouldFail(RuntimeException) { 245 | closure() 246 | } 247 | 248 | then: 249 | msg.contains("queue 'foo'") // wrong exception message 250 | msg.contains("exchange 'bad.topic'") // wrong exception message 251 | msg.contains("must be declared") // wrong exception message 252 | } 253 | 254 | void testTopicExchangeDefinitionWithInvalidBinding() { 255 | when: 256 | def closure = { 257 | exchange name: 'bad.topic', type: topic, { 258 | foo durable: false, exclusive: true, binding: [key: 'shares.#'] 259 | } 260 | } 261 | 262 | def builder = new RabbitQueueBuilder() 263 | 264 | closure.delegate = builder 265 | 266 | def msg = shouldFail(RuntimeException) { 267 | closure() 268 | } 269 | 270 | then: 271 | msg.contains("queue 'foo'") // wrong exception message 272 | msg.contains("exchange 'bad.topic'") // wrong exception message 273 | msg.contains("must be a string") // wrong exception message 274 | } 275 | 276 | void testDirectExchangeDefinitionWithImplicitBinding() { 277 | when: 278 | def closure = { 279 | exchange name: 'my.direct', type: direct, durable: true, { 280 | foo autoDelete: true, durable: false, exclusive: true 281 | } 282 | } 283 | 284 | def builder = new RabbitQueueBuilder() 285 | 286 | closure.delegate = builder 287 | closure() 288 | 289 | def exchanges = builder.exchanges 290 | 291 | then: 292 | 1 == exchanges?.size() // wrong number of exchanges 293 | 'my.direct' == exchanges[0].name // wrong exchange name 294 | DirectExchange == exchanges[0].type // wrong exchange type 295 | true == exchanges[0].durable // exchange is not durable 296 | null == exchanges[0].autoDelete // exchange has auto-delete set 297 | null == exchanges[0].arguments // no arguments expected 298 | 299 | when: 300 | def queues = builder.queues 301 | 302 | then: 303 | 1 == queues?.size() // wrong number of queues 304 | 'foo' == queues[0].name // wrong queue name 305 | false == queues[0].durable // wrong durable value 306 | true == queues[0].autoDelete // wrong auto delete value 307 | true == queues[0].exclusive // wrong exclusive value 308 | null == queues[0].arguments // no arguments expected 309 | 310 | when: 311 | def bindings = builder.bindings 312 | 313 | then: 314 | 1 == bindings?.size() // wrong number of bindings 315 | 'my.direct' == bindings[0].exchange // wrong exchange bound 316 | 'foo' == bindings[0].queue // wrong queue bound 317 | 'foo' == bindings[0].rule // binding is wrong 318 | null == bindings[0].arguments // no arguments expected 319 | } 320 | 321 | void testDirectExchangeDefinitionWithExplicitBinding() { 322 | when: 323 | def closure = { 324 | exchange name: 'my.direct', type: direct, durable: true, { 325 | foo autoDelete: true, durable: false, exclusive: true, binding: 'shares.nyse.vmw' 326 | } 327 | } 328 | 329 | def builder = new RabbitQueueBuilder() 330 | 331 | closure.delegate = builder 332 | closure() 333 | 334 | def exchanges = builder.exchanges 335 | 336 | then: 337 | 1 == exchanges?.size() // wrong number of exchanges 338 | 'my.direct' == exchanges[0].name // wrong exchange name 339 | DirectExchange == exchanges[0].type // wrong exchange type 340 | true == exchanges[0].durable // exchange is not durable 341 | null == exchanges[0].autoDelete // exchange has auto-delete set 342 | null == exchanges[0].arguments // no arguments expected 343 | 344 | when: 345 | def queues = builder.queues 346 | 347 | then: 348 | 1 == queues?.size() // wrong number of queues 349 | 'foo' == queues[0].name // wrong queue name 350 | false == queues[0].durable // wrong durable value 351 | true == queues[0].autoDelete // wrong auto delete value 352 | true == queues[0].exclusive // wrong exclusive value 353 | null == queues[0].arguments // no arguments expected 354 | 355 | when: 356 | def bindings = builder.bindings 357 | 358 | then: 359 | 1 == bindings?.size() // wrong number of bindings 360 | 'my.direct' == bindings[0].exchange // wrong exchange bound 361 | 'foo' == bindings[0].queue // wrong queue bound 362 | 'shares.nyse.vmw' == bindings[0].rule // binding is wrong 363 | null == bindings[0].arguments // no arguments expected 364 | } 365 | 366 | void testStandaloneDirectExchangeDefinition() { 367 | when: 368 | def closure = { 369 | exchange name: 'my.direct', type: direct, durable: false, autoDelete: true 370 | } 371 | 372 | def builder = new RabbitQueueBuilder() 373 | 374 | closure.delegate = builder 375 | closure() 376 | 377 | def exchanges = builder.exchanges 378 | 379 | then: 380 | 1 == exchanges?.size() // wrong number of exchanges 381 | 'my.direct' == exchanges[0].name // wrong exchange name 382 | DirectExchange == exchanges[0].type // wrong exchange type 383 | false == exchanges[0].durable // exchange is durable 384 | true == exchanges[0].autoDelete // exchange does not have auto-delete set 385 | null == exchanges[0].arguments // no arguments expected 386 | 387 | 0 == builder.queues?.size() // wrong number of queues 388 | 0 == builder.bindings?.size() // wrong number of bindings 389 | } 390 | 391 | void testDirectExchangeDefinitionWithInvalidBinding() { 392 | when: 393 | def closure = { 394 | exchange name: 'bad.direct', type: direct, { 395 | foo durable: false, exclusive: true, binding: [key: 'shares.#'] 396 | } 397 | } 398 | 399 | def builder = new RabbitQueueBuilder() 400 | 401 | closure.delegate = builder 402 | 403 | def msg = shouldFail(RuntimeException) { 404 | closure() 405 | } 406 | 407 | then: 408 | msg.contains("queue 'foo'") // wrong exception message 409 | msg.contains("exchange 'bad.direct'") // wrong exception message 410 | msg.contains("must be a string") // wrong exception message 411 | } 412 | } 413 | -------------------------------------------------------------------------------- /travis-build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e 3 | rm -rf *.zip 4 | ./gradlew clean check jar 5 | 6 | 7 | #EXIT_STATUS=0 8 | #echo "Publishing archives for branch $TRAVIS_BRANCH" 9 | #if [[ -n $TRAVIS_TAG ]] || [[ $TRAVIS_BRANCH == 'master' && $TRAVIS_PULL_REQUEST == 'false' ]]; then 10 | # 11 | # echo "Publishing archives" 12 | # 13 | # if [[ -n $TRAVIS_TAG ]]; then 14 | # ./gradlew bintrayUpload || EXIT_STATUS=$? 15 | # else 16 | # ./gradlew publish || EXIT_STATUS=$? 17 | # fi 18 | # 19 | #fi 20 | 21 | #exit $EXIT_STATUS 22 | --------------------------------------------------------------------------------

Grails Runtime Exception

Error Details

Stack Trace

Application Status

Artefacts

Installed Plugins

Welcome to Grails

Available Controllers: