/rhcbootcamp

modified from repo of @justincohler

Primary LanguageHTMLApache License 2.0Apache-2.0

Associate Consultant Bootcamp

##Prerequisites## ###Accounts### Each new hire will need to set up the following accounts to start the lab content provided in this repository.

###Installations### Each new hire will need the following installations downloaded and unzipped prior to the start of the New Hire Bootcamp.

Install URL
Java Development Kit 7 OpenJDK, Oracle JDK
Apache Maven (Latest) link
Git link
Tomcat 7.0 link link2
JBoss BPM Suite 6.1.0 link
OpenShift Command Line Tools link
MongoDB 2.6 link

##Day 1 - OpenShift Application Management## ###Goals###

  1. Learn how to use OpenShift Online to enable quick POCs (Proof-of-Concepts)
  2. To get familiar with both the UI and CLI experience in OpenShift
  3. To get familiar with the format for the lab content in the remaining days of the Bootcamp

###Instructions###

  1. Run the following commands on the command line to create a new EWS (Enterprise Web Server) project called "nchlab" with large gears in OpenShift:
	rhc app-create nchlab jbossews-2.0 -g large

These commands will output the generated credentials and locations for the OpenShift Git repository our application will use. Save this information in a text file for safekeeping.

If you don't have large gears available, the other options are small and medium, however large gears are recommended.

  1. Enter the newly cloned git directory
	cd nchlab/
  1. Connect the starter code on GitHub to the OpenShift repository:
	git remote add upstream -m master git://github.com/justincohler/nch-bootcamp.git 
	git pull -s recursive -X theirs upstream master
  • An editor will ask you to enter a merge message. Enter the following to (w)rite the merge record and (q)uit out of the editor:
		> :wq
  1. Finally, push the starter code to OpenShift:
	git push

The code will be pushed to OpenShift, where OpenShift will run a Maven build on the project, copy the built deployment into the JBoss EWS container, and start the container.

  1. In your browser, navigate to https://nchlab-YOURDOMAIN.rhcloud.com/
    • You now have a web application running business rules and Camel services on top of a MongoDB database!

Now we will import the projects from the "nchlab" repository into the JBDS (JBoss Developer Studio) IDE.

  1. Start JBDS and once you have opened a workspace, click File->Import...
  2. In the Import wizard, Expand the "Maven" folder, and click "Existing Maven Projects"
  3. Select the directory where you cloned your nchlab repository.
  4. Select all the projects in the parent directory, and complete the wizard. In the Project Editor, you should have 9 projects imported.
  5. Right click on the "lab" project, then click Run As->Maven Build...
  6. In the Build popup, enter:
    • Goals: clean install
    • Profiles: openshift
  7. Click 'Run' to perform the Maven build and ensure that the project build is successful.

Now let's set up a local server to test out our application.

  1. Make sure that you have locally installed Tomcat 7.0.x and have a local MongoDB database running.
    • Instructions for MongoDB installation are located here. Version 2.6 is preferred, but installing v3.0 should work fine as well.
  2. In the "Servers" view of JBDS, right click and click on New->Server...
  3. In the following dialogues, select a new Tomcat 7 server and point to the Tomcat installation on your machine.
  4. On the "Add and Remove" screen, add the lab-web project in the "Available" column to the "Configured" column and click finish.
  5. In the web.xml of the lab-web project, under the "spring.profiles.active" context-param, change "openshift" to "default" to switch the Spring profile to your local configuration.
  6. Right click on the lab-web project in the Project Editor and click "Properties".
  7. Click into the Web Project Settings Properties menu on the left and set the Context root to "/". (Without quotes)
  8. Start the new server by right clicking on the new server and clicking "Start"
  9. Point to localhost:8080/ in your web browser and you should have the application running on your local machine with a local database.

##Day 2 - Business Rules and Process Modeling## ###Goals###

  1. To get familiar with BDD (Behavior-Driven-Development) by using the Cucumber test Framework
  2. Learn how to write Business Rules, and touch integration endpoints in Business Processes

###Note### All exercises in the code are marked by the 'XXX' label, which shows up by default in the JBDS Tasks view. To expose this view in JBDS, in the top toolbar, click Window->Show View->Other..., and under "General", open "Tasks".

You can also search for 'XXX' in the File Search. In JBDS, in the top toolbar, click Search->File... and search on "XXX" in the "Containing Text" field.

###Instructions###

  1. To check out today's repository branch, pull all of the branches from the upstream bootcamp repository into the directory you created yesterday:
	git fetch upstream
  1. Next, checkout the Day 2 branch of the bootcamp repository:
	git checkout day2
  1. Open JBDS and build the project as you did yesterday. Note that the tests run in the project are skipped during the build.

The first goal of the day is to learn some basic concepts of BDD. Cucumber is a popular BDD tool we use frequently on projects. The framework uses text files containing application "features", and connects the steps of each feature to a corresponding JUnit test, called a "step". There are a number of test features found in the following location:

	lab-test-harness/src/test/resources/features/lab.feature

The JUnit tests which implement these features are found at the following location:

	lab-test-harness/src/test/java/com/rhc/lab/test/cucumber/BaseSteps.java
  1. To start today's exercises inside of BaseSteps.java, there are two methods which have to be implemented. They are marked by the 'XXX' comment. Fill in each of these methods according to the instructions in the comments, and run the following Cucumber test to verify your results:
	lab-test-harness/src/test/java/com/rhc/lab/test/cucumber/RunCukesTest.java

* In the Junit window, the features should still fail, but the "Given" steps should all pass successfully. Why is this the case?

The second goal of the day is to get some practice writing business rules in the Drools Rules Language.

  1. You will implement the rules that will confirm or revoke a venue booking request. Locate the business rules at the following location:
	lab-knowledge/src/main/resources/rules/createBooking.drl
  1. Several empty rules have to be implemented. They are marked by the 'XXX' comments. Fill in each of these rules according to the instructions in the comments, and run RunCukesTest.java to verify the rules pass the features written. At this point the rules will not pass. Take a look at the Business Process Model found at the following location to ensure the ruleflow groups are defined correctly:
	lab-knowledge/src/main/resources/rules/bookingProcess.bpmn2
  1. Run the RunCukesTest.java again to make sure all features are passing, and throw in some log print lines to ensure your steps are executing as expected.
  2. Verify the project builds successfully by running a Maven build.
  3. Once the project builds, make sure that your local application can save booking requests.
  4. Then run the following Git commands to commit the files to your local repository and push the new code to your OpenShift instance:
	git add . 
	git commit -m "YOUR COMMIT MESSAGE" 
	git push origin master

Your application is now back to a known good state and you've completed the exercises for Day 2. If you have time left over, add some features to the lab.feature file and create some rules of your own.

##Day 3 - Integrating Services with Camel## ###Goals###

  1. Learn how to write Camel routes for code-less integration

###Instructions

  1. To check out today's repository branch, pull all of the branches from the upstream bootcamp repository into the directory you created yesterday:
	git fetch upstream
  1. Next, checkout the Day 3 branch of the bootcamp repository:
	git checkout day3
  1. Open JBDS and build the project as you did yesterday. The project should now fail to build.

The goal for today is to create a Camel route that takes a BookingRequest object created by a web form in the UI, runs that request through a series of business rules, and saves a confirmed Booking object to a MongoDB database. The Camel context, which defines the route we will be writing is found at the following location:

	lab-camel-services/src/main/resources/camel-context.xml

You will also be tasked with configuring the camel context in the servlet container. The web.xml for the project is found at the following location:

	lab-web/src/main/webapp/WEB-INF/web.xml

For reference, read through this example on Camel in web applications.

In this branch, there are a series of exercises marked by the "XXX" marker describing the components needed to implement the route described above. Complete the marked exercises and then test the application locally and in your OpenShift instance:

  1. Verify the project builds successfully by running a Maven build.
  2. Once the project builds, make sure that your local application can save booking requests.
  3. Then run the following Git commands to commit the files to your local repository and push the new code to your OpenShift instance:
	git add . 
	git commit -m "YOUR COMMIT MESSAGE" 
	git push origin master

##Day 4 - Continuous Integration and Delivery## ###Goals###

  1. Learn how to add and use plugins in Jenkins
  2. Using newfound BDD knowledge, add features, step code, and rules to the existing codebase

###Instructions### Today we will set up a local Jenkins instance to build and test our project.

  1. Download the latest Jenkins WAR (Web Archive) here or get our USB copy.
  2. Download the EAP 6.4.0 Zip archive and unzip (or get our USB copy).
  3. Drop the jenkins.war file inside the $EAP_HOME/standalone/deployments directory.
  4. Create an empty file in the deployments directory suffixed with "dodeploy" with the following command:
	touch jenkins.war.dodeploy

This will tell the EAP server to deploy this application on startup of the container.

  1. Start the server and navigate to http://localhost:8080/jenkins. (Make sure your tomcat instance isn't running. If so, you will have port conflict issues).
  2. Navigate to the Manage Jenkins screen.
  3. In the list of options on the management screen, click "Manage Plugins" (http://localhost:8080/jenkins/pluginManager).
  4. Since this is the first time we're adding plugins, go to the "Advanced" tab of the Plugin Manager and in the bottom right corner, click "Check now" to update the list of available plugins.
  5. Once the check has completed, navigate to the "Available" tab and select the "Cucumber Plugin", the "Cucumber Reports Plugin" and the "GitHub Plugin".
  6. Click "Install without Restart". Once the installations have completed, check the box to restart Jenkins when no builds are running.
  7. Navigate back to the homepage, and add a new Freestyle Software Job. This will take you to the configuration screen for the job.
  8. To pull in our source code, select the Git radio button on the job page and point to our GitHub master branch. Also add this to the Github field at the top of the job config.
  9. Add a new shell build step with a simple Maven install:
	mvn clean install
  1. At the bottom of the job page, add a new Post-build Action "Publish cucumber results as a report". Clicking the "Advanced" button in this action reveals granular settings that can set the build to fail if, for example, there are pending Cucumber steps. Which of these do you think could be useful for different phases of a development cycle?
  2. Click "Apply" then "Save" to ensure the changes are reflected, then rebuild the project with the "Build Now" button in the job page or on the homepage.

Now using the BDD knowledge gained in the morning presentations, implement the following example feature request:

	"We would like to add a feature where bands and orchestras cannot perform at a venue on the same day"

Attempt to add this functionality to your local master branch, or your working branch from yesterday.

##Day 5 - Breakfix Playground## ###Goals###

  1. Get familiar navigating a multi-module application to look for common breaks.

###Instructions###

  1. To check out today's repository branch, pull all of the branches from the upstream bootcamp repository into the directory you created yesterday:
	git fetch upstream
  1. Next, checkout the Day 5 branch of the bootcamp repository:
	git checkout day5
  1. Open JBDS and build the project as you did yesterday. The project should now fail to build.

Today's lab will be a series of breakfixes in our application. Several components are currently broken in the application, and it is your job to get the application back to the known good state. The "XXX" marker has been placed in several spots of the application with hints to get you on the right track. Use the 'File Search' functionality in JBDS to locate these markers and be sure to build with Maven frequently to determine the source of the errors.

  1. Verify the project builds successfully by running a Maven build.
  2. Once the project builds, make sure that your local application can save booking requests.
  3. Then run the following Git commands to commit the files to your local repository and push the new code to your OpenShift instance:
	git add . 
	git commit -m "YOUR COMMIT MESSAGE" 
	git push origin master