Our Team is imple­men­ting Con­ti­nuous Inte­gra­ti­on in one of our major pro­jects. Imple­men­ting Con­ti­nuous Inte­gra­ti­on (CI) into a major and long run­ning auto­mo­ti­ve pro­ject is a lar­ge impro­ve­ment which dra­ma­ti­cal­ly rai­sed our efficiency.

When we crea­te CI not the brigh­test bulb in the box is to lea­ve pre­vious foun­da­ti­ons in ruins. It is best to get to know the pro­cess in detail from the tech­ni­cal side, con­duct sub­stan­ti­ve deba­tes with an expe­ri­en­ced per­son and, what is most neces­sa­ry, use the latest tech­no­lo­gi­cal solu­ti­ons. Once we have the com­ple­te pic­tu­re, we can break it down into smal­ler puz­zles. Some frag­ments are bet­ter left unch­an­ged and focus only on run­ning them. Ano­ther good prac­ti­ce is to take advan­ta­ge of a uni­ver­sal pro­gramming lan­guage like Python and an auto­ma­ti­on tool like Jenk­ins which has lots of plug­ins to sim­pli­fy the who­le process.

When we pre­cis­e­ly coll­ect all the aspects and com­bi­ne them crea­tively, we can dra­ma­ti­cal­ly increase effi­ci­en­cy wit­hout tur­ning the enti­re pro­ject upsi­de down. This is not the fas­test way, but the only one if we want to be sure that the solu­ti­on will meet all func­tion­a­li­ty standards.

Depen­ding on the needs of the pro­ject, we can cus­to­mi­ze Jenk­ins Pipe­line in seve­ral ways. We ana­ly­zed three ways: Jenk­ins jobs cas­ca­des, Blue Oce­an plug­in and Decla­ra­ti­ve Pipe­line. In our case, the Decla­ra­ti­ve Pipe­line was the most sui­ta­ble. The main advan­ta­ge of which is the use of Jekins­file, whe­re we are deal­ing with Groo­vy syn­tax. Here we real­ly have unli­mi­t­ed pos­si­bi­li­ties of adap­ting indi­vi­du­al ele­ments, which are addi­tio­nal­ly sup­port­ed by a varie­ty of plug­ins.
We have some tips and tricks to help you imple­ment this solu­ti­on as well:

  • First read about com­mon Jenk­ins pipe­line mista­kes and draw conclusions.
  • Good repre­sen­ta­ti­on of Jenk­ins file have Visu­al Stu­dio Code.
  • Crea­te more stages. This will show you in which step your pro­gram break.
  • Con­sider whe­re you want to sto­rage parameters:
    • The best way is to keep the para­me­ters in one place. Jenk­ins or Jenkinsfile.
    • In Jenk­ins­file, para­me­ters will be see after next che­cking out revision.
    • In Jenk­ins, more peo­p­le have an easier way to access and modi­fy parameters.
  • If we have more nodes we could defi­ned it in the para­me­ters as well.
  • If we want to call a func­tion in Python with a spe­ci­fic para­me­ter then we can use the fol­lo­wing solution.

  • To store addi­tio­nal pro­per­ties retur­ned out by our python code, we can use an addi­tio­nal file stored on the com­pu­ter with the Jenk­ins con­fi­gu­ra­ti­on. In this case, the glo­bal varia­ble props should be defi­ned at the begin­ning of the file befo­re pipe­line and defi­ned like in the pre­vious screen.
  • Post-stage email con­tent should also be kept in Jenk­ins­file. It offers HTML inter­pre­ta­ti­on and it is easier to access parameters.
  • We can repeat our build pro­cess by direct­ly modi­fy­ing the Jenk­ins­file wit­hout modi­fy­ing it on GIT.

Pro­ject Manage­ment part

To start such imple­men­ta­ti­on, and for bet­ter under­stan­ding requi­re­ments, tog­e­ther with our Pro­ject Mana­ger, we crea­ted Requi­re­ment Tracea­bi­li­ty Matrix. We did it at the begin­ning and we deter­mi­ned all func­tion­al, non-func­tion­al, busi­ness, stake­hol­der requi­re­ments. It allo­wed to deter­mi­ne the scope, needs and mile­sto­nes which should be implemented.

Addi­tio­nal­ly we crea­ted Acti­vi­ty List, whe­re we lis­ted all acti­vi­ties, which should be per­for­med to imple­ment CI in our pro­ject. We used Git­lab as a tool, which sup­port­ed us in plan­ning, exe­cu­ting, moni­to­ring and con­trol­ling pro­cess (boards).

Moreo­ver we crea­ted Pro­ject Net­work Dia­gram, whe­re we deter­mi­ned depen­den­ci­es, did fast track­ing, plan­ned acti­vi­ties, and esti­ma­ted dura­ti­ons of task and project.