Continuous integration - Gitification/gitification GitHub Wiki
This page presents our Continuous Integration (CI) pipeline and technologies associated.
Scheme
This figure presents each steps of our continuous integration.
Technologies
This sections present each technologies used in the pipeline.
Node.js & Angular.js
Framework used on the developer side to create the server and client application.
Git
Our SVC is Git powered by GitHub.
Node module dependency management
Node offer a powerful module management for development. Two way can be used to install dependencies :
npm install
which will parsepackage.json
filenpm install [-g] name_of_module
where-g
indicate global install
The package.json
file contains meta information, project dependencies, licenses, issue reporting url, ... Refer to the documentation for more information.
Travis-CI
Continuous integration free service linked with GitHub through WebHook. Each time code is published with git push
, an event is sent to Travis-CI to start a new build test.
The build will checkout the specified version. Travis is guided by the .travis.yml
file in the root directory. It contains build information, build steps and notification. The build life-cycle is the following :
- Switch language runtime (e.g. C, Java, Node.js)
- Clone repository
- Run
before_install
commands cd
into repository directory and run dependency installation (npm install
for Node.js)- Run
before_script
commands - Run
test script
commands (npm test
for Node.js) - Run
after_success
/after_failure
commands - Run
after_script
commands
Each steps must exit with a status code 0
to execute the next (except for after_success
, after_failure
and after_scripts
). It is possible to extend build life-cycle, refer to the documentation for more information.
The following example shows a .travis.yml
file using Node.js, performing a build and testing. First, the language is indicating Node.js with a 0.8
version. Travis will use nvm
to get the correct version.
Then, it will run npm install
specific to Node.js environment. Once modules are successfully installed, the before_script
is ran. It install Grunt CLI globally. The testing phase executes npm test
which is defined in package.json
file (in this case, we run grunt travis --verbose
).
If an error occur during the build, an email is sent to the email recipient until the build is successful again.
---
language: node_js
node_js:
- 0.8
before_script:
- npm install -g grunt-cli
notifications:
email:
- '[email protected]'
This snippet is from package.json
file. It shows how to set the npm test
command.
{
"scripts": {
"test": "grunt travis --verbose"
}
}
Grunt
Grunt is a task runner based on plugins. It automates task execution using target similar to Maven of Make. The Gruntfile.js
specify plugin usage, loading and parameters. It registers tasks that can be used with the Grunt CLI command (installed with npm install -g grunt-cli
).
For our project, we used several tasks :
jshint
to execute a syntax checkwatch
to reload file when change occursvows-runner
to launchvows
BDD testsenv
to specify environment variableskarma
to test the client-side application
The travis
target executes, on the server code, env:dev
, jshint
and vows
. On the client code, it runs karma
.
Grunt has more than 800 plugin available, 23 officials the other being third-party. To find more plugins, refer to the plugin list on Grunt website.
SSH Deploy
To deploy our application, we chose to use Travis after_success
target. A well known program called Capistrano
could have been used but we chose to do it manually. First, the SSH private key to authenticate through RSA is required on Travis. The key is encoded with travis encrypt
on chunk of the SSH key. Encrypted content is stored into .travis.yml
in the environment section.
On the server, it will decrypt the SSH key, add it to the keychain and configure the server access. Then, it will connect on the server, checkout latest version with git
and manage server instance with forever
.
Refrences
- Specifics of npm's package.json handling
- Configuring your Travis CI build with .travis.yml
- Test-Driven Node.js Development With Grunt
- Effortless Continuous Integration and Deployment with Node.js, Travis CI & Capistrano
- Automated deployment of node.js apps
- Kick Ass Cross-Platform Workflow With Grunt
- Using secret api keys on travis-ci
- squeezing private SSH key into .travis.yml file