The following is a helpful Dataweave (2.0) code to allow you to extract cookie value coming in via Cookie header.
%dw 2.0
output application/java
---
(payload splitBy "; " map ($ splitBy "=") reduce (item, accum = {}) -> (accum ++ { (item[0]): item[1] })) ['csrftoken']
"PHPSESSID=413; csrftoken=444t4#tb3gg43; _gat=1"
444t4#tb3gg43| ''' | |
| Script to delete jobs and nested views in Jenkins CI including the parent view. | |
| This currently works when you have two-level nested views with jobs under the child view. | |
| Parent view | |
| - Child view 1 | |
| - Job 1 | |
| - Job 2 | |
| - Child view 2 | |
| - Job 3 | |
| - Job 4 | |
| The script will first delete all the jobs in child view, then proceed to delete the child view itself. | |
| Once all child views have been deleted, it will delete the parent view as last step. | |
| License: MIT | |
| ''' | |
| import sys | |
| import requests | |
| # Update Jenkins end-point here upto the context path for view with trailing slash | |
| jenkins_endpoint_url="http://localhost:8005/view/" | |
| ####################################### | |
| #### DONT MODIFY BELOW | |
| # First arg is username | |
| user = sys.argv[1] | |
| # Second arg is password | |
| passw = sys.argv[2] | |
| # Third arg is the view name | |
| view_to_delete = sys.argv[3] | |
| ''' | |
| Method to invoke REST-API call to delete jobs | |
| ''' | |
| def delete_job(job): | |
| del_job_req = requests.delete(job['url'], auth=(user, passw)) | |
| if(del_job_req.status_code == 200): | |
| print ">>>> Job " + job['name'] + " deleted successfully." | |
| else: | |
| print ">>>> Exception occurred deleting job. HTTP status code: " + str(del_job_req.status_code) | |
| sys.exit(); | |
| ''' | |
| Method to invoke REST-API call to delete views | |
| ''' | |
| def delete_view(view): | |
| request = requests.post(view['url'] + 'doDelete' , auth=(user, passw)) | |
| if(request.status_code == 200): | |
| print ">>>> View " + view['name'] + " deleted successfully." | |
| else: | |
| print ">>>> Exception occurred deleting view. HTTP status code: " + str(del_view_req.status_code) | |
| sys.exit() | |
| #### Start of script | |
| # Fetch list of all nested views | |
| nested_view_list_req = requests.get(jenkins_endpoint_url + view_to_delete + '/api/json', auth=(user, passw)) | |
| if(nested_view_list_req.status_code == 200): | |
| for app_view in nested_view_list_req.json()['views']: # Loop through each nested view | |
| print "Processing: " + app_view['name'] | |
| # Get each job under the nested views | |
| nested_view_req = requests.get(app_view['url'] + 'api/json', auth=(user, passw)) | |
| if(nested_view_req.status_code == 200): | |
| # Loop through each jobs in the nested view and delete them | |
| for jobs in nested_view_req.json()['jobs']: | |
| delete_job(jobs) | |
| print "Deleting nested view " + app_view['name'] + " now" | |
| # Delete each of the nested view | |
| delete_view(app_view) | |
| else: | |
| print "Unable to get list of jobs in the view. Error code: " + str(nested_view_list_req.status_code) | |
| if(nested_view_list_req.status_code == 200): | |
| print "Lastly deleting parent view: " + view_to_delete | |
| delete_view(nested_view_list_req.json()) | |
| print "All done" |
This script below allows you to compare properties files between environments.
If you maintain your application's externalised properties file in a seperate repository with a structure similar to below, you can use this to compare properties file between different environment.
compare-properties.groovy
|- src
| |- main
| | |- resources
| | | |- finance-app
| | | | |- dev
| | | | | |- application.properties
| | | | |- test
| | | | | |- application.properties
The script offers 2 mode for comparison. First is showing properties that missing in one or other environments. Second being the values of matching properties that are different.
Update the name of the properties file and the base path from where the script will be run:
def propertiesFileName = "application.properties"
def basePath = "src/main/resources"To run the script, place it at the root of the project and run by: groovy compare-properties.groovy
| /** | |
| * Usage: Run the script: groovy compare-properties.groovy | |
| * You will be prompted for application name (finance-app), source environment (eg. uat3) and target environment (prod) | |
| */ | |
| // Script configuration | |
| def propertiesFileName = 'application.properties' | |
| def basePath = 'src/main/resources' | |
| // End of script configuration - no more config below this point | |
| def applicationName, src, target, diffMode | |
| def allowedDiffModes = ['1', '2', '3'] | |
| if (args.length == 0) { | |
| diffMode = System.console().readLine 'Select mode: \n ' + | |
| 'Enter 1 to evaluate missing properties. \n ' + | |
| 'Enter 2 to evaluate value mismatches.\n ' + | |
| 'Enter 3 to find properties where values are duplicating. \n ' + | |
| 'Choice: ' | |
| if (!allowedDiffModes.contains(diffMode)) { | |
| println 'Invalid option selected' | |
| System.exit(0) | |
| } | |
| applicationName = System.console().readLine 'Enter application name: ' | |
| src = System.console().readLine 'Enter Source Environment: ' | |
| if (['1', '2'].contains(diffMode)) | |
| target = System.console().readLine 'Enter Target Environment: ' | |
| } else { | |
| diffMode = args[0] | |
| applicationName = args[1] | |
| src = args[2] | |
| target = args[3] | |
| } | |
| Properties srcProperties = new Properties() | |
| Properties targetProperties = new Properties() | |
| File srcPropertiesFile = new File("${basePath}/${applicationName}/${src}/${propertiesFileName}") | |
| File targetPropertiesFile = new File("${basePath}/${applicationName}/${target}/${propertiesFileName}") | |
| Closure loadPropertiesFromFile = { | |
| File propertiesFile, Properties loadIntoProps, String env, String appName -> | |
| if (env) { | |
| try { | |
| propertiesFile.withInputStream { | |
| loadIntoProps.load(it) | |
| } | |
| } | |
| catch (FileNotFoundException e) { | |
| println "Environment ${env} not defined for the application ${appName}. \nExiting script. \n" | |
| System.exit(0) | |
| } | |
| } | |
| } | |
| loadPropertiesFromFile(srcPropertiesFile, srcProperties, src, applicationName) | |
| loadPropertiesFromFile(targetPropertiesFile, targetProperties, target, applicationName) | |
| // Only the keys | |
| List srcPropListKeys = srcProperties.collect { return it.key } | |
| List targetPropListKeys = targetProperties.collect { return it.key } | |
| List srcPropList = srcProperties.collect { return ["${it.key}": it.value] } | |
| List targetPropList = targetProperties.collect { return ["${it.key}": it.value] } | |
| Closure evaluateMissingProps = { | |
| println "Properties in ${src} that are not in ${target}: " | |
| (srcPropListKeys - targetPropListKeys).size == 0 ? println(' None') : (srcPropListKeys - targetPropListKeys).each { | |
| println " ${it} \n" | |
| } | |
| println "\n" | |
| println "Properties in ${target} that not in ${src}:" | |
| (targetPropListKeys - srcPropListKeys).size == 0 ? println(' None') : (targetPropListKeys - srcPropListKeys).each { | |
| println " ${it} \n" | |
| } | |
| } | |
| Closure evaluateValueMismatches = { | |
| List diff = (srcPropList - targetPropList) | |
| println "${diff.size} properties in ${src} are different in ${target}: " | |
| diff.size == 0 ? println('None') : diff.each { | |
| it.each { k, v -> | |
| def targetProp = targetProperties.find { it.key == k } | |
| println "-----" | |
| println " $k " | |
| println "\t${src}\t: $v " | |
| println "\t${target}\t: ${targetProp?.value ? targetProp?.value : " ** DOES NOT EXIST IN: ${target}. ** "}" | |
| } | |
| } | |
| } | |
| Closure findDuplicatingProperties = { | |
| srcProperties.groupBy { it.value }.findAll { it.value.size() > 1 }?.each { | |
| it.value.each { println "${it.key}=${it.value}" } | |
| } | |
| } | |
| println '*********** START ***********' | |
| println "Number of properties in ${applicationName}/${src}: ${srcPropListKeys.size}\n" | |
| if (target) println "Number of properties in ${applicationName}/${target}: ${targetPropListKeys.size}\n" | |
| if (diffMode == '1') | |
| evaluateMissingProps() | |
| else if (diffMode == '2') | |
| evaluateValueMismatches() | |
| else if (diffMode == '3') | |
| findDuplicatingProperties() | |
| else | |
| throw new RuntimeException('Invalid mode selected...') | |
| println "\n *********** END *********** \n" |
~/.m2/settings.xml<settings>
<servers>
<server>
<id>dev-tomcat</id>
<username>tomcat</username>
<password>password</password>
</server>
</servers>
</settings>pom.xml<build>
.....
<finalName>my-webapp</finalName>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.1</version>
<configuration>
<url>http://localhost:8080/manager/html</url>
<server>dev-tomcat</server>
<path>/${project.build.finalName}</path>
</configuration>
</plugin>
</plugins>
</build>Here dev-server refers to the <server><id>dev-tomcat</id> defined in ~/.m2/settings.xml
Alternatively you can add the <username> and <password> under <configuration> in the pom.xml
<CATALINA_HOME>/conf/tomcat-users.xml with the role manager-script <role rolename="manager-script"/>
<user username="tomcat" password="tomcat" roles="manager-script"/>
````
4) To deploy to tomcat run: ```mvn tomcat7:deploy```
5) If your maven project has multiple modules such as below:
````
my-maven-project
|--my-app
-- pom.xml
|--my-webapp
-- pom.xml
-- pom.xml
````
The outermost pom.xml file should have at least the plugin reference:
````xml
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.0</version>
</plugin>
````
While the ```my-webapp/pom.xml``` producing the WAR file should have ``<configuration>`` element containing url, server and path child elements:
````xml
<configuration>
<update>true</update>
<url>http://localhost:8080/manager/text</url>
<server>dev-tomcat</server>
<path>/${project.build.finalName}</path>
</configuration>
````