Our Team is imple­ment­ing Con­tinu­ous Integ­ra­tion in one of our major pro­jects. Imple­ment­ing Con­tinu­ous Integ­ra­tion (CI) into a major and long run­ning auto­mot­ive pro­ject is a large improve­ment which dra­mat­ic­ally raised our efficiency.

When we cre­ate CI not the bright­est bulb in the box is to leave pre­vi­ous found­a­tions in ruins. It is best to get to know the pro­cess in detail from the tech­nic­al side, con­duct sub­stant­ive debates with an exper­i­enced per­son and, what is most neces­sary, use the latest tech­no­lo­gic­al solu­tions. Once we have the com­plete pic­ture, we can break it down into smal­ler puzzles. Some frag­ments are bet­ter left unchanged and focus only on run­ning them. Anoth­er good prac­tice is to take advant­age of a uni­ver­sal pro­gram­ming lan­guage like Python and an auto­ma­tion tool like Jen­kins which has lots of plu­gins to sim­pli­fy the whole process.

When we pre­cisely col­lect all the aspects and com­bine them cre­at­ively, we can dra­mat­ic­ally increase effi­ciency without turn­ing the entire pro­ject upside down. This is not the fast­est way, but the only one if we want to be sure that the solu­tion will meet all func­tion­al­ity standards.

Depend­ing on the needs of the pro­ject, we can cus­tom­ize Jen­kins Pipeline in sev­er­al ways. We ana­lyzed three ways: Jen­kins jobs cas­cades, Blue Ocean plu­gin and Declar­at­ive Pipeline. In our case, the Declar­at­ive Pipeline was the most suit­able. The main advant­age of which is the use of Jekinsfile, where we are deal­ing with Groovy syn­tax. Here we really have unlim­ited pos­sib­il­it­ies of adapt­ing indi­vidu­al ele­ments, which are addi­tion­ally sup­por­ted by a vari­ety of plu­gins.
We have some tips and tricks to help you imple­ment this solu­tion as well:

  • First read about com­mon Jen­kins pipeline mis­takes and draw conclusions.
  • Good rep­res­ent­a­tion of Jen­kins file have Visu­al Stu­dio Code.
  • Cre­ate more stages. This will show you in which step your pro­gram break.
  • Con­sider where you want to stor­age parameters:
    • The best way is to keep the para­met­ers in one place. Jen­kins or Jenkinsfile.
    • In Jen­kinsfile, para­met­ers will be see after next check­ing out revision.
    • In Jen­kins, more people have an easi­er way to access and modi­fy parameters.
  • If we have more nodes we could defined it in the para­met­ers as well.
  • If we want to call a func­tion in Python with a spe­cif­ic para­met­er then we can use the fol­low­ing solution.

  • To store addi­tion­al prop­er­ties returned out by our python code, we can use an addi­tion­al file stored on the com­puter with the Jen­kins con­fig­ur­a­tion. In this case, the glob­al vari­able props should be defined at the begin­ning of the file before pipeline and defined like in the pre­vi­ous screen.
  • Post-stage email con­tent should also be kept in Jen­kinsfile. It offers HTML inter­pret­a­tion and it is easi­er to access parameters.
  • We can repeat our build pro­cess by dir­ectly modi­fy­ing the Jen­kinsfile without modi­fy­ing it on GIT.

Pro­ject Man­age­ment part

To start such imple­ment­a­tion, and for bet­ter under­stand­ing require­ments, togeth­er with our Pro­ject Man­ager, we cre­ated Require­ment Trace­ab­il­ity Mat­rix. We did it at the begin­ning and we determ­ined all func­tion­al, non-func­tion­al, busi­ness, stake­hold­er require­ments. It allowed to determ­ine the scope, needs and mile­stones which should be implemented.

Addi­tion­ally we cre­ated Activ­ity List, where we lis­ted all activ­it­ies, which should be per­formed to imple­ment CI in our pro­ject. We used Git­lab as a tool, which sup­por­ted us in plan­ning, execut­ing, mon­it­or­ing and con­trolling pro­cess (boards).

Moreover we cre­ated Pro­ject Net­work Dia­gram, where we determ­ined depend­en­cies, did fast track­ing, planned activ­it­ies, and estim­ated dur­a­tions of task and project.