Our Team is imple­men­ting Con­ti­nu­ous Inte­gra­tion in one of our major pro­jects. Imple­men­ting Con­ti­nu­ous Inte­gra­tion (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 raised our efficiency.

When we cre­ate CI not the bri­gh­test bulb in the box is to leave pre­vio­us foun­da­tions in ruins. It is best to get to know the pro­cess in deta­il from the tech­ni­cal side, con­duct sub­stan­ti­ve deba­tes with an expe­rien­ced per­son and, what is most neces­sa­ry, use the latest tech­no­lo­gi­cal solu­tions. Once we have the com­ple­te pic­tu­re, we can bre­ak it down into smal­ler puz­zles. Some frag­ments are bet­ter left unchan­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­gram­ming lan­gu­age like Python and an auto­ma­tion tool like Jen­kins which has lots of plu­gins to sim­pli­fy the who­le process.

When we pre­ci­se­ly col­lect all the aspects and com­bi­ne them cre­ati­ve­ly, we can dra­ma­ti­cal­ly incre­ase effi­cien­cy witho­ut tur­ning the enti­re pro­ject upsi­de down. This is not the fastest way, but the only one if we want to be sure that the solu­tion will meet all func­tio­na­li­ty standards.

Depen­ding on the needs of the pro­ject, we can custo­mi­ze Jen­kins Pipe­li­ne in seve­ral ways. We ana­ly­zed three ways: Jen­kins jobs casca­des, Blue Oce­an plu­gin and Dec­la­ra­ti­ve Pipe­li­ne. In our case, the Dec­la­ra­ti­ve Pipe­li­ne was the most suita­ble. The main advan­ta­ge of which is the use of Jekins­fi­le, whe­re we are dealing with Gro­ovy syn­tax. Here we real­ly have unli­mi­ted possi­bi­li­ties of adap­ting indi­vi­du­al ele­ments, which are addi­tio­nal­ly sup­por­ted by a varie­ty of plu­gins.
We have some tips and tricks to help you imple­ment this solu­tion as well:

  • First read abo­ut com­mon Jen­kins pipe­li­ne mista­kes and draw conclusions.
  • Good repre­sen­ta­tion of Jen­kins file have Visu­al Stu­dio Code.
  • Cre­ate more sta­ges. This will show you in which step your pro­gram break.
  • Con­si­der whe­re you want to sto­ra­ge parameters:
    • The best way is to keep the para­me­ters in one pla­ce. Jen­kins or Jenkinsfile.
    • In Jen­kins­fi­le, para­me­ters will be see after next chec­king out revision.
    • In Jen­kins, more people 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 sto­re addi­tio­nal pro­per­ties retur­ned out by our python code, we can use an addi­tio­nal file sto­red on the com­pu­ter with the Jen­kins con­fi­gu­ra­tion. In this case, the glo­bal varia­ble props sho­uld be defi­ned at the begin­ning of the file befo­re pipe­li­ne and defi­ned like in the pre­vio­us screen.
  • Post-sta­ge ema­il con­tent sho­uld also be kept in Jen­kins­fi­le. It offers HTML inter­pre­ta­tion and it is easier to access parameters.
  • We can repe­at our build pro­cess by direc­tly modi­fy­ing the Jen­kins­fi­le witho­ut modi­fy­ing it on GIT.

Pro­ject Mana­ge­ment part

To start such imple­men­ta­tion, and for bet­ter under­stan­ding requ­ire­ments, toge­ther with our Pro­ject Mana­ger, we cre­ated Requ­ire­ment Tra­ce­abi­li­ty Matrix. We did it at the begin­ning and we deter­mi­ned all func­tio­nal, non-func­tio­nal, busi­ness, sta­ke­hol­der requ­ire­ments. It allo­wed to deter­mi­ne the sco­pe, needs and mile­sto­nes which sho­uld be implemented.

Addi­tio­nal­ly we cre­ated Acti­vi­ty List, whe­re we listed all acti­vi­ties, which sho­uld be per­for­med to imple­ment CI in our pro­ject. We used Gitlab as a tool, which sup­por­ted us in plan­ning, exe­cu­ting, moni­to­ring and con­trol­ling pro­cess (boards).

More­over we cre­ated Pro­ject Network Dia­gram, whe­re we deter­mi­ned depen­den­cies, did fast trac­king, plan­ned acti­vi­ties, and esti­ma­ted dura­tions of task and project.