├── gradle
    ├── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
    ├── dependencies.gradle
    ├── codenarc.gradle
    ├── checkstyle
    │   ├── suppressions.xml
    │   ├── required-header.txt
    │   └── checkstyle.xml
    ├── pom.gradle
    ├── checkstyle.gradle
    ├── javaModule.gradle
    └── codenarc
    │   ├── codenarc.groovy
    │   └── codenarcTest.groovy
├── .gitignore
├── examples
    └── spring-capgemini-trace-sample
    │   ├── src
    │       └── main
    │       │   ├── resources
    │       │       ├── addVideo.json
    │       │       ├── data.sql
    │       │       └── config
    │       │       │   └── application.properties
    │       │   └── java
    │       │       └── com
    │       │           └── capgemini
    │       │               └── boot
    │       │                   └── trace
    │       │                       └── sample
    │       │                           └── video
    │       │                               ├── repository
    │       │                                   ├── VideoRepository.java
    │       │                                   └── Video.java
    │       │                               ├── Application.java
    │       │                               ├── client
    │       │                                   └── VideoSvcApi.java
    │       │                               └── controller
    │       │                                   └── VideoSvc.java
    │   ├── build.gradle
    │   └── README.md
├── settings.gradle
├── spring-capgemini-core
    ├── build.gradle
    └── src
    │   ├── test
    │       └── groovy
    │       │   └── com
    │       │       └── capgemini
    │       │           └── boot
    │       │               └── core
    │       │                   ├── TestSettingBackedBean.java
    │       │                   ├── TestApplication.java
    │       │                   ├── TestFactory.java
    │       │                   ├── TestSettings.java
    │       │                   └── SettingBackedBeanCreationSpec.groovy
    │   └── main
    │       └── java
    │           └── com
    │               └── capgemini
    │                   └── boot
    │                       └── core
    │                           └── factory
    │                               ├── internal
    │                                   ├── SettingBackedBeansConfiguration.java
    │                                   ├── ExceptionFactory.java
    │                                   ├── SpringBootSettingsResolver.java
    │                                   ├── DefaultAnnotationStrategy.java
    │                                   ├── DefaultExceptionFactory.java
    │                                   └── SettingBackedBeanFactoryPostProcessor.java
    │                               ├── SettingBackedBeanFactory.java
    │                               ├── SettingBackedBean.java
    │                               ├── EnableSettingBackedBeans.java
    │                               ├── SettingsResolver.java
    │                               └── FactoryProcessorStrategy.java
├── circle.yml
├── spring-capgemini-trace
    ├── build.gradle
    └── src
    │   ├── main
    │       └── java
    │       │   └── com
    │       │       └── capgemini
    │       │           └── boot
    │       │               └── trace
    │       │                   ├── annotation
    │       │                       ├── Trace.java
    │       │                       └── EnableTraceLogger.java
    │       │                   ├── TraceLoggerConfigurationUtils.java
    │       │                   ├── TraceLoggerConfiguration.java
    │       │                   ├── TraceLoggerRegistrar.java
    │       │                   └── settings
    │       │                       └── TraceLoggerSettings.java
    │   └── test
    │       └── groovy
    │           └── com
    │               └── capgemini
    │                   └── boot
    │                       └── trace
    │                           ├── TraceLoggerConfigurationDisabledSpec.groovy
    │                           ├── TraceLoggerRegistrarPointcutCrossoverSpec.groovy
    │                           ├── TestApplication.java
    │                           ├── TraceLoggerRegistrarSpec.groovy
    │                           ├── TraceLoggerConfigurationMessagesSpec.groovy
    │                           └── TraceLoggerConfigurationSpec.groovy
├── README.md
├── gradlew.bat
├── gradlew
└── LICENSE


/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Capgemini/spring-boot-capgemini/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | .classpath
 3 | .settings
 4 | .project
 5 | .gradle
 6 | build/
 7 | bin/
 8 | out/
 9 | *.iml
10 | *.ipr
11 | *.iws
12 | *.idea
13 | gradle.properties


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/resources/addVideo.json:
--------------------------------------------------------------------------------
1 | {"id":0,"name":"The Dark Knight","url":"http://www.imdb.com/title/tt0468569/?ref_=chttp_tt_4","duration":152}


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include \
2 |     "spring-capgemini-core",
3 |     "spring-capgemini-trace",
4 |     "spring-capgemini-trace-sample"
5 | 
6 | project(':spring-capgemini-trace-sample').projectDir = new File('examples/spring-capgemini-trace-sample/')
7 | 


--------------------------------------------------------------------------------
/gradle/dependencies.gradle:
--------------------------------------------------------------------------------
 1 | ext {
 2 |     commonVersions = [
 3 |         springBoot: "1.2.2.RELEASE",
 4 |         spock: "1.0-groovy-2.4",
 5 |     ]
 6 | 
 7 |     commonDependencies = [
 8 |         spockSpring: "org.spockframework:spock-spring:${commonVersions.spock}"
 9 |     ]
10 | }
11 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Fri Dec 05 14:27:21 GMT 2014
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.4-all.zip
7 | 


--------------------------------------------------------------------------------
/gradle/codenarc.gradle:
--------------------------------------------------------------------------------
 1 | project.apply plugin: "codenarc"
 2 | 
 3 | codenarc {
 4 |     toolVersion = "0.23"
 5 | }
 6 | 
 7 | codenarcMain {
 8 |     configFile rootProject.file('gradle/codenarc/codenarc.groovy')
 9 | }
10 | 
11 | codenarcTest {
12 |     configFile rootProject.file('gradle/codenarc/codenarcTest.groovy')
13 | }


--------------------------------------------------------------------------------
/gradle/checkstyle/suppressions.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | 
 3 | <!DOCTYPE suppressions PUBLIC
 4 |     "-//Puppy Crawl//DTD Suppressions 1.1//EN"
 5 |     "http://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
 6 | 
 7 | <suppressions>
 8 | 
 9 |   <suppress checks="RegexpHeader" files=".*MimeParse.java"/>
10 | 
11 | </suppressions>


--------------------------------------------------------------------------------
/spring-capgemini-core/build.gradle:
--------------------------------------------------------------------------------
 1 | archivesBaseName = 'spring-capgemini-core'
 2 | description = "spring-capgemini-core"
 3 | 
 4 | apply from: "$rootDir/gradle/javaModule.gradle"
 5 | 
 6 | dependencies {
 7 | 	compile "org.springframework.boot:spring-boot-starter:${commonVersions.springBoot}"
 8 | 	
 9 |     testCompile "org.springframework.boot:spring-boot-starter-test:${commonVersions.springBoot}"
10 | }


--------------------------------------------------------------------------------
/circle.yml:
--------------------------------------------------------------------------------
 1 | 
 2 | dependencies:
 3 |   cache_directories:
 4 |     - "~/.gradle"
 5 | 
 6 | test:
 7 |  override:
 8 |    - ./gradlew clean build -i
 9 |  pre:
10 |    - echo $BINTRAY_USER > gradle.properties
11 |    - echo $BINTRAY_API_KEY >> gradle.properties
12 |  post:
13 |    - mkdir -p $CIRCLE_TEST_REPORTS/junit/
14 |    - find . -type f -regex ".*/build/test-results/.*xml" -exec cp {} $CIRCLE_TEST_REPORTS/junit/ \;
15 | 
16 | deployment:
17 |   master:
18 |     branch: master
19 |     commands:
20 |       - ./gradlew artifactoryPublish


--------------------------------------------------------------------------------
/spring-capgemini-trace/build.gradle:
--------------------------------------------------------------------------------
 1 | archivesBaseName = 'trace-spring-boot'
 2 | description = "trace-spring-boot"
 3 | 
 4 | apply from: "$rootDir/gradle/javaModule.gradle"
 5 | 
 6 | dependencies {
 7 |     compile "org.springframework.boot:spring-boot-starter-aop:${commonVersions.springBoot}"
 8 |     compile project(":spring-capgemini-core")
 9 |     
10 |     testCompile "org.springframework.boot:spring-boot-starter-test:${commonVersions.springBoot}"
11 |     testCompile("org.springframework.boot:spring-boot-starter-web:${commonVersions.springBoot}") {
12 |         exclude module: "spring-boot-starter-tomcat"
13 |     }
14 |     testCompile "org.springframework.boot:spring-boot-starter-jetty:${commonVersions.springBoot}"
15 | }


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/resources/data.sql:
--------------------------------------------------------------------------------
1 | -- This file is invoked by Spring boot by default, using Spring JDBC, more information 
2 | -- here (http://docs.spring.io/spring-boot/docs/current/reference/html/howto-database-initialization.html#howto-intialize-a-database-using-spring-jdbc) 
3 | insert into video (id, duration, name, url) values (1, 142, 'The Shawshank Redemption', 'http://www.imdb.com/title/tt0111161/?ref_=chttp_tt_1');
4 | insert into video (id, duration, name, url) values (2, 175, 'The Godfather', 'http://www.imdb.com/title/tt0068646/?ref_=chttp_tt_2');
5 | insert into video (id, duration, name, url) values (3, 200, 'The Godfather: Part II', 'http://www.imdb.com/title/tt0071562/?ref_=chttp_tt_3'); 


--------------------------------------------------------------------------------
/gradle/checkstyle/required-header.txt:
--------------------------------------------------------------------------------
 1 | ^/\*\s*$
 2 | ^\* Copyright \d\d\d\d((\s*-\s*\d\d\d\d)|(,\s*\d\d\d\d)+)? the original author or authors.\s*$
 3 | ^\*\s*$
 4 | ^\* Licensed under the Apache License, Version 2\.0 \(the "License"\);\s*$
 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 |  */


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/build.gradle:
--------------------------------------------------------------------------------
 1 | buildscript {
 2 |     dependencies {
 3 |         classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.3.RELEASE")
 4 |     }
 5 |     repositories {
 6 |         jcenter()
 7 |     }
 8 | }
 9 | 
10 | apply plugin: 'spring-boot'
11 | 
12 | dependencies {
13 |     compile "org.springframework.boot:spring-boot-starter-web:${commonVersions.springBoot}"
14 |     compile "org.springframework.boot:spring-boot-starter-actuator:${commonVersions.springBoot}"
15 |     compile "org.springframework.boot:spring-boot-starter-aop:${commonVersions.springBoot}"
16 |     compile "org.springframework.boot:spring-boot-starter-data-jpa:${commonVersions.springBoot}"
17 |     compile "com.h2database:h2:1.4.187"
18 |     compile "com.google.guava:guava:17.0"
19 |     compile project(":spring-capgemini-trace")
20 | 
21 |     runtime "org.springframework.boot:spring-boot-starter-jetty:${commonVersions.springBoot}"
22 | 
23 |     testCompile "org.springframework.boot:spring-boot-starter-test:${commonVersions.springBoot}"
24 | }
25 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/test/groovy/com/capgemini/boot/core/TestSettingBackedBean.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core;
18 | 
19 | public class TestSettingBackedBean {
20 |     
21 |     private String settingValue;
22 |     
23 |     TestSettingBackedBean(String settingValue) {
24 |         this.settingValue = settingValue;
25 |     }
26 |     
27 |     public String getSettingValue() {
28 |         return settingValue;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/gradle/pom.gradle:
--------------------------------------------------------------------------------
 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 | 
17 | ext {
18 |   pomModifications = []
19 |   modifyPom = { pomModifications << it }
20 | }
21 | 
22 | tasks.withType(Upload) {
23 |   repositories.withType(org.gradle.api.artifacts.maven.MavenResolver) {
24 |     it.pom.whenConfigured { pom ->
25 |       pomModifications.each {
26 |         configure(pom, it)
27 |       }
28 |     }
29 |   }
30 | }
31 | 
32 | modifyPom {
33 |   dependencies.removeAll { it.scope == "test" }
34 | }
35 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/resources/config/application.properties:
--------------------------------------------------------------------------------
 1 | # enables trace logging
 2 | trace-logging.enabled=true
 3 | 
 4 | # sets severity of logger to Trace for VideoSvc class.  The logger is "Logback", defined in "spring-boot-starter-logging" which 
 5 | # is pulled in as a transititve dependency by the "spring-boot-starter-web" dependency defined in grade.build
 6 | logging.level.com.capgemini.boot.trace.sample.video.controller.VideoSvc=TRACE
 7 | 
 8 | # enables tracing of all public methods in the VideoSvc class
 9 | trace-logging.pointcut.videoSvc=execution(* com.capgemini.boot.trace.sample.video.controller.VideoSvc.*(..))
10 | 
11 | # enables tracing of all public methods in VideoSvc class that take a String 
12 | # parameter -i.e the method "Collection<Video> findByTitle(String title)"
13 | #trace-logging.pointcut.test1=execution(* com.capgemini.boot.trace.sample.video.controller.VideoSvc.*(String))
14 | 
15 | # forces the use of CGLIB rather than JDK dynamic proxies, required as the target object (VideoSvc) implements an API
16 | #  see http://docs.spring.io/spring/docs/2.5.x/reference/aop.html#aop-proxying for more information
17 | spring.aop.proxyTargetClass=true


--------------------------------------------------------------------------------
/gradle/checkstyle.gradle:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2013 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 | 
17 | apply plugin: 'checkstyle'
18 | 
19 | def checkstyleConfigDir = new File(buildscript.sourceFile.parentFile, 'checkstyle')
20 | 
21 | checkstyle {
22 |   configFile = new File(checkstyleConfigDir, "checkstyle.xml")
23 |   configProperties.checkstyleConfigDir = checkstyleConfigDir
24 | }
25 | 
26 | def checkstyleTasks = tasks.withType(Checkstyle)
27 | 
28 | task checkstyle(dependsOn: checkstyleTasks)
29 | 
30 | check.dependsOn checkstyleTasks
31 | 
32 | tasks.withType(Test) {
33 |   mustRunAfter checkstyleTasks
34 | }
35 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Circle CI](https://circleci.com/gh/Capgemini/spring-boot-capgemini/tree/master.svg?style=svg&circle-token=9d20343e9806ad4e5ac6cae2b29c619ff8b28648)](https://circleci.com/gh/Capgemini/spring-boot-capgemini/tree/master)
 2 | 
 3 | [![Gitter Chat](http://img.shields.io/badge/chat-online-brightgreen.svg)](https://gitter.im/Capgemini/spring-boot-capgemini)
 4 | 
 5 | # Spring Boot - Capgemini
 6 | 
 7 | Spring Boot Capgemini includes a number of Spring Boot Starters that we have found useful whilst building real world Spring Boot applications at Capgemini.
 8 | 
 9 | Some of the Starters are integrations to technologies not currently provided out-of-the-box by Spring Boot, and are unlikely to ever be.  Some may naturally fit as core features and will hopefully one day be subsumed by the core project.  Others are just features we have found useful and hopefully you will too. 
10 | 
11 | ### Features
12 | * Trace logging - method entry and exit trace logging.
13 | 
14 | ## Core Developers
15 | * [Russell Hart](https://github.com/rhart)
16 | * [Greg Wolverson] (https://github.com/gwolverson)
17 | * [Craig Williams] (https://github.com/craigwilliams84)
18 | * [Gareth Sullivan](https://github.com/sinsir)
19 | 
20 | ##Contributors
21 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/main/java/com/capgemini/boot/trace/annotation/Trace.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.annotation;
17 | 
18 | import java.lang.annotation.ElementType;
19 | import java.lang.annotation.Retention;
20 | import java.lang.annotation.RetentionPolicy;
21 | import java.lang.annotation.Target;
22 | 
23 | /**
24 |  * Methods annotated with this annotation will be trace logged when TraceLogger is enabled
25 |  * for a spring-boot application.
26 |  */
27 | @Target({ElementType.TYPE, ElementType.METHOD})
28 | @Retention(RetentionPolicy.RUNTIME)
29 | public @interface Trace {
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/internal/SettingBackedBeansConfiguration.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory.internal;
18 | 
19 | import org.springframework.context.annotation.Bean;
20 | import org.springframework.context.annotation.ComponentScan;
21 | import org.springframework.context.annotation.Configuration;
22 | 
23 | @Configuration
24 | @ComponentScan
25 | public class SettingBackedBeansConfiguration {
26 |     
27 |     @Bean
28 |     public SettingBackedBeanFactoryPostProcessor settingsBackedBeanPostProcessor() {
29 |         return new SettingBackedBeanFactoryPostProcessor();
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/test/groovy/com/capgemini/boot/core/TestApplication.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core;
18 | 
19 | import org.springframework.boot.SpringApplication;
20 | import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
21 | import org.springframework.context.annotation.ComponentScan;
22 | 
23 | import com.capgemini.boot.core.factory.EnableSettingBackedBeans;
24 | 
25 | @EnableAutoConfiguration
26 | @EnableSettingBackedBeans
27 | @ComponentScan
28 | public class TestApplication {
29 |     
30 |     public static void main(String[] args) throws Exception {
31 |         SpringApplication.run(TestApplication.class, args);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/internal/ExceptionFactory.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory.internal;
18 | 
19 | import java.lang.reflect.Method;
20 | 
21 | /**
22 |  * Factory for creating exceptions.
23 |  *
24 |  */
25 | public interface ExceptionFactory {
26 |     RuntimeException createInvalidArgumentsException(Method method);
27 |     
28 |     RuntimeException createNoMatchingSettingException(String property);
29 |     
30 |     RuntimeException createSettingAccessException(String property);
31 |     
32 |     RuntimeException createSettingArgumentsException(String property);
33 |     
34 |     RuntimeException createGenericException(String message, Throwable cause);
35 | }
36 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/SettingBackedBeanFactory.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory;
18 | 
19 | import org.springframework.stereotype.Component;
20 | 
21 | import java.lang.annotation.ElementType;
22 | import java.lang.annotation.Retention;
23 | import java.lang.annotation.RetentionPolicy;
24 | import java.lang.annotation.Target;
25 | 
26 | /**
27 |  * A settings backed bean factory is a component that creates beans dependent on 
28 |  * settings within the spring environment.
29 |  * 
30 |  */
31 | @Target(ElementType.TYPE)
32 | @Retention(RetentionPolicy.RUNTIME)
33 | @Component
34 | public @interface SettingBackedBeanFactory {
35 |     Class<?> settingsClass();
36 |     
37 |     String settingPrefix();
38 | }
39 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/SettingBackedBean.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.core.factory;
17 | 
18 | import java.lang.annotation.ElementType;
19 | import java.lang.annotation.Retention;
20 | import java.lang.annotation.RetentionPolicy;
21 | import java.lang.annotation.Target;
22 | 
23 | /**
24 |  * A setting configured bean method registers beans that are dependent on 
25 |  * a specified setting.  If there are multiple setting instances (eg the setting
26 |  * is backed by a map/collection), then multiple beans will be registered for
27 |  * a single annotated method.
28 |  *
29 |  */
30 | @Target(ElementType.METHOD)
31 | @Retention(RetentionPolicy.RUNTIME)
32 | public @interface SettingBackedBean {
33 |     String setting();
34 |     
35 |     String beanNameSuffix();
36 | }
37 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/EnableSettingBackedBeans.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory;
18 | 
19 | import com.capgemini.boot.core.factory.internal.SettingBackedBeansConfiguration;
20 | import org.springframework.context.annotation.Import;
21 | 
22 | import java.lang.annotation.ElementType;
23 | import java.lang.annotation.Retention;
24 | import java.lang.annotation.RetentionPolicy;
25 | import java.lang.annotation.Target;
26 | 
27 | /**
28 |  * A settings backed bean factory is a component that creates beans dependent on 
29 |  * settings within the spring environment.
30 |  * 
31 |  */
32 | @Target(ElementType.TYPE)
33 | @Retention(RetentionPolicy.RUNTIME)
34 | @Import({SettingBackedBeansConfiguration.class})
35 | public @interface EnableSettingBackedBeans {
36 | }
37 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/SettingsResolver.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory;
18 | 
19 | import org.springframework.core.env.ConfigurableEnvironment;
20 | 
21 | /**
22 |  * Resolves a settings class instance.
23 |  *
24 |  */
25 | public interface SettingsResolver {
26 | 
27 |     /**
28 |      * Resolves an instance of a settings class of the specified type, with a property prefix.
29 |      *
30 |      * @param settingsClass The class type to resolve
31 |      * @param prefix The property prefix
32 |      * @param environment The environment
33 |      * @param <T> the setting class
34 |      * @return The resolved settings class instance
35 |      */
36 |     <T> T resolveSettings(Class<T> settingsClass, String prefix, ConfigurableEnvironment environment);
37 | }
38 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/main/java/com/capgemini/boot/trace/annotation/EnableTraceLogger.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.annotation;
17 | 
18 | import com.capgemini.boot.trace.TraceLoggerConfiguration;
19 | import com.capgemini.boot.trace.TraceLoggerRegistrar;
20 | import org.springframework.context.annotation.Import;
21 | 
22 | import java.lang.annotation.ElementType;
23 | import java.lang.annotation.Retention;
24 | import java.lang.annotation.RetentionPolicy;
25 | import java.lang.annotation.Target;
26 | 
27 | /**
28 |  * Trace logging will be enabled for spring-boot applications that enable this annotation.
29 |  */
30 | @Target(ElementType.TYPE)
31 | @Retention(RetentionPolicy.RUNTIME)
32 | @Import({TraceLoggerConfiguration.class, TraceLoggerRegistrar.class})
33 | public @interface EnableTraceLogger {
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/java/com/capgemini/boot/trace/sample/video/repository/VideoRepository.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.sample.video.repository;
17 | 
18 | import org.springframework.data.repository.CrudRepository;
19 | import org.springframework.stereotype.Repository;
20 | 
21 | import java.util.Collection;
22 | 
23 | /**
24 |  * An interface for a repository that can store Video objects and allow them to
25 |  * be searched by title.
26 |  */
27 | @Repository
28 | public interface VideoRepository extends CrudRepository<Video, Long> {
29 | 
30 |     /**
31 |      * Find all videos with a matching title
32 |      * 
33 |      * @param title video title (e.g., Video.name)
34 |      * @return Collection of matching Video objects
35 |      */
36 |     Collection<Video> findByName(String title);
37 | 
38 | }
39 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/java/com/capgemini/boot/trace/sample/video/Application.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.sample.video;
17 | 
18 | import com.capgemini.boot.trace.annotation.EnableTraceLogger;
19 | import com.capgemini.boot.trace.sample.video.repository.VideoRepository;
20 | import org.springframework.boot.SpringApplication;
21 | import org.springframework.boot.autoconfigure.SpringBootApplication;
22 | import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
23 | 
24 | 
25 | // Tell Spring to automatically create a JPA implementation of VideoRepository
26 | @EnableJpaRepositories(basePackageClasses = VideoRepository.class)
27 | // This is a convenience annotation that is equivalent to declaring @Configuration, @EnableAutoConfiguration and @ComponentScan.
28 | @SpringBootApplication
29 | // Enable configurable logging of method entry/exit points
30 | @EnableTraceLogger
31 | public class Application {
32 |     public static void main(String[] args) {
33 |         SpringApplication.run(Application.class, args);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/test/groovy/com/capgemini/boot/core/TestFactory.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core;
18 | 
19 | import com.capgemini.boot.core.factory.SettingBackedBean;
20 | import com.capgemini.boot.core.factory.SettingBackedBeanFactory;
21 | 
22 | @SettingBackedBeanFactory(settingsClass = TestSettings.class, settingPrefix = TestSettings.SETTINGS_PREFIX)
23 | public class TestFactory {
24 |     
25 |     @SettingBackedBean(setting = "settingMap", beanNameSuffix = "FromMap")
26 |     public TestSettingBackedBean createSettingBackedBeanWithMap(String settingValue) {
27 |         return new TestSettingBackedBean(settingValue);
28 |     }
29 |     
30 |     @SettingBackedBean(setting = "settingList", beanNameSuffix = "FromList")
31 |     public TestSettingBackedBean createSettingBackedBeanWithList(String settingValue) {
32 |         return new TestSettingBackedBean(settingValue);
33 |     }
34 |     
35 |     @SettingBackedBean(setting = "singleSetting", beanNameSuffix = "singleSettingBean")
36 |     public TestSettingBackedBean createSettingBackedBeanFromSingleSetting(String settingValue) {
37 |         return new TestSettingBackedBean(settingValue);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/test/groovy/com/capgemini/boot/core/TestSettings.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core;
18 | 
19 | import java.util.ArrayList;
20 | import java.util.HashMap;
21 | import java.util.List;
22 | import java.util.Map;
23 | 
24 | import org.springframework.boot.context.properties.ConfigurationProperties;
25 | import org.springframework.stereotype.Component;
26 | 
27 | @Component
28 | @ConfigurationProperties(prefix = TestSettings.SETTINGS_PREFIX)
29 | public class TestSettings {
30 |     public static final String SETTINGS_PREFIX = "test-settings";
31 |     
32 |     private Map<String, String> settingMap = new HashMap<String, String>();
33 |     
34 |     private List<String> settingList = new ArrayList<String>();
35 |     
36 |     private String singleSetting;
37 |     
38 |     public Map<String, String> getSettingMap() {
39 |         return settingMap;
40 |     }
41 |     
42 |     public List<String> getSettingList() {
43 |         return settingList;
44 |     }
45 |     
46 |     public String getSingleSetting() {
47 |         return singleSetting;
48 |     }
49 |     
50 |     public void setSingleSetting(String value) {
51 |         singleSetting = value;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/internal/SpringBootSettingsResolver.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory.internal;
18 | 
19 | import com.capgemini.boot.core.factory.SettingsResolver;
20 | import org.springframework.beans.FatalBeanException;
21 | import org.springframework.boot.bind.PropertiesConfigurationFactory;
22 | import org.springframework.core.env.ConfigurableEnvironment;
23 | 
24 | public class SpringBootSettingsResolver implements SettingsResolver {
25 | 
26 |     @SuppressWarnings("unchecked")
27 |     @Override
28 |     public <T> T resolveSettings(Class<T> settingsClass, String prefix, ConfigurableEnvironment environment) {
29 |         try {
30 |             T newSettings = (T) Class.forName(settingsClass.getName()).newInstance();
31 |     
32 |             PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(newSettings);
33 |             factory.setTargetName(prefix);
34 |             factory.setPropertySources(environment.getPropertySources());
35 |             factory.setConversionService(environment.getConversionService());
36 |             factory.bindPropertiesToTarget();
37 |     
38 |             return newSettings;
39 |         } catch (Exception ex) {
40 |             throw new FatalBeanException("Could not bind DataSourceSettings properties", ex);
41 |         }
42 |     }
43 | 
44 | }
45 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/main/java/com/capgemini/boot/trace/TraceLoggerConfigurationUtils.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace;
17 | 
18 | import com.capgemini.boot.trace.settings.TraceLoggerSettings;
19 | import org.springframework.aop.interceptor.AbstractTraceInterceptor;
20 | import org.springframework.aop.interceptor.CustomizableTraceInterceptor;
21 | 
22 | /**
23 |  * Utility methods for trace logger configuration.
24 |  *
25 |  */
26 | public final class TraceLoggerConfigurationUtils {
27 | 
28 |     /**
29 |      * Private constructor as this class provides static methods only
30 |      */
31 |     private TraceLoggerConfigurationUtils() { }
32 | 
33 |     /**
34 |      * Creates a trace interceptor for logging entry into and exit from methods.
35 |      * @param settings the settings
36 |      * @return The created trace interceptor
37 |      */
38 |     public static AbstractTraceInterceptor createTraceInterceptor(TraceLoggerSettings settings) {
39 |         CustomizableTraceInterceptor customizableTraceInterceptor = new CustomizableTraceInterceptor();
40 |         customizableTraceInterceptor.setUseDynamicLogger(true);
41 |         customizableTraceInterceptor.setEnterMessage(settings.getMessage().getEnter());
42 |         customizableTraceInterceptor.setExitMessage(settings.getMessage().getExit());
43 |         customizableTraceInterceptor.setExceptionMessage(settings.getMessage().getException());
44 |         return customizableTraceInterceptor;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/gradle/javaModule.gradle:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2013 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 | 
17 | apply plugin: "groovy"
18 | apply from: "$rootDir/gradle/checkstyle.gradle"
19 | apply from: "$rootDir/gradle/codenarc.gradle"
20 | 
21 | dependencies {
22 |     testCompile commonDependencies.spockSpring
23 | }
24 | 
25 | sourceCompatibility = "1.7"
26 | targetCompatibility = "1.7"
27 | 
28 | tasks.withType(AbstractCompile) {
29 |     options.compilerArgs << "-Werror" << "-Xlint:all" << "-Xlint:-options" << "-Xlint:-serial"
30 |     options.compilerArgs << "-Xlint:-classfile" // Needed due to https://issues.jboss.org/browse/JASSIST-245
31 | }
32 | 
33 | task sourceJar(type: Jar) {
34 |     description "An archive of the source code for Maven Central"
35 |     classifier "sources"
36 |     from sourceSets.main.allSource
37 | }
38 | 
39 | task javadocJar(type: Jar) {
40 |     description "An archive of the JavaDocs for Maven Central"
41 |     classifier "javadoc"
42 |     from javadoc
43 | }
44 | 
45 | artifacts {
46 |     archives javadocJar, sourceJar
47 | }
48 | 
49 | /*signing {
50 |   if (!isSnapshot) {
51 |     sign configurations.archives
52 |   }
53 | }*/
54 | 
55 | install {
56 |     repositories {
57 |         mavenDeployer {
58 |             repository(url: localRepoUrl)
59 |         }
60 |     }
61 | }
62 | 
63 | /*install.repositories["mavenInstaller"].beforeDeployment { deployment ->
64 |   if (!isSnapshot) {
65 |     artifacts {
66 |       signatures signing.signPom(deployment)
67 |     }
68 |   }
69 | }*/
70 | 
71 | task codeQuality {
72 |     dependsOn tasks.withType(CodeNarc), tasks.withType(Checkstyle)
73 | }
74 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/java/com/capgemini/boot/trace/sample/video/client/VideoSvcApi.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.sample.video.client;
17 | 
18 | import com.capgemini.boot.trace.sample.video.repository.Video;
19 | 
20 | import java.util.Collection;
21 | 
22 | /**
23 |  * Defines an API for a Video service. The interface is used to
24 |  * provide a contract for client/server interactions. 
25 |  */
26 | public interface VideoSvcApi {
27 |     
28 |     /** the title parameter used in the REST-ful URL for finding a video by its title */ 
29 |     String TITLE_PARAMETER = "title";
30 | 
31 |     /** The path used to access the VideoSvc controller */
32 |     String VIDEO_SVC_PATH = "/video";
33 | 
34 |     /** The path used to access the find method on the VideoSvc controller */
35 |     String VIDEO_TITLE_SEARCH_PATH = VIDEO_SVC_PATH + "/find";
36 | 
37 |     
38 |     /**
39 |      * Returns the current list of videos.  Returns an empty collection if no videos exist 
40 |      * 
41 |      * @return the collection of Video objects
42 |      */
43 |     Collection<Video> getVideoList();
44 | 
45 |     
46 |     /**                                               
47 |      * Adds the specified video to the list of videos.
48 |      * 
49 |      * @param video the Video to add to the list
50 |      * @return true if video was added successfully, false otherwise
51 |      */
52 |     boolean addVideo(Video video);
53 |     
54 |     /**
55 |      * Returns a collection of videos matching the specified title.
56 |      * Returns an empty collection if no videos are matched
57 |      * 
58 |      * @param title the title of the video to search for
59 |      * @return the collection of video objects
60 |      */
61 |     Collection<Video> findByTitle(String title);
62 | }
63 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/test/groovy/com/capgemini/boot/trace/TraceLoggerConfigurationDisabledSpec.groovy:
--------------------------------------------------------------------------------
 1 | package com.capgemini.boot.trace
 2 | 
 3 | import org.springframework.beans.factory.annotation.Value
 4 | import org.springframework.boot.test.SpringApplicationContextLoader
 5 | import org.springframework.boot.test.TestRestTemplate
 6 | import org.springframework.boot.test.WebIntegrationTest
 7 | import org.springframework.test.context.ContextConfiguration
 8 | import org.springframework.web.client.RestTemplate
 9 | import spock.lang.Specification
10 | 
11 | /*
12 |  * NOTE: This could hopefully be moved into TraceLoggerConfigurationSpec once dynamic
13 |  * properties functionality has been implemented.
14 |  */
15 | @ContextConfiguration(loader = SpringApplicationContextLoader, classes = TestApplication)
16 | @WebIntegrationTest(["logging.level.com.capgemini.boot.trace.TestApplication=TRACE", "server.port=0", 
17 |                      "trace-logging.enabled=false",
18 |                      "trace-logging.pointcut.test1=execution(* getMessageWithoutAnnotation())"])
19 | class TraceLoggerConfigurationDisabledSpec extends Specification {
20 | 
21 |     @Value('${local.server.port}')
22 |     int serverPort
23 | 
24 |     RestTemplate restTemplate = new TestRestTemplate()
25 |     
26 |     def "methods aren't traced when disabled"() {
27 |         given:
28 |         def output = new ByteArrayOutputStream()
29 | 
30 |         def origOut = System.out
31 |         System.out = new PrintStream(output, true)
32 | 
33 |         when:
34 |         restTemplate.getForEntity("http://localhost:$serverPort", String)
35 | 
36 |         then:
37 |         !output.toString().contains("Entering getMessageWithAnnotation()")
38 |         !output.toString().contains("Leaving  getMessageWithAnnotation(), returned Hello World!")
39 | 
40 |         cleanup:
41 |         System.out = origOut
42 |     }
43 |     
44 |     def "method matching pointcut is not traced when disabled"() {
45 |         given:
46 |         def output = new ByteArrayOutputStream()
47 | 
48 |         def origOut = System.out
49 |         System.out = new PrintStream(output, true)
50 | 
51 |         when:
52 |         restTemplate.getForEntity("http://localhost:$serverPort/nonAnnotated", String)
53 | 
54 |         then:
55 |         !output.toString().contains("Entering getMessageWithoutAnnotation()")
56 |         !output.toString().contains("Leaving  getMessageWithoutAnnotation(), returned Hello Non Annotated World!")
57 | 
58 |         cleanup:
59 |         System.out = origOut
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/test/groovy/com/capgemini/boot/trace/TraceLoggerRegistrarPointcutCrossoverSpec.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace
17 | 
18 | import org.springframework.beans.factory.annotation.Autowired
19 | import org.springframework.beans.factory.annotation.Value
20 | import org.springframework.boot.test.SpringApplicationContextLoader
21 | import org.springframework.boot.test.TestRestTemplate
22 | import org.springframework.boot.test.WebIntegrationTest
23 | import org.springframework.context.ApplicationContext
24 | import org.springframework.test.context.ContextConfiguration
25 | import org.springframework.web.client.RestTemplate
26 | import spock.lang.Specification
27 | 
28 | @ContextConfiguration(loader = SpringApplicationContextLoader, classes = TestApplication)
29 | @WebIntegrationTest(["logging.level.com.capgemini.boot.trace.TestApplication=TRACE",
30 | 					 "server.port=0",
31 | 					 "trace-logging.pointcut.test1=execution(* getMessageWithoutAnnotation())",
32 |                      "trace-logging.pointcut.test2=execution(* getMessageWithoutAnnotation())"])
33 | class TraceLoggerRegistrarPointcutCrossoverSpec extends Specification {
34 | 
35 |     @Value('${local.server.port}')
36 |     int serverPort
37 | 
38 | 	@Autowired
39 | 	ApplicationContext context
40 | 
41 |     RestTemplate restTemplate = new TestRestTemplate()
42 | 
43 |     def "method matching multiple pointcuts is only traced once"() {
44 | 		given:
45 | 		def output = new ByteArrayOutputStream()
46 | 
47 | 		def origOut = System.out
48 | 		System.out = new PrintStream(output, true)
49 | 
50 | 		when:
51 | 		restTemplate.getForEntity("http://localhost:$serverPort/nonAnnotated", String)
52 | 
53 | 		then:
54 |         def expectedEnterMessage = "Entering getMessageWithoutAnnotation()"
55 |         def expectedExitMessage = "Leaving  getMessageWithoutAnnotation(), returned Hello Non Annotated World!"
56 | 		output.toString().contains(expectedEnterMessage)
57 | 		output.toString().contains(expectedExitMessage)
58 |         
59 |         //Check that there's only one instance of the trace log messages
60 |         output.toString().indexOf(expectedEnterMessage) == output.toString().lastIndexOf(expectedEnterMessage)
61 |         output.toString().indexOf(expectedExitMessage) == output.toString().lastIndexOf(expectedExitMessage)
62 |         
63 | 		cleanup:
64 | 		System.out = origOut
65 | 	}
66 | }
67 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/main/java/com/capgemini/boot/trace/TraceLoggerConfiguration.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace;
17 | 
18 | import com.capgemini.boot.core.factory.EnableSettingBackedBeans;
19 | import com.capgemini.boot.trace.settings.TraceLoggerSettings;
20 | import org.springframework.aop.Advisor;
21 | import org.springframework.aop.aspectj.AspectJExpressionPointcut;
22 | import org.springframework.aop.interceptor.AbstractTraceInterceptor;
23 | import org.springframework.aop.support.DefaultPointcutAdvisor;
24 | import org.springframework.beans.factory.annotation.Autowired;
25 | import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
26 | import org.springframework.boot.context.properties.EnableConfigurationProperties;
27 | import org.springframework.context.annotation.Bean;
28 | import org.springframework.context.annotation.ComponentScan;
29 | import org.springframework.context.annotation.Configuration;
30 | import org.springframework.context.annotation.EnableAspectJAutoProxy;
31 | 
32 | /**
33 |  * Configures basic trace logging for enabled spring-boot applications.
34 |  * 
35 |  * Methods annotated with the @Trace annotation will be traced.
36 |  */
37 | @Configuration
38 | @ComponentScan
39 | @EnableConfigurationProperties
40 | @EnableSettingBackedBeans
41 | @EnableAspectJAutoProxy
42 | //I would much rather call isEnabled from the settings bean in an expression here, but the bean isn't available
43 | @ConditionalOnProperty(prefix = TraceLoggerSettings.SETTINGS_PREFIX, value = TraceLoggerSettings.ENABLED_SETTING, matchIfMissing = true)
44 | public class TraceLoggerConfiguration {
45 | 
46 |     @Autowired
47 |     private TraceLoggerSettings settings;
48 |     
49 |     static final String TRACE_ANNOTATION = "@annotation(com.capgemini.boot.trace.annotation.Trace) or within(@com.capgemini.boot.trace.annotation.Trace *)";
50 | 
51 |     @Bean(name = "traceInterceptor")
52 |     public AbstractTraceInterceptor customizableTraceInterceptor() {
53 |         return TraceLoggerConfigurationUtils.createTraceInterceptor(settings);
54 |     }
55 | 
56 |     @Bean(name = "traceAnnotationAdvisor")
57 |     public Advisor traceAnnotationAdvisor() {
58 |         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
59 |         pointcut.setExpression(TRACE_ANNOTATION);
60 | 
61 |         return new DefaultPointcutAdvisor(pointcut, customizableTraceInterceptor());
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/FactoryProcessorStrategy.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory;
18 | 
19 | import org.springframework.context.ApplicationContext;
20 | 
21 | import java.lang.reflect.Method;
22 | 
23 | /**
24 |  * Strategy for the post processor, providing the logic for establishing if a
25 |  * class/method is a setting backed factory class/method, and obtaining the
26 |  * the configuration for these factories.
27 |  * 
28 |  */
29 | public interface FactoryProcessorStrategy {  
30 |     
31 |     /**
32 |      * Get all setting backed factory beans in the application.
33 |      * 
34 |      * @param context The application context
35 |      * @return The names of all setting backed factory beans
36 |      */
37 |     String[] getFactoryBeanNames(ApplicationContext context);
38 |     
39 |     /**
40 |      * Establish if a method is a setting backed bean factory method.
41 |      * 
42 |      * @param method The method
43 |      * @return True if the method is a setting backed bean factory method, false otherwise
44 |      */
45 |     boolean isFactoryMethod(Method method);
46 |     
47 |     /**
48 |      * Gets the class that defines the settings for specified the setting backed bean factory.
49 |      * 
50 |      * @param factoryClass The setting backed bean factory class
51 |      * @return The settings class
52 |      */
53 |     Class<?> getSettingsClass(Class<?> factoryClass);
54 |     
55 |     /**
56 |      * Gets the setting prefix for the specified factory class.
57 |      * 
58 |      * @param factoryClass The setting backed bean factory class
59 |      * @return The setting prefix
60 |      */
61 |     String getSettingPrefix(Class<?> factoryClass);
62 |     
63 |     /**
64 |      * The suffix that should be appending to the bean name for beans 
65 |      * created via the specified factory method.
66 |      * 
67 |      * @param factoryMethod The factory method
68 |      * @return The bean name suffix
69 |      */
70 |     String getBeanNameSuffix(Method factoryMethod);
71 |     
72 |     /**
73 |      * The setting name that beans created via the specified factory method should be backed by.
74 |      * 
75 |      * This should correspond to a getter method in the settings class.
76 |      * 
77 |      * @param factoryMethod The factory method
78 |      * @return The backed setting name.
79 |      */
80 |     String getSettingName(Method factoryMethod);
81 | }
82 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/internal/DefaultAnnotationStrategy.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory.internal;
18 | 
19 | import com.capgemini.boot.core.factory.FactoryProcessorStrategy;
20 | import com.capgemini.boot.core.factory.SettingBackedBean;
21 | import com.capgemini.boot.core.factory.SettingBackedBeanFactory;
22 | import org.springframework.context.ApplicationContext;
23 | 
24 | import java.lang.reflect.Method;
25 | 
26 | /**
27 |  * {@link SettingBackedBean} and {@link SettingBackedBeanFactory} annotation strategy.
28 |  *
29 |  */
30 | public class DefaultAnnotationStrategy implements FactoryProcessorStrategy {  
31 |     
32 |     @Override
33 |     public Class<?> getSettingsClass(Class<?> factoryClass) {
34 |         final SettingBackedBeanFactory annotation = getAnnotationFromFactory(factoryClass);
35 |         return annotation.settingsClass();
36 |     }
37 |     
38 |     @Override
39 |     public String getSettingPrefix(Class<?> factoryClass) {
40 |         final SettingBackedBeanFactory annotation = getAnnotationFromFactory(factoryClass);
41 |         return annotation.settingPrefix();
42 |     }
43 |     
44 |     @Override
45 |     public String getBeanNameSuffix(Method factoryMethod) {
46 |         final SettingBackedBean annotation = factoryMethod.getAnnotation(getFactoryMethodAnnotation());
47 |         return annotation.beanNameSuffix();
48 |     }
49 |     
50 |     @Override
51 |     public String[] getFactoryBeanNames(ApplicationContext context) {
52 |         return context.getBeanNamesForAnnotation(getFactoryClassAnnotation());
53 |     }
54 |     
55 |     @Override
56 |     public boolean isFactoryMethod(Method method) {
57 |         return method.isAnnotationPresent(getFactoryMethodAnnotation());
58 |     }
59 |     
60 |     @Override
61 |     public String getSettingName(Method factoryMethod) {
62 |         return factoryMethod.getAnnotation(getFactoryMethodAnnotation()).setting();
63 |     }
64 |     
65 |     private SettingBackedBeanFactory getAnnotationFromFactory(Class<?> factoryClass) {
66 |         return factoryClass.getAnnotation(getFactoryClassAnnotation());
67 |     }
68 |     
69 |     private Class<SettingBackedBeanFactory> getFactoryClassAnnotation() {
70 |         return SettingBackedBeanFactory.class;
71 |     }
72 |     
73 |     private Class<SettingBackedBean> getFactoryMethodAnnotation() {
74 |         return SettingBackedBean.class;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/main/java/com/capgemini/boot/trace/TraceLoggerRegistrar.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace;
17 | 
18 | import com.capgemini.boot.core.factory.SettingBackedBean;
19 | import com.capgemini.boot.core.factory.SettingBackedBeanFactory;
20 | import com.capgemini.boot.trace.settings.TraceLoggerSettings;
21 | import org.springframework.aop.Advisor;
22 | import org.springframework.aop.aspectj.AspectJExpressionPointcut;
23 | import org.springframework.aop.support.DefaultPointcutAdvisor;
24 | 
25 | import java.util.ArrayList;
26 | import java.util.List;
27 | 
28 | /**
29 |  * Configures trace logging for enabled spring-boot applications for configured
30 |  * pointcuts.
31 |  * 
32 |  * Pointcuts are configured via trace-logging.pointcut.[name] properties.
33 |  */
34 | @SettingBackedBeanFactory(settingsClass = TraceLoggerSettings.class, settingPrefix = TraceLoggerSettings.SETTINGS_PREFIX)
35 | public class TraceLoggerRegistrar {
36 |     
37 |     private List<String> previouslyAddedTracePointcuts = new ArrayList<String>();
38 | 
39 |     @SettingBackedBean(setting = "pointcut", beanNameSuffix = "Advisor")
40 |     public Advisor createAdvisor(String pointcutExpression, TraceLoggerSettings settings) {
41 |         Advisor advisor = null;
42 |         
43 |         if (settings.getEnabled()) {
44 |             final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
45 |             pointcut.setExpression(generateAdvisorPointcutExpression(pointcutExpression));
46 | 
47 |             advisor = new DefaultPointcutAdvisor(pointcut, TraceLoggerConfigurationUtils.createTraceInterceptor(settings));
48 |         }
49 | 
50 |         return advisor;
51 |     }
52 |     
53 |     private String generateAdvisorPointcutExpression(String basePointcutExpression) {
54 |         
55 |         String pointcut = basePointcutExpression 
56 |                 + " and not (" 
57 |                 + TraceLoggerConfiguration.TRACE_ANNOTATION + ")";
58 |         
59 |         //Add previously added pointcuts as 'not' clauses in this pointcut so that trace logging
60 |         //does not potentially occur multiple times per method invocation
61 |         for (String previousPointcut : previouslyAddedTracePointcuts) {
62 |             pointcut = pointcut + " and not (" + previousPointcut + ")";
63 |         }
64 |         
65 |         previouslyAddedTracePointcuts.add(basePointcutExpression);
66 |         
67 |         return pointcut;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/test/groovy/com/capgemini/boot/core/SettingBackedBeanCreationSpec.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2015 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 | 
17 | package com.capgemini.boot.core
18 | 
19 | import org.springframework.beans.factory.annotation.Autowired
20 | import org.springframework.boot.test.IntegrationTest
21 | import org.springframework.boot.test.SpringApplicationContextLoader
22 | import org.springframework.context.ApplicationContext
23 | import org.springframework.test.context.ContextConfiguration
24 | 
25 | import spock.lang.Specification
26 | 
27 | @ContextConfiguration(loader = SpringApplicationContextLoader, classes = TestApplication)
28 | @IntegrationTest(["server.port=0",
29 |                      "test-settings.settingMap.one=mapSettingValueOne",
30 |                      "test-settings.settingMap.two=mapSettingValueTwo",
31 |                      "test-settings.settingList[0]=listSettingValueOne",
32 |                      "test-settings.settingList[1]=listSettingValueTwo",
33 |                      "test-settings.singleSetting=singleSettingValue"])
34 | class SettingBackedBeanCreationSpec extends Specification {
35 | 
36 |     @Autowired
37 |     ApplicationContext context
38 | 
39 |     def "first map setting backed bean bean exists"() {
40 |         given:
41 |         TestSettingBackedBean bean = context.getBean("oneFromMap")
42 |         
43 |         expect:
44 |         bean.settingValue == "mapSettingValueOne"
45 |     }
46 |     
47 |     def "second map setting backed bean bean exists"() {
48 |         given:
49 |         TestSettingBackedBean bean = context.getBean("twoFromMap")
50 |         
51 |         expect:
52 |         bean.settingValue == "mapSettingValueTwo"
53 |     }
54 |     
55 |     def "first list setting backed bean bean exists"() {
56 |         given:
57 |         TestSettingBackedBean bean = context.getBean("1FromList")
58 |         
59 |         expect:
60 |         bean.settingValue == "listSettingValueOne"
61 |     }
62 |     
63 |     def "second list setting backed bean bean exists"() {
64 |         given:
65 |         TestSettingBackedBean bean = context.getBean("2FromList")
66 |         
67 |         expect:
68 |         bean.settingValue == "listSettingValueTwo"
69 |     }
70 |     
71 |     def "setting backed bean bean exists for single setting"() {
72 |         given:
73 |         TestSettingBackedBean bean = context.getBean("singleSettingBean")
74 |         
75 |         expect:
76 |         bean.settingValue == "singleSettingValue"
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/main/java/com/capgemini/boot/trace/settings/TraceLoggerSettings.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.settings;
17 | 
18 | import org.springframework.boot.context.properties.ConfigurationProperties;
19 | import org.springframework.stereotype.Component;
20 | 
21 | import java.util.HashMap;
22 | import java.util.Map;
23 | 
24 | /**
25 |  * Trace Logger configuration backed by properties.
26 |  * 
27 |  * Pointcuts are configured via trace-logging.pointcut.[name] properties.
28 |  */
29 | @Component
30 | @ConfigurationProperties(prefix = TraceLoggerSettings.SETTINGS_PREFIX)
31 | public final class TraceLoggerSettings {
32 |     
33 |     private static final String DEFAULT_ENTER_MESSAGE = "Entering $[methodName]($[arguments])";
34 |     
35 |     private static final String DEFAULT_EXIT_MESSAGE = "Leaving  $[methodName](), returned $[returnValue]";
36 |     
37 |     private static final String DEFAULT_EXCEPTION_MESSAGE = "Exception when executing $[methodName](): $[exception]";
38 |     
39 |     public static final String SETTINGS_PREFIX = "trace-logging";
40 |     
41 |     public static final String ENABLED_SETTING = "enabled";
42 | 
43 |     private Map<String, String> pointcut = new HashMap<String, String>();
44 |     
45 |     private Message message = new Message();
46 |     
47 |     private boolean enabled = true;
48 | 
49 |     public Map<String, String> getPointcut() {
50 |         return pointcut;
51 |     }
52 |     
53 |     public Message getMessage() {
54 |         return message;
55 |     }
56 |     
57 |     public void setEnabled(boolean enabled) {
58 |         this.enabled = enabled;
59 |     }
60 |     
61 |     public boolean getEnabled() {
62 |         return enabled;
63 |     }
64 |     
65 |     public static class Message {
66 |         private String enter = DEFAULT_ENTER_MESSAGE;
67 |         
68 |         private String exit = DEFAULT_EXIT_MESSAGE;
69 |         
70 |         private String exception = DEFAULT_EXCEPTION_MESSAGE;
71 | 
72 |         public String getEnter() {
73 |             return enter;
74 |         }
75 | 
76 |         public void setEnter(String enter) {
77 |             this.enter = enter;
78 |         }
79 | 
80 |         public String getExit() {
81 |             return exit;
82 |         }
83 | 
84 |         public void setExit(String exit) {
85 |             this.exit = exit;
86 |         }
87 | 
88 |         public String getException() {
89 |             return exception;
90 |         }
91 | 
92 |         public void setException(String exception) {
93 |             this.exception = exception;
94 |         }        
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/internal/DefaultExceptionFactory.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 | 
17 | package com.capgemini.boot.core.factory.internal;
18 | 
19 | import org.springframework.beans.factory.BeanCreationException;
20 | 
21 | import java.lang.reflect.Method;
22 | 
23 | public class DefaultExceptionFactory implements ExceptionFactory {
24 | 
25 |     private static final String INVALID_ARGUMENTS = "The arguments for factory method %s are incorrect. "
26 |             + "The first argument should always be the type of the linked setting and a second optional "
27 |             + "argument is allowed, with the same type as the specified settings class.";
28 |     
29 |     private static final String NO_MATCHING_SETTING = "A getter for the setting named %s does not exist";
30 |     
31 |     private static final String ILLEGAL_SETTING_ACCESS = "Getter method for the setting named %s must be public";
32 |     
33 |     private static final String ILLEGAL_SETTING_ARGUMENTS = "Getter method for the setting names %s should not have any arguments";
34 |     @Override
35 |     public RuntimeException createInvalidArgumentsException(Method method) {
36 |         final String message = String.format(INVALID_ARGUMENTS, method.getName());
37 |         
38 |         return createGenericBeanCreationException(message);
39 |     }
40 |     @Override
41 |     public RuntimeException createNoMatchingSettingException(String property) {
42 |         final String message = String.format(NO_MATCHING_SETTING, property);
43 |         
44 |         return createGenericBeanCreationException(message);
45 |     }
46 |     
47 |     @Override
48 |     public RuntimeException createSettingAccessException(String property) {
49 |         final String message = String.format(ILLEGAL_SETTING_ACCESS, property);
50 |         
51 |         return createGenericBeanCreationException(message);
52 |     }
53 |     
54 |     @Override
55 |     public RuntimeException createSettingArgumentsException(String property) {
56 |         final String message  = String.format(ILLEGAL_SETTING_ARGUMENTS, property);
57 |         
58 |         return createGenericBeanCreationException(message);
59 |     }
60 |     
61 |     @Override
62 |     public RuntimeException createGenericException(String message, Throwable cause) {
63 |         return createGenericBeanCreationException(message, cause);
64 |     }
65 |     
66 |     private RuntimeException createGenericBeanCreationException(String message) {
67 |         return createGenericBeanCreationException(message, null);
68 |     }
69 |     
70 |     private RuntimeException createGenericBeanCreationException(String message, Throwable cause) {
71 |         return new BeanCreationException(message);
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/test/groovy/com/capgemini/boot/trace/TestApplication.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Copyright 2015 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 com.capgemini.boot.trace;
 17 | 
 18 | import com.capgemini.boot.trace.annotation.EnableTraceLogger;
 19 | import com.capgemini.boot.trace.annotation.Trace;
 20 | import org.springframework.beans.factory.annotation.Autowired;
 21 | import org.springframework.boot.SpringApplication;
 22 | import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 23 | import org.springframework.stereotype.Component;
 24 | import org.springframework.web.bind.annotation.RequestMapping;
 25 | import org.springframework.web.bind.annotation.RestController;
 26 | 
 27 | @RestController
 28 | @EnableAutoConfiguration
 29 | @EnableTraceLogger
 30 | public class TestApplication {
 31 |     @Autowired
 32 |     private Foo foo;
 33 |     
 34 |     @Autowired
 35 |     private ClassLevelTrace classLevelTrace;
 36 | 
 37 |     @RequestMapping("/")
 38 |     String home() {
 39 |         return foo.getMessageWithAnnotation();
 40 |     }
 41 | 
 42 |     @RequestMapping("/nonAnnotated")
 43 |     String nonAnnotated() {
 44 |         return foo.getMessageWithoutAnnotation();
 45 |     }
 46 | 
 47 |     @RequestMapping("/anotherNonAnnotated")
 48 |     String anotherNonAnnotated() {
 49 |         return foo.getAnotherMessageWithoutAnnotation();
 50 |     }
 51 |     
 52 |     @RequestMapping("/classAnnotated")
 53 |     String classLevelAnnotation() {
 54 |         return classLevelTrace.getMessage();
 55 |     }
 56 |     
 57 |     @RequestMapping("/exception")
 58 |     String exception() {
 59 |         return foo.getMessageWithAnnotationThrowingException();
 60 |     }
 61 | 
 62 |     public static void main(String[] args) throws Exception {
 63 |         SpringApplication.run(TestApplication.class, args);
 64 |     }
 65 | 
 66 |     @Component
 67 |     public class Foo {
 68 |         @Autowired
 69 |         public Foo() {
 70 |         }
 71 | 
 72 |         @Trace
 73 |         public String getMessageWithAnnotation() {
 74 |             return "Hello World!";
 75 |         }
 76 |         
 77 |         @Trace
 78 |         public String getMessageWithAnnotationThrowingException() {
 79 |             throw new RuntimeException();
 80 |         }
 81 | 
 82 |         public String getMessageWithoutAnnotation() {
 83 |             return "Hello Non Annotated World!";
 84 |         }
 85 | 
 86 |         public String getAnotherMessageWithoutAnnotation() {
 87 |             return "Hello Non Annotated Universe!";
 88 |         }
 89 |     }
 90 |     
 91 |     @Component
 92 |     @Trace
 93 |     public class ClassLevelTrace {
 94 |         @Autowired
 95 |         public ClassLevelTrace() {
 96 |             
 97 |         }
 98 |         
 99 |         public String getMessage() {
100 |             return "Hello World!";
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/java/com/capgemini/boot/trace/sample/video/repository/Video.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Copyright 2015 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 com.capgemini.boot.trace.sample.video.repository;
 17 | 
 18 | import com.google.common.base.Objects;
 19 | 
 20 | import javax.persistence.Entity;
 21 | import javax.persistence.GeneratedValue;
 22 | import javax.persistence.GenerationType;
 23 | import javax.persistence.Id;
 24 | 
 25 | /**
 26 |  * A simple object to represent a video and its URL for viewing.
 27 |  */
 28 | //Mark this class as a JPA entity
 29 | @Entity
 30 | public class Video {
 31 | 
 32 |     // specify auto generated primary key of the entity
 33 |     @Id
 34 |     @GeneratedValue(strategy = GenerationType.AUTO)
 35 |     private long id;
 36 | 
 37 |     private String name;
 38 |     private String url;
 39 |     private long duration;
 40 | 
 41 |     public Video() {
 42 |     }
 43 | 
 44 |     public Video(String name, String url, long duration) {
 45 |         super();
 46 |         this.name = name;
 47 |         this.url = url;
 48 |         this.duration = duration;
 49 |     }
 50 | 
 51 |     public String getName() {
 52 |         return name;
 53 |     }
 54 | 
 55 |     public void setName(String name) {
 56 |         this.name = name;
 57 |     }
 58 | 
 59 |     public String getUrl() {
 60 |         return url;
 61 |     }
 62 | 
 63 |     public void setUrl(String url) {
 64 |         this.url = url;
 65 |     }
 66 | 
 67 |     public long getDuration() {
 68 |         return duration;
 69 |     }
 70 | 
 71 |     public void setDuration(long duration) {
 72 |         this.duration = duration;
 73 |     }
 74 | 
 75 |     public long getId() {
 76 |         return id;
 77 |     }
 78 | 
 79 |     public void setId(long id) {
 80 |         this.id = id;
 81 |     }
 82 | 
 83 |     /**
 84 |      * Two Videos will generate the same hashcode if they have exactly the same
 85 |      * values for their name, url, and duration.
 86 |      * 
 87 |      */
 88 |     @Override
 89 |     public int hashCode() {
 90 |         return Objects.hashCode(name, url, duration);
 91 |     }
 92 | 
 93 |     /**
 94 |      * Two Videos are considered equal if they have exactly the same values for
 95 |      * their name, url, and duration.
 96 |      * 
 97 |      */
 98 |     @Override
 99 |     public boolean equals(Object obj) {
100 |         if (obj instanceof Video) {
101 |             Video other = (Video) obj;
102 |             return Objects.equal(name, other.name)
103 |                     && Objects.equal(url, other.url)
104 |                     && duration == other.duration;
105 |         } else {
106 |             return false;
107 |         }
108 |     }
109 | 
110 |     @Override
111 |     public String toString() {
112 |         return Objects.toStringHelper(this)
113 |                 .add("id", id)
114 |                 .add("name", name)
115 |                 .add("url", url)
116 |                 .add("duration", duration)
117 |                 .toString();
118 |     }
119 | }
120 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/test/groovy/com/capgemini/boot/trace/TraceLoggerRegistrarSpec.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Copyright 2015 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 com.capgemini.boot.trace
 17 | 
 18 | import org.springframework.aop.PointcutAdvisor
 19 | import org.springframework.aop.support.ExpressionPointcut
 20 | import org.springframework.beans.factory.annotation.Autowired
 21 | import org.springframework.beans.factory.annotation.Value
 22 | import org.springframework.boot.test.SpringApplicationContextLoader
 23 | import org.springframework.boot.test.TestRestTemplate
 24 | import org.springframework.boot.test.WebIntegrationTest
 25 | import org.springframework.context.ApplicationContext
 26 | import org.springframework.test.context.ContextConfiguration
 27 | import org.springframework.web.client.RestTemplate
 28 | import spock.lang.Specification
 29 | 
 30 | @ContextConfiguration(loader = SpringApplicationContextLoader, classes = TestApplication)
 31 | @WebIntegrationTest(["logging.level.com.capgemini.boot.trace.TestApplication=TRACE",
 32 | 					 "server.port=0",
 33 | 					 "trace-logging.pointcut.test1=execution(* getMessageWithoutAnnotation())",
 34 | 		             "trace-logging.pointcut.test2=execution(* getAnotherMessageWithoutAnnotation())"])
 35 | class TraceLoggerRegistrarSpec extends Specification {
 36 | 
 37 |     @Value('${local.server.port}')
 38 |     int serverPort
 39 | 
 40 | 	@Autowired
 41 | 	ApplicationContext context
 42 | 
 43 |     RestTemplate restTemplate = new TestRestTemplate()
 44 | 
 45 |     def "first pointcut advisor bean exists"() {
 46 |         given:
 47 | 		PointcutAdvisor bean = context.getBean("test1Advisor")
 48 | 		
 49 | 		expect:
 50 |         bean.pointcut instanceof ExpressionPointcut
 51 |         ((ExpressionPointcut) bean.pointcut).expression.contains("execution(* getMessageWithoutAnnotation())")
 52 |     }
 53 | 	
 54 | 	def "second pointcut advisor bean exists"() {
 55 | 		given:
 56 | 		PointcutAdvisor bean = context.getBean("test2Advisor")
 57 | 		
 58 | 		expect:
 59 | 		bean.pointcut instanceof ExpressionPointcut
 60 | 		((ExpressionPointcut) bean.pointcut).expression.contains("execution(* getAnotherMessageWithoutAnnotation())")
 61 | 	}
 62 | 
 63 |     def "method matching pointcut is traced"() {
 64 | 		given:
 65 | 		def output = new ByteArrayOutputStream()
 66 | 
 67 | 		def origOut = System.out
 68 | 		System.out = new PrintStream(output, true)
 69 | 
 70 | 		when:
 71 | 		restTemplate.getForEntity("http://localhost:$serverPort/nonAnnotated", String)
 72 | 
 73 | 		then:
 74 | 		output.toString().contains("Entering getMessageWithoutAnnotation()")
 75 | 		output.toString().contains("Leaving  getMessageWithoutAnnotation(), returned Hello Non Annotated World!")
 76 | 
 77 | 		cleanup:
 78 | 		System.out = origOut
 79 | 	}
 80 | 	
 81 | 	def "multiple pointcuts supported"() {
 82 | 		given:
 83 | 		def output = new ByteArrayOutputStream()
 84 | 
 85 | 		def origOut = System.out
 86 | 		System.out = new PrintStream(output, true)
 87 | 
 88 | 		when:
 89 | 		restTemplate.getForEntity("http://localhost:$serverPort/nonAnnotated", String)
 90 | 		restTemplate.getForEntity("http://localhost:$serverPort/anotherNonAnnotated", String)
 91 | 
 92 | 		then:
 93 | 		output.toString().contains("Entering getMessageWithoutAnnotation()")
 94 | 		output.toString().contains("Leaving  getMessageWithoutAnnotation(), returned Hello Non Annotated World!")
 95 | 		output.toString().contains("Entering getAnotherMessageWithoutAnnotation()")
 96 | 		output.toString().contains("Leaving  getAnotherMessageWithoutAnnotation(), returned Hello Non Annotated Universe!")
 97 | 
 98 | 		cleanup:
 99 | 		System.out = origOut
100 | 	}
101 | }
102 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/test/groovy/com/capgemini/boot/trace/TraceLoggerConfigurationMessagesSpec.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2015 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 com.capgemini.boot.trace
 17 | 
 18 | import org.aopalliance.intercept.Interceptor
 19 | import org.springframework.aop.interceptor.CustomizableTraceInterceptor
 20 | import org.springframework.beans.factory.annotation.Autowired
 21 | import org.springframework.beans.factory.annotation.Value
 22 | import org.springframework.boot.test.SpringApplicationContextLoader
 23 | import org.springframework.boot.test.TestRestTemplate
 24 | import org.springframework.boot.test.WebIntegrationTest
 25 | import org.springframework.context.ApplicationContext
 26 | import org.springframework.test.context.ContextConfiguration
 27 | import org.springframework.web.client.RestTemplate
 28 | import spock.lang.Specification
 29 | 
 30 | /*
 31 |  * NOTE: This could hopefully be moved into TraceLoggerConfigurationSpec once dynamic
 32 |  * properties functionality has been implemented.
 33 |  */
 34 | @ContextConfiguration(loader = SpringApplicationContextLoader, classes = TestApplication)
 35 | @WebIntegrationTest(["logging.level.com.capgemini.boot.trace.TestApplication=TRACE", "server.port=0",
 36 |                 "trace-logging.message.enter=Entering customized \$[methodName](\$[arguments])",
 37 |                 "trace-logging.message.exit=Exiting customized \$[methodName](), returned \$[returnValue]",
 38 |                 "trace-logging.message.exception=Exception customized when executing \$[methodName](): \$[exception]"])
 39 | class TraceLoggerConfigurationMessagesSpec extends Specification {
 40 |         
 41 |     @Value('${local.server.port}')
 42 |     int serverPort
 43 | 
 44 | 	@Autowired
 45 | 	ApplicationContext context
 46 | 
 47 |     RestTemplate restTemplate = new TestRestTemplate()
 48 | 	
 49 | 	def "trace interceptor bean exists with correct properties set when messages configured"() {
 50 |         given:
 51 | 		Interceptor bean = context.getBean("traceInterceptor")
 52 | 		
 53 | 		expect:
 54 |         bean instanceof CustomizableTraceInterceptor
 55 |         with(((CustomizableTraceInterceptor) bean)) {
 56 |             enterMessage == 'Entering customized $[methodName]($[arguments])'
 57 |             exitMessage == 'Exiting customized $[methodName](), returned $[returnValue]'
 58 |             exceptionMessage == 'Exception customized when executing \$[methodName](): \$[exception]'
 59 |         }
 60 | 	}
 61 | 
 62 |     def "can configure custom entry and exit log messages"() {
 63 |         given:
 64 |         def output = new ByteArrayOutputStream()
 65 | 
 66 |         def origOut = System.out
 67 |         System.out = new PrintStream(output, true)
 68 | 
 69 |         when:
 70 |         restTemplate.getForEntity("http://localhost:$serverPort", String)
 71 | 
 72 |         then:
 73 |         output.toString().contains("Entering customized getMessageWithAnnotation()")
 74 |         output.toString().contains("Exiting customized getMessageWithAnnotation(), returned Hello World!")
 75 | 
 76 |         cleanup:
 77 |         System.out = origOut
 78 |     }
 79 |     
 80 |     def "can configure custom exception message"() {
 81 |         given:
 82 |         def output = new ByteArrayOutputStream()
 83 | 
 84 |         def origOut = System.out
 85 |         System.out = new PrintStream(output, true)
 86 | 
 87 |         when:
 88 |         restTemplate.getForEntity("http://localhost:$serverPort/exception", String)
 89 | 
 90 |         then:
 91 |         output.toString().contains("Entering customized getMessageWithAnnotationThrowingException()")
 92 |         output.toString().contains(
 93 |             "Exception customized when executing getMessageWithAnnotationThrowingException(): "
 94 |                 + "java.lang.RuntimeException")
 95 | 
 96 |         cleanup:
 97 |         System.out = origOut
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/src/main/java/com/capgemini/boot/trace/sample/video/controller/VideoSvc.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Copyright 2015 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 com.capgemini.boot.trace.sample.video.controller;
17 | 
18 | import com.capgemini.boot.trace.sample.video.client.VideoSvcApi;
19 | import com.capgemini.boot.trace.sample.video.repository.Video;
20 | import com.capgemini.boot.trace.sample.video.repository.VideoRepository;
21 | import com.google.common.collect.Lists;
22 | import org.springframework.beans.factory.annotation.Autowired;
23 | import org.springframework.web.bind.annotation.*;
24 | 
25 | import java.util.Collection;
26 | 
27 | /**
28 |  * This simple VideoSvc allows clients to send HTTP POST requests with videos
29 |  * that are stored in memory using a list. Clients can send HTTP GET requests to
30 |  * receive a JSON listing of the videos that have been sent to the controller so
31 |  * far. Stopping the controller will cause it to lose the history of videos that
32 |  * have been sent to it because they are stored in memory.
33 |  */
34 | 
35 | // Tell Spring that this class is a Controller that should
36 | // handle certain HTTP requests for the DispatcherServlet
37 | @RestController
38 | public class VideoSvc implements VideoSvcApi {
39 |     // The VideoRepository that we are going to store our videos
40 |     // in. We don't explicitly construct a VideoRepository, but
41 |     // instead mark this object as a dependency that needs to be
42 |     // injected by Spring. Our Application class has a method
43 |     // annotated with @Bean that determines what object will end
44 |     // up being injected into this member variable.
45 |     //
46 |     // Also notice that we don't even need a setter for Spring to
47 |     // do the injection.
48 |     //
49 |     @Autowired
50 |     private VideoRepository videos;
51 | 
52 |     // Receives POST requests to /video and converts the HTTP
53 |     // request body, which should contain json, into a Video
54 |     // object before adding it to the list. The @RequestBody
55 |     // annotation on the Video parameter is what tells Spring
56 |     // to interpret the HTTP request body as JSON and convert
57 |     // it into a Video object to pass into the method. The
58 |     // @ResponseBody annotation tells Spring to conver the
59 |     // return value from the method back into JSON and put
60 |     // it into the body of the HTTP response to the client.
61 |     //
62 |     // The VIDEO_SVC_PATH is set to "/video" in the VideoSvcApi
63 |     // interface. We use this constant to ensure that the
64 |     // client and service paths for the VideoSvc are always
65 |     // in synch.
66 |     //
67 |     @Override
68 |     @RequestMapping(value = VideoSvcApi.VIDEO_SVC_PATH, method = RequestMethod.POST)
69 |     public @ResponseBody boolean addVideo(@RequestBody Video v) {
70 |         videos.save(v);
71 |         return true;
72 |     }
73 | 
74 |     // Receives GET requests to /video and returns the current
75 |     // list of videos in memory. Spring automatically converts
76 |     // the list of videos to JSON because of the @ResponseBody
77 |     // annotation.
78 |     @Override
79 |     @RequestMapping(value = VideoSvcApi.VIDEO_SVC_PATH, method = RequestMethod.GET)
80 |     public @ResponseBody Collection<Video> getVideoList() {
81 |         return Lists.newArrayList(videos.findAll());
82 |     }
83 | 
84 |     // Receives GET requests to /video/find and returns all Videos
85 |     // that have a title (e.g., Video.name) matching the "title" request
86 |     // parameter value that is passed by the client
87 |     @Override
88 |     @RequestMapping(value = VideoSvcApi.VIDEO_TITLE_SEARCH_PATH, method = RequestMethod.GET)
89 |     public @ResponseBody Collection<Video> findByTitle(
90 |     // Tell Spring to use the "title" parameter in the HTTP request's query
91 |     // string as the value for the title method parameter
92 |             @RequestParam(TITLE_PARAMETER) String title) {
93 |         if (title == null || title.equals("")) {
94 |             throw new IllegalArgumentException("Video title cannot be null");
95 |         }
96 |         return videos.findByName(title);
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/examples/spring-capgemini-trace-sample/README.md:
--------------------------------------------------------------------------------
  1 | Spring Boot Trace Sample
  2 | ========================
  3 | 
  4 | Introduction
  5 | ------------
  6 | 
  7 | This is a simple Video store application that allows users to
  8 | 
  9 |    * add a video to the store
 10 |    * retrieve all videos from the store
 11 |    * find a video by it's title
 12 |    
 13 | A Video has the following attributes
 14 | 
 15 |    * id
 16 |    * name
 17 |    * url
 18 |    * duration;
 19 | 
 20 | 
 21 | Design
 22 | ------
 23 | 
 24 | ### REST API
 25 | 
 26 | The Video store application is a Spring Boot Application, that as a Rest Controller class mapping the following URLs
 27 | 
 28 |    * `localhost:8080/video` (GET) - retrieve all videos from the store
 29 |    * `localhost:8080/video` (POST) - add a video to the store
 30 |    * `localhost:8080/video/find?title=MyVideo` (POST) - find all videos with title of "MyVideo"
 31 |    
 32 | In order to add a video, the url must pass a JSON payload containing the Video information.
 33 | 
 34 | `src/main/resources/addVideo.json` is a json file containing a single Video entry.  Use the 'curl' command to send a HTTP POST command containing the json defined in this file to the specified url.
 35 | 
 36 | `curl -H "Content-Type: application/json" --data @addVideo.json http://localhost:8080/video`
 37 |   
 38 | ### JPA Repository
 39 | 
 40 | The application defines a repository that extends the Spring "CrudRepository".  The gradle build file defines a H2 database,  Spring Boot discovers it and and runs an in memory h2 database within the application.  The `VideoRepository` interface defines the application's interface to the database. There is no implementation of the `VideoRepository` in the project, Spring dynamically creates the implementation when it discovers the `@Repository` annotated interface.
 41 | 
 42 | On Spring Boot startup Spring JDBC finds, and executes the `data.sql` file located in the `src/main/resources` directory.  This file populates the repository with 3 Video entries.
 43 | 
 44 | ### Trace starter
 45 | 
 46 | The video applications gradle build file declares the `spring-boot-trace` spring boot starter as a dependency.
 47 | 
 48 | This allows the use of the  `@EnableTraceLogging` annotation to state that this application can be configured to trace entry/exit/exception points of public methods, defined by configuration.
 49 | 
 50 | Configuration
 51 | -------------
 52 | 
 53 | ### Logging configuration
 54 | 
 55 | The `spring-boot-trace` spring boot starter logs at `TRACE` level, so the default `LogBack` logger used by the Video Spring Boot application must be configured to capture logs at this `TRACE` level.  This can be configured in the configuration file in `src/main/resources/config/application.properties`, as follows
 56 | 
 57 | `logging.level.com.capgemini.boot.trace.sample.video.controller.VideoSvc=TRACE` - configures `TRACE` logging for only the VideoSvc class
 58 | 
 59 | OR
 60 | 
 61 | `logging.level.com.capgemini.boot.trace.sample.video.*=TRACE` - configures `TRACE` logging for all classes in the `com.capgemini.boot.trace.sample.video package` and its subpackages.
 62 | 
 63 | 
 64 | ### Trace configuration
 65 | 
 66 | To enable trace logging, the following attribute in the `application.properties` file must be set to true
 67 | 
 68 | `trace-logging.enabled=true`
 69 | 
 70 | If, as in the video application example, the target object to be trace logged implements an interface, you must forces the use of CGLIB rather than JDK dynamic proxies by setting the following property in the `application.properties` file
 71 | 
 72 | `spring.aop.proxyTargetClass=true`
 73 | 
 74 | see [spring documentation](http://docs.spring.io/spring/docs/2.5.x/reference/aop.html#aop-proxying) for more information
 75 | 
 76 | ### Trace pointcut configuration
 77 | 
 78 | The methods to be traced by the `spring-boot-trace` starter, are defined by AOP pointcut expressions in the following format in the `application.properties` file
 79 | 
 80 | `trace-logging.pointcut.NAME=execution(* com.capgemini.boot.trace.sample.video.controller.VideoSvc.*(..))
 81 | 
 82 | where NAME is used to differentiate pointcuts.
 83 | 
 84 | The Spring AOP pointcut expression language is defined, with examples, at the following [Spring documentation](http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html#aop-pointcuts-examples)
 85 | 
 86 | The video application uses
 87 | 
 88 | `trace-logging.pointcut.videoSvc=execution(* com.capgemini.boot.trace.sample.video.controller.VideoSvc.*(..))`
 89 | 
 90 | which means that all public methods of the VideoSvc class are trace logged
 91 | 
 92 | The following examples enables tracing of all public methods in VideoSvc class that take a String parameter - i.e the method "Collection<Video> findByTitle(String title)"
 93 | 
 94 | `trace-logging.pointcut.test1=execution(* com.capgemini.boot.trace.sample.video.controller.VideoSvc.*(String))` 
 95 | 
 96 |    
 97 | 
 98 | 
 99 | 
100 | 
101 | 
102 | 


--------------------------------------------------------------------------------
/spring-capgemini-trace/src/test/groovy/com/capgemini/boot/trace/TraceLoggerConfigurationSpec.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2015 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 com.capgemini.boot.trace
 17 | 
 18 | import org.aopalliance.intercept.Interceptor
 19 | import org.springframework.aop.PointcutAdvisor
 20 | import org.springframework.aop.interceptor.CustomizableTraceInterceptor
 21 | import org.springframework.aop.support.ExpressionPointcut
 22 | import org.springframework.beans.factory.annotation.Autowired
 23 | import org.springframework.beans.factory.annotation.Value
 24 | import org.springframework.boot.test.SpringApplicationContextLoader
 25 | import org.springframework.boot.test.TestRestTemplate
 26 | import org.springframework.boot.test.WebIntegrationTest
 27 | import org.springframework.context.ApplicationContext
 28 | import org.springframework.test.context.ContextConfiguration
 29 | import org.springframework.web.client.RestTemplate
 30 | import spock.lang.Specification
 31 | 
 32 | @ContextConfiguration(loader = SpringApplicationContextLoader, classes = TestApplication)
 33 | @WebIntegrationTest(["logging.level.com.capgemini.boot.trace.TestApplication=TRACE", "server.port=0"])
 34 | class TraceLoggerConfigurationSpec extends Specification {
 35 | 
 36 |     @Value('${local.server.port}')
 37 |     int serverPort
 38 | 
 39 | 	@Autowired
 40 | 	ApplicationContext context
 41 | 
 42 |     RestTemplate restTemplate = new TestRestTemplate()
 43 | 
 44 |     def "annotation advisor bean exists with correct properties set"() {
 45 |         given:
 46 | 		PointcutAdvisor bean = context.getBean("traceAnnotationAdvisor")
 47 | 		
 48 | 		expect:
 49 |         bean.pointcut instanceof ExpressionPointcut
 50 |         ((ExpressionPointcut) bean.pointcut).expression == "@annotation(com.capgemini.boot.trace.annotation.Trace) or" +
 51 |                 " within(@com.capgemini.boot.trace.annotation.Trace *)"
 52 |     }
 53 | 	
 54 | 	def "trace interceptor bean exists with correct properties set"() {
 55 |         given:
 56 | 		Interceptor bean = context.getBean("traceInterceptor")
 57 | 		
 58 | 		expect:
 59 |         bean instanceof CustomizableTraceInterceptor
 60 |         with(((CustomizableTraceInterceptor) bean)) {
 61 |             enterMessage == 'Entering $[methodName]($[arguments])'
 62 |             exitMessage == 'Leaving  $[methodName](), returned $[returnValue]'
 63 |         }
 64 | 	}
 65 | 
 66 |     def "can trace an annotated method call"() {
 67 |         given:
 68 |         def output = new ByteArrayOutputStream()
 69 | 
 70 |         def origOut = System.out
 71 |         System.out = new PrintStream(output, true)
 72 | 
 73 |         when:
 74 |         restTemplate.getForEntity("http://localhost:$serverPort", String)
 75 | 
 76 |         then:
 77 |         output.toString().contains("Entering getMessageWithAnnotation()")
 78 |         output.toString().contains("Leaving  getMessageWithAnnotation(), returned Hello World!")
 79 | 
 80 |         cleanup:
 81 |         System.out = origOut
 82 |     }
 83 | 	
 84 | 	def "non annotated method isn't traced"() {
 85 | 		given:
 86 | 		def output = new ByteArrayOutputStream()
 87 | 
 88 | 		def origOut = System.out
 89 | 		System.out = new PrintStream(output, true)
 90 | 
 91 | 		when:
 92 | 		restTemplate.getForEntity("http://localhost:$serverPort/nonAnnotated", String)
 93 | 
 94 | 		then:
 95 | 		!output.toString().contains("Entering getMessageWithoutAnnotation()")
 96 | 		!output.toString().contains("Leaving  getMessageWithoutAnnotation(), returned Hello Non Annotated World!")
 97 | 
 98 | 		cleanup:
 99 | 		System.out = origOut
100 | 	}
101 |     
102 |     def "can trace a class annotated method call"() {
103 |         given:
104 |         def output = new ByteArrayOutputStream()
105 | 
106 |         def origOut = System.out
107 |         System.out = new PrintStream(output, true)
108 | 
109 |         when:
110 |         restTemplate.getForEntity("http://localhost:$serverPort/classAnnotated", String)
111 | 
112 |         then:
113 |         output.toString().contains("Entering getMessage()")
114 |         output.toString().contains("Leaving  getMessage(), returned Hello World!")
115 | 
116 |         cleanup:
117 |         System.out = origOut
118 |     }
119 |     
120 |     def "can trace exception"() {
121 |         given:
122 |         def output = new ByteArrayOutputStream()
123 | 
124 |         def origOut = System.out
125 |         System.out = new PrintStream(output, true)
126 | 
127 |         when:
128 |         restTemplate.getForEntity("http://localhost:$serverPort/exception", String)
129 | 
130 |         then:
131 |         output.toString().contains("Entering getMessageWithAnnotationThrowingException()")
132 |         output.toString().contains(
133 |             "Exception when executing getMessageWithAnnotationThrowingException(): java.lang.RuntimeException")
134 | 
135 |         cleanup:
136 |         System.out = origOut
137 |     }
138 | }
139 | 


--------------------------------------------------------------------------------
/gradle/checkstyle/checkstyle.xml:
--------------------------------------------------------------------------------
  1 | <!--
  2 |   ~ Copyright 2010 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 | <!DOCTYPE module PUBLIC
 17 |         "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
 18 |         "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
 19 | <module name="Checker">
 20 |     <module name="SuppressionFilter">
 21 |         <property name="file" value="${checkstyleConfigDir}/suppressions.xml"/>
 22 |     </module>
 23 |     <module name="TreeWalker">
 24 |       <!--<module name="Indentation">-->
 25 |         <!--<property name="basicOffset" value="2"/>-->
 26 |       <!--</module>-->
 27 | 
 28 |         <!-- Blocks -->
 29 |         <module name="EmptyBlock">
 30 |             <property name="option" value="stmt"/>
 31 |             <property name="tokens" value="LITERAL_DO,LITERAL_ELSE,LITERAL_FINALLY,LITERAL_IF,LITERAL_FOR,LITERAL_TRY,LITERAL_WHILE,INSTANCE_INIT,STATIC_INIT"/>
 32 |         </module>
 33 |         <module name="EmptyBlock">
 34 |             <property name="option" value="text"/>
 35 |             <property name="tokens" value="LITERAL_CATCH"/>
 36 |         </module>
 37 |         <module name="AvoidNestedBlocks"/>
 38 | 
 39 |         <!-- Braces -->
 40 |         <module name="LeftCurly"/>
 41 |         <module name="RightCurly"/>
 42 |         <module name="NeedBraces"/>
 43 | 
 44 |         <!-- Whitespace -->
 45 |         <module name="GenericWhitespace"/>
 46 |         <module name="EmptyForInitializerPad"/>
 47 |         <module name="EmptyForIteratorPad"/>
 48 |         <module name="MethodParamPad"/>
 49 |         <module name="NoWhitespaceBefore"/>
 50 |         <module name="NoWhitespaceAfter"/>
 51 |         <module name="OperatorWrap"/>
 52 |         <module name="ParenPad"/>
 53 |         <module name="TypecastParenPad"/>
 54 |         <module name="WhitespaceAfter">
 55 |             <property name="tokens" value="COMMA, SEMI"/>
 56 |         </module>
 57 |         <module name="WhitespaceAround">
 58 |             <!-- everything except { and } -->
 59 |             <property name="tokens" value="ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN, COLON, DIV, DIV_ASSIGN, EQUAL, GE, GT, LAND, LE, LITERAL_ASSERT, LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_RETURN, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE, LOR, LT, MINUS, MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL, PLUS, PLUS_ASSIGN, QUESTION, SL, SLIST, SL_ASSIGN, SR, SR_ASSIGN, STAR, STAR_ASSIGN, TYPE_EXTENSION_AND"/>
 60 |         </module>
 61 | 
 62 |         <!-- Coding -->
 63 |         <module name="CovariantEquals"/>
 64 |         <module name="DefaultComesLast"/>
 65 |         <module name="EmptyStatement"/>
 66 |         <module name="EqualsHashCode"/>
 67 |         <module name="ExplicitInitialization"/>
 68 |         <module name="MultipleVariableDeclarations"/>
 69 |         <module name="NoClone"/>
 70 |         <module name="NoFinalizer"/>
 71 |         <module name="RedundantThrows">
 72 |             <property name="allowUnchecked" value="true"/>
 73 |         </module>
 74 |         <module name="SimplifyBooleanExpression"/>
 75 |         <module name="SimplifyBooleanReturn"/>
 76 |         <module name="StringLiteralEquality"/>
 77 |         <module name="UnnecessaryParentheses"/>
 78 |         <module name="RedundantModifier"/>
 79 | 
 80 |         <!-- Design -->
 81 |         <module name="InterfaceIsType"/>
 82 | 
 83 |         <!-- Imports -->
 84 |         <module name="RedundantImport"/>
 85 |         <module name="UnusedImports"/>
 86 | 
 87 |         <!-- Naming -->
 88 |         <module name="ClassTypeParameterName"/>
 89 |         <module name="ConstantName"/>
 90 |         <module name="LocalFinalVariableName"/>
 91 |         <module name="LocalVariableName"/>
 92 |         <module name="MemberName">
 93 |             <property name="format" value="^[a-z_][a-zA-Z0-9_]*$"/>
 94 |         </module>
 95 |         <module name="MethodName">
 96 |             <property name="format" value="^[a-z_][a-zA-Z0-9_]*$"/>
 97 |         </module>
 98 |         <module name="MethodTypeParameterName"/>
 99 |         <module name="PackageName">
100 |             <property name="format" value="^[a-z]+(\.[a-z][a-z0-9]*)*$"/>
101 |         </module>
102 |         <module name="ParameterName"/>
103 |         <module name="StaticVariableName"/>
104 |         <module name="TypeName"/>
105 | 
106 |         <!-- to enable SuppressionCommentFilter -->
107 |         <module name="FileContentsHolder"/>
108 |     </module>
109 |     <module name="RegexpHeader">
110 |         <property name="headerFile" value="${checkstyleConfigDir}/required-header.txt"/>
111 |     </module>
112 |     <module name="FileTabCharacter"/>
113 |     <module name="RegexpSingleline">
114 |         <property name="format" value="File \| Settings \| File Templates"/>
115 |     </module>
116 |     <module name="RegexpSingleline">
117 |         <property name="format" value="Created with IntelliJ IDEA"/>
118 |     </module>
119 |     <module name="RegexpSingleline">
120 |         <property name="format" value="@author"/>
121 |     </module>
122 | 
123 |     <!-- allows suppressing using the //CHECKSTYLE:ON //CHECKSTYLE:OFF -->
124 |     <module name="SuppressionCommentFilter"/>
125 | </module>


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/gradle/codenarc/codenarc.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2014 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 | 
 17 | ruleset {
 18 |   // rulesets/basic.xml
 19 |   AssertWithinFinallyBlock
 20 |   AssignmentInConditional
 21 |   BigDecimalInstantiation
 22 |   BitwiseOperatorInConditional
 23 |   BooleanGetBoolean
 24 |   BrokenNullCheck
 25 |   BrokenOddnessCheck
 26 |   ClassForName
 27 |   ComparisonOfTwoConstants
 28 |   ComparisonWithSelf
 29 |   ConstantAssertExpression
 30 |   ConstantIfExpression
 31 |   ConstantTernaryExpression
 32 |   DeadCode
 33 |   DoubleNegative
 34 |   DuplicateCaseStatement
 35 |   DuplicateMapKey
 36 |   DuplicateSetValue
 37 |   EmptyCatchBlock
 38 |   EmptyClass
 39 |   EmptyElseBlock
 40 |   EmptyFinallyBlock
 41 |   EmptyForStatement
 42 |   EmptyIfStatement
 43 |   EmptyInstanceInitializer
 44 |   EmptyMethod
 45 |   EmptyStaticInitializer
 46 |   EmptySwitchStatement
 47 |   EmptySynchronizedStatement
 48 |   EmptyTryBlock
 49 |   EmptyWhileStatement
 50 |   EqualsAndHashCode
 51 |   EqualsOverloaded
 52 |   ExplicitGarbageCollection
 53 |   ForLoopShouldBeWhileLoop
 54 |   HardCodedWindowsFileSeparator
 55 |   HardCodedWindowsRootDirectory
 56 |   IntegerGetInteger
 57 |   RandomDoubleCoercedToZero
 58 |   RemoveAllOnSelf
 59 |   ReturnFromFinallyBlock
 60 |   ThrowExceptionFromFinallyBlock
 61 | 
 62 |   // rulesets/braces.xml
 63 |   ElseBlockBraces
 64 |   ForStatementBraces
 65 |   IfStatementBraces
 66 |   WhileStatementBraces
 67 | 
 68 |   // rulesets/concurrency.xml
 69 |   /*
 70 |   BusyWait
 71 |   DoubleCheckedLocking
 72 |   InconsistentPropertyLocking
 73 |   InconsistentPropertySynchronization
 74 |   NestedSynchronization
 75 |   StaticCalendarField
 76 |   StaticConnection
 77 |   StaticDateFormatField
 78 |   StaticMatcherField
 79 |   StaticSimpleDateFormatField
 80 |   SynchronizedMethod
 81 |   SynchronizedOnBoxedPrimitive
 82 |   SynchronizedOnGetClass
 83 |   SynchronizedOnReentrantLock
 84 |   SynchronizedOnString
 85 |   SynchronizedOnThis
 86 |   SynchronizedReadObjectMethod
 87 |   SystemRunFinalizersOnExit
 88 |   ThisReferenceEscapesConstructor
 89 |   ThreadGroup
 90 |   ThreadLocalNotStaticFinal
 91 |   ThreadYield
 92 |   UseOfNotifyMethod
 93 |   VolatileArrayField
 94 |   VolatileLongOrDoubleField
 95 |   WaitOutsideOfWhileLoop
 96 |   */
 97 | 
 98 |   // rulesets/convention.xml
 99 |   ConfusingTernary
100 |   CouldBeElvis
101 |   HashtableIsObsolete
102 |   IfStatementCouldBeTernary
103 |   InvertedIfElse
104 |   LongLiteralWithLowerCaseL
105 |   ParameterReassignment
106 |   TernaryCouldBeElvis
107 |   VectorIsObsolete
108 | 
109 |   // rulesets/design.xml
110 |   /*
111 |   AbstractClassWithPublicConstructor
112 |   AbstractClassWithoutAbstractMethod
113 |   BooleanMethodReturnsNull
114 |   BuilderMethodWithSideEffects
115 |   CloneableWithoutClone
116 |   CloseWithoutCloseable
117 |   CompareToWithoutComparable
118 |   ConstantsOnlyInterface
119 |   EmptyMethodInAbstractClass
120 |   FinalClassWithProtectedMember
121 |   ImplementationAsType
122 |   LocaleSetDefault
123 |   PrivateFieldCouldBeFinal
124 |   PublicInstanceField
125 |   ReturnsNullInsteadOfEmptyArray
126 |   ReturnsNullInsteadOfEmptyCollection
127 |   SimpleDateFormatMissingLocale
128 |   StatelessSingleton
129 |   */
130 | 
131 |   // rulesets/dry.xml
132 |   /*
133 |   DuplicateListLiteral
134 |   DuplicateMapLiteral
135 |   DuplicateNumberLiteral
136 |   DuplicateStringLiteral
137 |   */
138 | 
139 |   // rulesets/enhanced.xml
140 |   /*
141 |   CloneWithoutCloneable
142 |   JUnitAssertEqualsConstantActualValue
143 |   UnsafeImplementationAsMap
144 |   */
145 | 
146 |   // rulesets/exceptions.xml
147 |   /*
148 |   CatchArrayIndexOutOfBoundsException
149 |   CatchError
150 |   CatchException
151 |   CatchIllegalMonitorStateException
152 |   CatchIndexOutOfBoundsException
153 |   CatchNullPointerException
154 |   CatchRuntimeException
155 |   CatchThrowable
156 |   ConfusingClassNamedException
157 |   ExceptionExtendsError
158 |   ExceptionNotThrown
159 |   MissingNewInThrowStatement
160 |   ReturnNullFromCatchBlock
161 |   SwallowThreadDeath
162 |   ThrowError
163 |   ThrowException
164 |   ThrowNullPointerException
165 |   ThrowRuntimeException
166 |   ThrowThrowable
167 |   */
168 | 
169 |   // rulesets/formatting.xml
170 |   BracesForClass
171 |   BracesForForLoop
172 |   BracesForIfElse
173 |   BracesForMethod
174 |   BracesForTryCatchFinally
175 |   //ClassJavadoc
176 |   ClosureStatementOnOpeningLineOfMultipleLineClosure
177 |   FileEndsWithoutNewline
178 |   LineLength
179 |   SpaceAfterCatch
180 |   SpaceAfterClosingBrace
181 |   SpaceAfterComma
182 |   SpaceAfterFor
183 |   SpaceAfterIf
184 |   SpaceAfterOpeningBrace
185 |   SpaceAfterSemicolon
186 |   SpaceAfterSwitch
187 |   SpaceAfterWhile
188 |   SpaceAroundClosureArrow
189 |   SpaceAroundMapEntryColon
190 |   SpaceAroundOperator
191 |   SpaceBeforeClosingBrace
192 |   SpaceBeforeOpeningBrace
193 | 
194 |   // rulesets/generic.xml
195 |   /*
196 |   IllegalClassMember
197 |   IllegalClassReference
198 |   IllegalPackageReference
199 |   IllegalRegex
200 |   IllegalString
201 |   RequiredRegex
202 |   RequiredString
203 |   StatelessClass
204 |   */
205 | 
206 |   // rulesets/grails.xml
207 |   /*
208 |   GrailsDomainHasEquals
209 |   GrailsDomainHasToString
210 |   GrailsDomainReservedSqlKeywordName
211 |   GrailsDomainWithServiceReference
212 |   GrailsDuplicateConstraint
213 |   GrailsDuplicateMapping
214 |   GrailsPublicControllerMethod
215 |   GrailsServletContextReference
216 |   GrailsSessionReference   // DEPRECATED
217 |   GrailsStatelessService
218 |   */
219 | 
220 |   // rulesets/groovyism.xml
221 |   AssignCollectionSort
222 |   AssignCollectionUnique
223 |   ClosureAsLastMethodParameter
224 |   CollectAllIsDeprecated
225 |   ConfusingMultipleReturns
226 |   ExplicitArrayListInstantiation
227 |   ExplicitCallToAndMethod
228 |   ExplicitCallToCompareToMethod
229 |   ExplicitCallToDivMethod
230 |   ExplicitCallToEqualsMethod
231 |   ExplicitCallToGetAtMethod
232 |   ExplicitCallToLeftShiftMethod
233 |   ExplicitCallToMinusMethod
234 |   ExplicitCallToModMethod
235 |   ExplicitCallToMultiplyMethod
236 |   ExplicitCallToOrMethod
237 |   ExplicitCallToPlusMethod
238 |   ExplicitCallToPowerMethod
239 |   ExplicitCallToRightShiftMethod
240 |   ExplicitCallToXorMethod
241 |   ExplicitHashMapInstantiation
242 |   ExplicitHashSetInstantiation
243 |   ExplicitLinkedHashMapInstantiation
244 |   ExplicitLinkedListInstantiation
245 |   ExplicitStackInstantiation
246 |   ExplicitTreeSetInstantiation
247 |   GStringAsMapKey
248 |   GStringExpressionWithinString
249 |   GetterMethodCouldBeProperty
250 |   GroovyLangImmutable
251 |   UseCollectMany
252 |   UseCollectNested
253 | 
254 |   // rulesets/imports.xml
255 |   DuplicateImport
256 |   ImportFromSamePackage
257 | //  ImportFromSunPackages
258 | //  MisorderedStaticImports
259 |   UnnecessaryGroovyImport
260 |   UnusedImport
261 | 
262 |   // rulesets/jdbc.xml
263 |   /*
264 |   DirectConnectionManagement
265 |   JdbcConnectionReference
266 |   JdbcResultSetReference
267 |   JdbcStatementReference
268 |   */
269 | 
270 |   // rulesets/junit.xml
271 |   /*
272 |   ChainedTest
273 |   CoupledTestCase
274 |   JUnitAssertAlwaysFails
275 |   JUnitAssertAlwaysSucceeds
276 |   JUnitFailWithoutMessage
277 |   JUnitLostTest
278 |   JUnitPublicField
279 |   JUnitPublicNonTestMethod
280 |   JUnitSetUpCallsSuper
281 |   JUnitStyleAssertions
282 |   JUnitTearDownCallsSuper
283 |   JUnitTestMethodWithoutAssert
284 |   JUnitUnnecessarySetUp
285 |   JUnitUnnecessaryTearDown
286 |   JUnitUnnecessaryThrowsException
287 |   SpockIgnoreRestUsed
288 |   UnnecessaryFail
289 |   UseAssertEqualsInsteadOfAssertTrue
290 |   UseAssertFalseInsteadOfNegation
291 |   UseAssertNullInsteadOfAssertEquals
292 |   UseAssertSameInsteadOfAssertTrue
293 |   UseAssertTrueInsteadOfAssertEquals
294 |   UseAssertTrueInsteadOfNegation
295 |   */
296 | 
297 |   // rulesets/logging.xml
298 |   /*
299 |   LoggerForDifferentClass
300 |   LoggerWithWrongModifiers
301 |   LoggingSwallowsStacktrace
302 |   MultipleLoggers
303 |   PrintStackTrace
304 |   Println
305 |   SystemErrPrint
306 |   SystemOutPrint
307 |   */
308 | 
309 |   // rulesets/naming.xml
310 |   AbstractClassName
311 |   ClassName {
312 |     regex = '^[A-Z][\\$a-zA-Z0-9]*$'
313 |   }
314 |   ClassNameSameAsFilename
315 | //  ConfusingMethodName
316 | //  FactoryMethodName
317 |   FieldName {
318 |     regex = '^_?[a-z][a-zA-Z0-9]*$'
319 |     finalRegex = '^_?[a-z][a-zA-Z0-9]*$'
320 |     staticFinalRegex = '^logger$|^[A-Z][A-Z_0-9]*$|^serialVersionUID$'
321 |   }
322 |   InterfaceName
323 |   MethodName {
324 |     regex = '^[a-z][\\$_a-zA-Z0-9]*$|^.*\\s.*$'
325 |   }
326 |   ObjectOverrideMisspelledMethodName
327 |   PackageName
328 |   ParameterName
329 |   PropertyName
330 |   VariableName {
331 |     finalRegex = '^[a-z][a-zA-Z0-9]*$'
332 |   }
333 | 
334 |   // rulesets/security.xml
335 |   /*
336 |   FileCreateTempFile
337 |   InsecureRandom
338 |   JavaIoPackageAccess
339 |   NonFinalPublicField
340 |   NonFinalSubclassOfSensitiveInterface
341 |   ObjectFinalize
342 |   PublicFinalizeMethod
343 |   SystemExit
344 |   UnsafeArrayDeclaration
345 |   */
346 | 
347 |   // rulesets/serialization.xml
348 |   /*
349 |   EnumCustomSerializationIgnored
350 |   SerialPersistentFields
351 |   SerialVersionUID
352 |   SerializableClassMustDefineSerialVersionUID
353 |   */
354 | 
355 |   // rulesets/size.xml
356 |   /*
357 |   AbcComplexity   // DEPRECATED: Use the AbcMetric rule instead. Requires the GMetrics jar
358 |   AbcMetric   // Requires the GMetrics jar
359 |   ClassSize
360 |   CrapMetric   // Requires the GMetrics jar and a Cobertura coverage file
361 |   CyclomaticComplexity   // Requires the GMetrics jar
362 |   MethodCount
363 |   MethodSize
364 |   NestedBlockDepth
365 |   */
366 | 
367 |   // rulesets/unnecessary.xml
368 |   AddEmptyString
369 |   ConsecutiveLiteralAppends
370 |   ConsecutiveStringConcatenation
371 |   UnnecessaryBigDecimalInstantiation
372 |   UnnecessaryBigIntegerInstantiation
373 |   UnnecessaryBooleanExpression
374 |   UnnecessaryBooleanInstantiation
375 | //  UnnecessaryCallForLastElement
376 |   UnnecessaryCallToSubstring
377 |   UnnecessaryCatchBlock
378 | //  UnnecessaryCollectCall
379 |   UnnecessaryCollectionCall
380 |   UnnecessaryConstructor
381 |   UnnecessaryDefInFieldDeclaration
382 |   UnnecessaryDefInMethodDeclaration
383 |   UnnecessaryDefInVariableDeclaration
384 |   UnnecessaryDotClass
385 |   UnnecessaryDoubleInstantiation
386 |   UnnecessaryElseStatement
387 |   UnnecessaryFinalOnPrivateMethod
388 |   UnnecessaryFloatInstantiation
389 | //  UnnecessaryGString
390 | //  UnnecessaryGetter
391 |   UnnecessaryIfStatement
392 |   UnnecessaryInstanceOfCheck
393 |   UnnecessaryInstantiationToGetClass
394 |   UnnecessaryIntegerInstantiation
395 |   UnnecessaryLongInstantiation
396 |   UnnecessaryModOne
397 |   UnnecessaryNullCheck
398 |   UnnecessaryNullCheckBeforeInstanceOf
399 |   UnnecessaryObjectReferences
400 |   UnnecessaryOverridingMethod
401 | //  UnnecessaryPackageReference
402 |   UnnecessaryParenthesesForMethodCallWithClosure
403 |   UnnecessaryPublicModifier
404 | //  UnnecessaryReturnKeyword
405 | //  UnnecessarySelfAssignment
406 |   UnnecessarySemicolon
407 |   UnnecessaryStringInstantiation
408 | //  UnnecessarySubstring
409 |   UnnecessaryTernaryExpression
410 |   UnnecessaryTransientModifier
411 | 
412 |   // rulesets/unused.xml
413 |   UnusedArray
414 | //  UnusedMethodParameter
415 |   UnusedObject
416 |   UnusedPrivateField
417 |   UnusedPrivateMethod
418 |   UnusedPrivateMethodParameter
419 |   UnusedVariable
420 | }
421 | 


--------------------------------------------------------------------------------
/gradle/codenarc/codenarcTest.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2014 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 | 
 17 | ruleset {
 18 |   // rulesets/basic.xml
 19 |   AssertWithinFinallyBlock
 20 |   AssignmentInConditional
 21 |   BigDecimalInstantiation
 22 |   BitwiseOperatorInConditional
 23 |   BooleanGetBoolean
 24 |   BrokenNullCheck
 25 |   BrokenOddnessCheck
 26 |   ClassForName
 27 |   ComparisonOfTwoConstants
 28 |   ComparisonWithSelf
 29 |   ConstantAssertExpression
 30 |   ConstantIfExpression
 31 |   ConstantTernaryExpression
 32 |   DeadCode
 33 |   DoubleNegative
 34 |   DuplicateCaseStatement
 35 |   DuplicateMapKey
 36 |   DuplicateSetValue
 37 |   EmptyCatchBlock
 38 |   EmptyClass
 39 |   EmptyElseBlock
 40 |   EmptyFinallyBlock
 41 |   EmptyForStatement
 42 |   EmptyIfStatement
 43 |   EmptyInstanceInitializer
 44 |   EmptyMethod
 45 |   EmptyStaticInitializer
 46 |   EmptySwitchStatement
 47 |   EmptySynchronizedStatement
 48 |   EmptyTryBlock
 49 |   EmptyWhileStatement
 50 |   EqualsAndHashCode
 51 |   EqualsOverloaded
 52 |   ExplicitGarbageCollection
 53 |   ForLoopShouldBeWhileLoop
 54 |   HardCodedWindowsFileSeparator
 55 |   HardCodedWindowsRootDirectory
 56 |   IntegerGetInteger
 57 |   RandomDoubleCoercedToZero
 58 |   RemoveAllOnSelf
 59 |   ReturnFromFinallyBlock
 60 |   ThrowExceptionFromFinallyBlock
 61 | 
 62 |   // rulesets/braces.xml
 63 |   ElseBlockBraces
 64 |   ForStatementBraces
 65 |   IfStatementBraces
 66 |   WhileStatementBraces
 67 | 
 68 |   // rulesets/concurrency.xml
 69 |   /*
 70 |   BusyWait
 71 |   DoubleCheckedLocking
 72 |   InconsistentPropertyLocking
 73 |   InconsistentPropertySynchronization
 74 |   NestedSynchronization
 75 |   StaticCalendarField
 76 |   StaticConnection
 77 |   StaticDateFormatField
 78 |   StaticMatcherField
 79 |   StaticSimpleDateFormatField
 80 |   SynchronizedMethod
 81 |   SynchronizedOnBoxedPrimitive
 82 |   SynchronizedOnGetClass
 83 |   SynchronizedOnReentrantLock
 84 |   SynchronizedOnString
 85 |   SynchronizedOnThis
 86 |   SynchronizedReadObjectMethod
 87 |   SystemRunFinalizersOnExit
 88 |   ThisReferenceEscapesConstructor
 89 |   ThreadGroup
 90 |   ThreadLocalNotStaticFinal
 91 |   ThreadYield
 92 |   UseOfNotifyMethod
 93 |   VolatileArrayField
 94 |   VolatileLongOrDoubleField
 95 |   WaitOutsideOfWhileLoop
 96 |   */
 97 | 
 98 |   // rulesets/convention.xml
 99 |   ConfusingTernary
100 |   CouldBeElvis
101 |   HashtableIsObsolete
102 |   IfStatementCouldBeTernary
103 |   InvertedIfElse
104 |   LongLiteralWithLowerCaseL
105 |   ParameterReassignment
106 |   TernaryCouldBeElvis
107 |   VectorIsObsolete
108 | 
109 |   // rulesets/design.xml
110 |   /*
111 |   AbstractClassWithPublicConstructor
112 |   AbstractClassWithoutAbstractMethod
113 |   BooleanMethodReturnsNull
114 |   BuilderMethodWithSideEffects
115 |   CloneableWithoutClone
116 |   CloseWithoutCloseable
117 |   CompareToWithoutComparable
118 |   ConstantsOnlyInterface
119 |   EmptyMethodInAbstractClass
120 |   FinalClassWithProtectedMember
121 |   ImplementationAsType
122 |   LocaleSetDefault
123 |   PrivateFieldCouldBeFinal
124 |   PublicInstanceField
125 |   ReturnsNullInsteadOfEmptyArray
126 |   ReturnsNullInsteadOfEmptyCollection
127 |   SimpleDateFormatMissingLocale
128 |   StatelessSingleton
129 |   */
130 | 
131 |   // rulesets/dry.xml
132 |   /*
133 |   DuplicateListLiteral
134 |   DuplicateMapLiteral
135 |   DuplicateNumberLiteral
136 |   DuplicateStringLiteral
137 |   */
138 | 
139 |   // rulesets/enhanced.xml
140 |   /*
141 |   CloneWithoutCloneable
142 |   JUnitAssertEqualsConstantActualValue
143 |   UnsafeImplementationAsMap
144 |   */
145 | 
146 |   // rulesets/exceptions.xml
147 |   /*
148 |   CatchArrayIndexOutOfBoundsException
149 |   CatchError
150 |   CatchException
151 |   CatchIllegalMonitorStateException
152 |   CatchIndexOutOfBoundsException
153 |   CatchNullPointerException
154 |   CatchRuntimeException
155 |   CatchThrowable
156 |   ConfusingClassNamedException
157 |   ExceptionExtendsError
158 |   ExceptionNotThrown
159 |   MissingNewInThrowStatement
160 |   ReturnNullFromCatchBlock
161 |   SwallowThreadDeath
162 |   ThrowError
163 |   ThrowException
164 |   ThrowNullPointerException
165 |   ThrowRuntimeException
166 |   ThrowThrowable
167 |   */
168 | 
169 |   // rulesets/formatting.xml
170 |   BracesForClass
171 |   BracesForForLoop
172 |   BracesForIfElse
173 |   BracesForMethod
174 |   BracesForTryCatchFinally
175 |   //ClassJavadoc
176 |   ClosureStatementOnOpeningLineOfMultipleLineClosure
177 |   FileEndsWithoutNewline
178 |   LineLength
179 |   MissingBlankLineAfterImports
180 |   MissingBlankLineAfterPackage
181 |   SpaceAfterCatch
182 |   SpaceAfterClosingBrace
183 |   SpaceAfterComma
184 |   SpaceAfterFor
185 |   SpaceAfterIf
186 |   SpaceAfterOpeningBrace
187 |   SpaceAfterSemicolon
188 |   SpaceAfterSwitch
189 |   SpaceAfterWhile
190 |   SpaceAroundClosureArrow
191 |   SpaceAroundMapEntryColon
192 |   SpaceAroundOperator
193 |   SpaceBeforeClosingBrace
194 |   SpaceBeforeOpeningBrace
195 | 
196 |   // rulesets/generic.xml
197 |   /*
198 |   IllegalClassMember
199 |   IllegalClassReference
200 |   IllegalPackageReference
201 |   IllegalRegex
202 |   IllegalString
203 |   RequiredRegex
204 |   RequiredString
205 |   StatelessClass
206 |   */
207 | 
208 |   // rulesets/grails.xml
209 |   /*
210 |   GrailsDomainHasEquals
211 |   GrailsDomainHasToString
212 |   GrailsDomainReservedSqlKeywordName
213 |   GrailsDomainWithServiceReference
214 |   GrailsDuplicateConstraint
215 |   GrailsDuplicateMapping
216 |   GrailsPublicControllerMethod
217 |   GrailsServletContextReference
218 |   GrailsSessionReference   // DEPRECATED
219 |   GrailsStatelessService
220 |   */
221 | 
222 |   // rulesets/groovyism.xml
223 |   AssignCollectionSort
224 |   AssignCollectionUnique
225 |   ClosureAsLastMethodParameter
226 |   CollectAllIsDeprecated
227 |   ConfusingMultipleReturns
228 |   ExplicitArrayListInstantiation
229 |   ExplicitCallToAndMethod
230 |   ExplicitCallToCompareToMethod
231 |   ExplicitCallToDivMethod
232 |   ExplicitCallToEqualsMethod
233 |   ExplicitCallToGetAtMethod
234 |   ExplicitCallToLeftShiftMethod
235 |   ExplicitCallToMinusMethod
236 |   ExplicitCallToModMethod
237 |   ExplicitCallToMultiplyMethod
238 |   ExplicitCallToOrMethod
239 |   ExplicitCallToPlusMethod
240 |   ExplicitCallToPowerMethod
241 |   ExplicitCallToRightShiftMethod
242 |   ExplicitCallToXorMethod
243 |   ExplicitHashMapInstantiation
244 |   ExplicitHashSetInstantiation
245 |   ExplicitLinkedHashMapInstantiation
246 |   ExplicitLinkedListInstantiation
247 |   ExplicitStackInstantiation
248 |   ExplicitTreeSetInstantiation
249 |   GStringAsMapKey
250 |   GStringExpressionWithinString
251 |   GetterMethodCouldBeProperty
252 |   GroovyLangImmutable
253 |   UseCollectMany
254 |   UseCollectNested
255 | 
256 |   // rulesets/imports.xml
257 |   DuplicateImport
258 |   ImportFromSamePackage
259 | //  ImportFromSunPackages
260 | //  MisorderedStaticImports
261 |   UnnecessaryGroovyImport
262 |   UnusedImport
263 | 
264 |   // rulesets/jdbc.xml
265 |   /*
266 |   DirectConnectionManagement
267 |   JdbcConnectionReference
268 |   JdbcResultSetReference
269 |   JdbcStatementReference
270 |   */
271 | 
272 |   // rulesets/junit.xml
273 |   /*
274 |   ChainedTest
275 |   CoupledTestCase
276 |   JUnitAssertAlwaysFails
277 |   JUnitAssertAlwaysSucceeds
278 |   JUnitFailWithoutMessage
279 |   JUnitLostTest
280 |   JUnitPublicField
281 |   JUnitPublicNonTestMethod
282 |   JUnitSetUpCallsSuper
283 |   JUnitStyleAssertions
284 |   JUnitTearDownCallsSuper
285 |   JUnitTestMethodWithoutAssert
286 |   JUnitUnnecessarySetUp
287 |   JUnitUnnecessaryTearDown
288 |   JUnitUnnecessaryThrowsException
289 |   SpockIgnoreRestUsed
290 |   UnnecessaryFail
291 |   UseAssertEqualsInsteadOfAssertTrue
292 |   UseAssertFalseInsteadOfNegation
293 |   UseAssertNullInsteadOfAssertEquals
294 |   UseAssertSameInsteadOfAssertTrue
295 |   UseAssertTrueInsteadOfAssertEquals
296 |   UseAssertTrueInsteadOfNegation
297 |   */
298 | 
299 |   // rulesets/logging.xml
300 |   /*
301 |   LoggerForDifferentClass
302 |   LoggerWithWrongModifiers
303 |   LoggingSwallowsStacktrace
304 |   MultipleLoggers
305 |   PrintStackTrace
306 |   Println
307 |   SystemErrPrint
308 |   SystemOutPrint
309 |   */
310 | 
311 |   // rulesets/naming.xml
312 |   AbstractClassName
313 |   ClassName {
314 |     regex = '^[A-Z][\\$a-zA-Z0-9]*(?<!Test)'
315 |   }
316 |   ClassNameSameAsFilename
317 | //  ConfusingMethodName
318 | //  FactoryMethodName
319 |   FieldName {
320 |     regex = '^_?[a-z][a-zA-Z0-9]*$'
321 |     finalRegex = '^_?[a-z][a-zA-Z0-9]*$'
322 |     staticFinalRegex = '^logger$|^[A-Z][A-Z_0-9]*$|^serialVersionUID$'
323 |   }
324 |   InterfaceName
325 |   MethodName {
326 |     regex = '^[a-z][\\$_a-zA-Z0-9]*$|^.*\\s.*$'
327 |   }
328 |   ObjectOverrideMisspelledMethodName
329 |   PackageName
330 |   ParameterName
331 |   PropertyName
332 |   VariableName {
333 |     finalRegex = '^[a-z][a-zA-Z0-9]*$'
334 |   }
335 | 
336 |   // rulesets/security.xml
337 |   /*
338 |   FileCreateTempFile
339 |   InsecureRandom
340 |   JavaIoPackageAccess
341 |   NonFinalPublicField
342 |   NonFinalSubclassOfSensitiveInterface
343 |   ObjectFinalize
344 |   PublicFinalizeMethod
345 |   SystemExit
346 |   UnsafeArrayDeclaration
347 |   */
348 | 
349 |   // rulesets/serialization.xml
350 |   /*
351 |   EnumCustomSerializationIgnored
352 |   SerialPersistentFields
353 |   SerialVersionUID
354 |   SerializableClassMustDefineSerialVersionUID
355 |   */
356 | 
357 |   // rulesets/size.xml
358 |   /*
359 |   AbcComplexity   // DEPRECATED: Use the AbcMetric rule instead. Requires the GMetrics jar
360 |   AbcMetric   // Requires the GMetrics jar
361 |   ClassSize
362 |   CrapMetric   // Requires the GMetrics jar and a Cobertura coverage file
363 |   CyclomaticComplexity   // Requires the GMetrics jar
364 |   MethodCount
365 |   MethodSize
366 |   NestedBlockDepth
367 |   */
368 | 
369 |   // rulesets/unnecessary.xml
370 |   AddEmptyString
371 |   ConsecutiveLiteralAppends
372 |   ConsecutiveStringConcatenation
373 |   UnnecessaryBigDecimalInstantiation
374 |   UnnecessaryBigIntegerInstantiation
375 | //  UnnecessaryBooleanExpression
376 |   UnnecessaryBooleanInstantiation
377 | //  UnnecessaryCallForLastElement
378 |   UnnecessaryCallToSubstring
379 |   UnnecessaryCatchBlock
380 | //  UnnecessaryCollectCall
381 |   UnnecessaryCollectionCall
382 |   UnnecessaryConstructor
383 |   UnnecessaryDefInFieldDeclaration
384 | //  UnnecessaryDefInMethodDeclaration
385 |   UnnecessaryDefInVariableDeclaration
386 |   UnnecessaryDotClass
387 |   UnnecessaryDoubleInstantiation
388 |   UnnecessaryElseStatement
389 |   UnnecessaryFinalOnPrivateMethod
390 |   UnnecessaryFloatInstantiation
391 | //  UnnecessaryGString
392 |   UnnecessaryGetter
393 |   UnnecessaryIfStatement
394 |   UnnecessaryInstanceOfCheck
395 |   UnnecessaryInstantiationToGetClass
396 |   UnnecessaryIntegerInstantiation
397 |   UnnecessaryLongInstantiation
398 |   UnnecessaryModOne
399 |   UnnecessaryNullCheck
400 |   UnnecessaryNullCheckBeforeInstanceOf
401 |   UnnecessaryObjectReferences
402 |   UnnecessaryOverridingMethod
403 |   UnnecessaryPackageReference
404 |   UnnecessaryParenthesesForMethodCallWithClosure
405 | //  UnnecessaryPublicModifier
406 | //  UnnecessaryReturnKeyword
407 | //  UnnecessarySelfAssignment
408 |   UnnecessarySemicolon
409 |   UnnecessaryStringInstantiation
410 | //  UnnecessarySubstring
411 |   UnnecessaryTernaryExpression
412 |   UnnecessaryTransientModifier
413 | 
414 |   // rulesets/unused.xml
415 |   UnusedArray
416 | //  UnusedMethodParameter
417 | //  UnusedObject
418 |   UnusedPrivateField
419 |   UnusedPrivateMethod
420 |   UnusedPrivateMethodParameter
421 |   UnusedVariable
422 | }
423 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 
203 | 


--------------------------------------------------------------------------------
/spring-capgemini-core/src/main/java/com/capgemini/boot/core/factory/internal/SettingBackedBeanFactoryPostProcessor.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Copyright 2015 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 | 
 17 | package com.capgemini.boot.core.factory.internal;
 18 | 
 19 | import com.capgemini.boot.core.factory.FactoryProcessorStrategy;
 20 | import com.capgemini.boot.core.factory.SettingsResolver;
 21 | import org.springframework.beans.BeansException;
 22 | import org.springframework.beans.factory.config.BeanDefinition;
 23 | import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 24 | import org.springframework.beans.factory.config.ConstructorArgumentValues;
 25 | import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 26 | import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
 27 | import org.springframework.beans.factory.support.GenericBeanDefinition;
 28 | import org.springframework.context.ApplicationContext;
 29 | import org.springframework.context.ApplicationContextAware;
 30 | import org.springframework.context.EnvironmentAware;
 31 | import org.springframework.core.env.ConfigurableEnvironment;
 32 | import org.springframework.core.env.Environment;
 33 | 
 34 | import java.lang.reflect.InvocationTargetException;
 35 | import java.lang.reflect.Method;
 36 | import java.util.*;
 37 | 
 38 | /**
 39 |  * Finds all SettingsBackedBeanFactory beans, and registers SettingBackedBean bean definitions if factory methods exist.
 40 |  *
 41 |  */
 42 | public class SettingBackedBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor, ApplicationContextAware, EnvironmentAware {
 43 | 
 44 |     private ApplicationContext applicationContext;
 45 |     
 46 |     private ConfigurableEnvironment environment;
 47 |     
 48 |     private ExceptionFactory exceptionFactory;
 49 |     
 50 |     private SettingsResolver settingsResolver;
 51 |     
 52 |     private FactoryProcessorStrategy processorStrategy;
 53 |     
 54 |     //A cache of different settings classes so that each only has to be created once
 55 |     private Map<Class<?>, Object> settingsCache = new HashMap<Class<?>, Object>();
 56 |     
 57 |     @Override
 58 |     public void setApplicationContext(ApplicationContext applicationContext)
 59 |             throws BeansException {
 60 |         this.applicationContext = applicationContext;
 61 |         
 62 |     }
 63 |     
 64 |     @Override
 65 |     public void setEnvironment(Environment environment) {
 66 |         this.environment = (ConfigurableEnvironment) environment;
 67 |     }
 68 |     
 69 |     @Override
 70 |     public void postProcessBeanDefinitionRegistry(
 71 |             BeanDefinitionRegistry registry) throws BeansException {
 72 |         final String[] factoryBeanNames = getProcessorStrategy().getFactoryBeanNames(applicationContext);
 73 |         
 74 |         for (String factoryBeanName : factoryBeanNames) {
 75 |             registerSettingBackedBeansForFactory(factoryBeanName, registry);
 76 |         }
 77 |     }
 78 | 
 79 |     @Override
 80 |     public void postProcessBeanFactory(
 81 |             ConfigurableListableBeanFactory beanFactory) throws BeansException {
 82 |         //Do nothing
 83 |         
 84 |     }
 85 |     
 86 |     protected Object getSettings(Class<?> settingsClass, String prefix) {
 87 |         if (!this.settingsCache.containsKey(settingsClass)) {
 88 |             this.settingsCache.put(settingsClass, resolveSettings(settingsClass, prefix));
 89 |         }
 90 |         
 91 |         return this.settingsCache.get(settingsClass);
 92 |     }
 93 |     
 94 |     protected ExceptionFactory getExceptionFactory() {
 95 |         if (exceptionFactory == null) {
 96 |             exceptionFactory = new DefaultExceptionFactory();
 97 |         }
 98 |         
 99 |         return exceptionFactory;
100 |     }
101 |     
102 |     protected SettingsResolver getSettingsResolver() {
103 |         if (settingsResolver == null) {
104 |             //Check if a settings resolver bean exists, otherwise use spring boot resolver            
105 |             if (!applicationContext.getBeansOfType(SettingsResolver.class).isEmpty()) {
106 |                 settingsResolver = applicationContext.getBean(SettingsResolver.class);
107 |             } else {
108 |                 settingsResolver = new SpringBootSettingsResolver();
109 |             }
110 |         }
111 |         return settingsResolver;
112 |     }
113 |     
114 |     protected FactoryProcessorStrategy getProcessorStrategy() {
115 |         if (processorStrategy == null) {
116 |             //Check if an processor strategy bean exists, otherwise use default annotation strategy
117 |             if (!applicationContext.getBeansOfType(FactoryProcessorStrategy.class).isEmpty()) {
118 |                 processorStrategy = applicationContext.getBean(FactoryProcessorStrategy.class);
119 |             } else {
120 |                 processorStrategy = new DefaultAnnotationStrategy();
121 |             }
122 |         }
123 |         
124 |         return processorStrategy;
125 |     }
126 |     
127 |     private void registerSettingBackedBeansForFactory(String settingsBackedBeanFactoryName, BeanDefinitionRegistry registry) {   
128 |         final Class<?> factoryClass = getClassForBeanName(settingsBackedBeanFactoryName, registry);
129 |         
130 |         //Get settings class and prefix from factory
131 |         final Class<?> settingsClass = getProcessorStrategy().getSettingsClass(factoryClass);
132 |         final String settingPrefix = getProcessorStrategy().getSettingPrefix(factoryClass);
133 |         
134 |         //Get all bean factory methods in this settings backed bean factory.
135 |         //Map of setting name to list of methods
136 |         final Map<String, List<Method>> settingBackedBeanMethods = getSettingBackedBeanMethods(factoryClass);
137 |         
138 |         //For each setting that is mapped to a factory method, register beans
139 |         for (String settingName : settingBackedBeanMethods.keySet()) {
140 |             registerSettingBackedBeansForSetting(getSettings(settingsClass, settingPrefix), settingName, 
141 |                     settingsBackedBeanFactoryName, settingBackedBeanMethods.get(settingName), registry);
142 |         }
143 |         
144 |     }
145 |     
146 |     private void registerSettingBackedBeansForSettingInstanceValue(Object settings, String settingInstanceName, Object settingInstanceValue, 
147 |             String settingsBackedBeanFactoryName, List<Method> linkedSCBMethods, BeanDefinitionRegistry registry) {
148 |         
149 |         //Register a bean for each factory method that is linked with the setting, within this factory bean,
150 |         for (Method settingBackedBeanMethod : linkedSCBMethods) {
151 |             
152 |             //Obtain nameSuffix
153 |             final String nameSuffix = getProcessorStrategy().getBeanNameSuffix(settingBackedBeanMethod);
154 |             
155 |             final BeanDefinition beanDefinition = createBeanDefinition(settings, settingInstanceValue, 
156 |                     settingsBackedBeanFactoryName, settingBackedBeanMethod);
157 |         
158 |             registry.registerBeanDefinition(settingInstanceName + nameSuffix, beanDefinition);
159 |         }
160 |     }
161 |     
162 |     private Class<?> getClassForBeanName(String beanName, BeanDefinitionRegistry registry) {
163 |         final String factoryClassName = registry.getBeanDefinition(beanName).getBeanClassName();
164 |         
165 |         try {
166 |             return Class.forName(factoryClassName);
167 |         } catch (ClassNotFoundException e) {
168 |             throw getExceptionFactory().createGenericException("Bean class cannot be found", e);
169 |         }
170 |     }
171 |     
172 |     private BeanDefinition createBeanDefinition(Object settings, Object setting, String factoryBeanName, Method factoryMethod) {
173 |         final GenericBeanDefinition definition = new GenericBeanDefinition();
174 |         definition.setFactoryBeanName(factoryBeanName);
175 |         definition.setFactoryMethodName(factoryMethod.getName());
176 |         
177 |         //Create method arguments (confusingly called constructor arguments in spring)
178 |         final ConstructorArgumentValues arguments = new ConstructorArgumentValues();
179 |         arguments.addIndexedArgumentValue(0, setting);
180 |         
181 |         final int parameterCount = factoryMethod.getParameterTypes().length;
182 |         if (parameterCount == 2) {
183 |             arguments.addIndexedArgumentValue(1, settings);
184 |         } else if (parameterCount > 2) {
185 |             throw getExceptionFactory().createInvalidArgumentsException(factoryMethod);
186 |         }
187 |         
188 |         //TODO more checking of method arguments to ensure they're correct
189 |         
190 |         definition.setConstructorArgumentValues(arguments);
191 | 
192 |         return definition;
193 |     }
194 |         
195 |     @SuppressWarnings({ "unchecked", "rawtypes" })
196 |     private void registerSettingBackedBeansForSetting(Object settings, String settingName, 
197 |             String settingsBackedRegistrarBeanName, List<Method> linkedSCBMethods, BeanDefinitionRegistry registry) {
198 |         
199 |         try {
200 |             //Get getter method for setting
201 |             final Method settingGetter = settings.getClass().getMethod(getGetterMethodForSetting(settingName));
202 |             final Object returnedSetting = settingGetter.invoke(settings);
203 |             
204 |             //TODO provide a 'SettingBackedBeanDefinitionStrategy' interface to allow customization of how a
205 |             //setting (depending on the type) is converted into bean definition(s)
206 |             //Check type of returned setting
207 |             if (returnedSetting instanceof Map) {
208 |                 final Map<String, Object> settingInstanceValues = (Map) returnedSetting;
209 |                 
210 |                 //For each instance of setting, invoke all setting backed bean factory methods
211 |                 for (String settingInstanceName : settingInstanceValues.keySet()) {
212 |                     final Object settingInstanceValue = settingInstanceValues.get(settingInstanceName);
213 |                     registerSettingBackedBeansForSettingInstanceValue(settings, settingInstanceName, settingInstanceValue, 
214 |                             settingsBackedRegistrarBeanName, linkedSCBMethods, registry);
215 |                 }
216 |             } else if (returnedSetting instanceof Collection) {
217 |                 final Collection<Object> settingInstanceValues = (Collection) returnedSetting;
218 |                 
219 |                 int countForName = 0;
220 |                 for (Object settingInstanceValue : settingInstanceValues) {
221 |                     countForName++;
222 |                     registerSettingBackedBeansForSettingInstanceValue(settings, Integer.toString(countForName), settingInstanceValue, settingsBackedRegistrarBeanName, linkedSCBMethods, registry);
223 |                 }
224 |             } else {
225 |                 //Setting is not a collection, so treat as a single instance
226 |                 registerSettingBackedBeansForSettingInstanceValue(settings, "", returnedSetting, settingsBackedRegistrarBeanName, linkedSCBMethods, registry);
227 |             }
228 |         } catch (NoSuchMethodException e) {
229 |             throw getExceptionFactory().createNoMatchingSettingException(settingName);
230 |         } catch (SecurityException e) {
231 |             throw getExceptionFactory().createGenericException("An exception occured when obtaining setting named " + settingName, e);
232 |         } catch (IllegalAccessException e) {
233 |             throw getExceptionFactory().createSettingAccessException(settingName);
234 |         } catch (IllegalArgumentException e) {
235 |             throw getExceptionFactory().createSettingArgumentsException(settingName);
236 |         } catch (InvocationTargetException e) {
237 |             throw getExceptionFactory().createGenericException("An exception occured when obtaining setting named " + settingName, e);
238 |         }
239 |     }    
240 | 
241 |     private String getGetterMethodForSetting(String settingName) {
242 |         //Convert first letter of name to uppercase
243 |         final char first = Character.toUpperCase(settingName.charAt(0));
244 |         return "get" + first + settingName.substring(1);
245 |     }
246 |     
247 |     private Map<String, List<Method>> getSettingBackedBeanMethods(Class<?> clazz) {
248 |         final Map<String, List<Method>> settingMethods = new HashMap<String, List<Method>>();
249 |         
250 |         for (Method method : clazz.getDeclaredMethods()) {
251 |             if (getProcessorStrategy().isFactoryMethod(method)) {
252 |                 final String setting = getProcessorStrategy().getSettingName(method);
253 |                 
254 |                 if (!settingMethods.containsKey(setting)) {
255 |                     settingMethods.put(setting, new ArrayList<Method>());
256 |                 }
257 |                 
258 |                 settingMethods.get(setting).add(method);
259 |             }
260 |         }
261 |         
262 |         return settingMethods;
263 |     }
264 | 
265 |     private <T> T  resolveSettings(Class<T> settingsClass, String prefix) {
266 |         return getSettingsResolver().resolveSettings(settingsClass, prefix, environment);
267 |     }
268 | }
269 | 


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