diff --git a/cicd-lab-pipeline.groovy b/cicd-lab-pipeline.groovy
index 94556a4..d038dac 100644
--- a/cicd-lab-pipeline.groovy
+++ b/cicd-lab-pipeline.groovy
@@ -32,140 +32,145 @@
 orchestrate = new com.mirantis.mk.Orchestrate()
 
 node {
-    // connection objects
-    def openstackCloud
-    def saltMaster
+    try {
+        // connection objects
+        def openstackCloud
+        def saltMaster
 
-    // value defaults
-    def openstackVersion = OPENSTACK_API_CLIENT ? OPENSTACK_API_CLIENT : 'liberty'
-    def openstackEnv = "${env.WORKSPACE}/venv"
+        // value defaults
+        def openstackVersion = OPENSTACK_API_CLIENT ? OPENSTACK_API_CLIENT : 'liberty'
+        def openstackEnv = "${env.WORKSPACE}/venv"
 
-    if (HEAT_STACK_NAME == '') {
-        HEAT_STACK_NAME = BUILD_TAG
-    }
-
-    //
-    // Bootstrap
-    //
-
-    stage ('Download Heat templates') {
-        git.checkoutGitRepository('template', HEAT_TEMPLATE_URL, HEAT_TEMPLATE_BRANCH, HEAT_TEMPLATE_CREDENTIALS)
-    }
-
-    stage('Install OpenStack CLI') {
-        openstack.setupOpenstackVirtualenv(openstackEnv, openstackVersion)
-    }
-
-    stage('Connect to OpenStack cloud') {
-        openstackCloud = openstack.createOpenstackEnv(OPENSTACK_API_URL, OPENSTACK_API_CREDENTIALS, OPENSTACK_API_PROJECT)
-        openstack.getKeystoneToken(openstackCloud, openstackEnv)
-    }
-
-    if (HEAT_STACK_REUSE == 'false') {
-        stage('Launch new Heat stack') {
-            envParams = [
-                'instance_zone': HEAT_STACK_ZONE,
-                'public_net': HEAT_STACK_PUBLIC_NET
-            ]
-            openstack.createHeatStack(openstackCloud, HEAT_STACK_NAME, HEAT_STACK_TEMPLATE, envParams, HEAT_STACK_ENVIRONMENT, openstackEnv)
+        if (HEAT_STACK_NAME == '') {
+            HEAT_STACK_NAME = BUILD_TAG
         }
-    }
 
-    stage('Connect to Salt master') {
-        def saltMasterPort
-        try {
-            saltMasterPort = SALT_MASTER_PORT
-        } catch (MissingPropertyException e) {
-            saltMasterPort = 8000
+        //
+        // Bootstrap
+        //
+
+        stage ('Download Heat templates') {
+            git.checkoutGitRepository('template', HEAT_TEMPLATE_URL, HEAT_TEMPLATE_BRANCH, HEAT_TEMPLATE_CREDENTIALS)
         }
-        saltMasterHost = openstack.getHeatStackOutputParam(openstackCloud, HEAT_STACK_NAME, 'salt_master_ip', openstackEnv)
-        saltMasterUrl = "http://${saltMasterHost}:${saltMasterPort}"
-        saltMaster = salt.connection(saltMasterUrl, SALT_MASTER_CREDENTIALS)
-    }
 
-    //
-    // Install
-    //
+        stage('Install OpenStack CLI') {
+            openstack.setupOpenstackVirtualenv(openstackEnv, openstackVersion)
+        }
 
-    stage('Install core infra') {
-        // salt.master, reclass
-        // refresh_pillar
-        // sync_all
-        // linux,openssh,salt.minion.ntp
+        stage('Connect to OpenStack cloud') {
+            openstackCloud = openstack.createOpenstackEnv(OPENSTACK_API_URL, OPENSTACK_API_CREDENTIALS, OPENSTACK_API_PROJECT)
+            openstack.getKeystoneToken(openstackCloud, openstackEnv)
+        }
 
-        orchestrate.installFoundationInfra(saltMaster)
-        orchestrate.validateFoundationInfra(saltMaster)
-    }
+        if (HEAT_STACK_REUSE == 'false') {
+            stage('Launch new Heat stack') {
+                envParams = [
+                    'instance_zone': HEAT_STACK_ZONE,
+                    'public_net': HEAT_STACK_PUBLIC_NET
+                ]
+                openstack.createHeatStack(openstackCloud, HEAT_STACK_NAME, HEAT_STACK_TEMPLATE, envParams, HEAT_STACK_ENVIRONMENT, openstackEnv)
+            }
+        }
 
-    stage("Deploy GlusterFS") {
-        salt.enforceState(saltMaster, 'I@glusterfs:server', 'glusterfs.server.service', true)
-        salt.enforceState(saltMaster, 'ci01*', 'glusterfs.server.setup', true)
-        sleep(5)
-        salt.enforceState(saltMaster, 'I@glusterfs:client', 'glusterfs.client', true)
-        print salt.cmdRun(saltMaster, 'I@glusterfs:client', 'mount|grep fuse.glusterfs || echo "Command failed"')
-    }
+        stage('Connect to Salt master') {
+            def saltMasterPort
+            try {
+                saltMasterPort = SALT_MASTER_PORT
+            } catch (MissingPropertyException e) {
+                saltMasterPort = 8000
+            }
+            saltMasterHost = openstack.getHeatStackOutputParam(openstackCloud, HEAT_STACK_NAME, 'salt_master_ip', openstackEnv)
+            saltMasterUrl = "http://${saltMasterHost}:${saltMasterPort}"
+            saltMaster = salt.connection(saltMasterUrl, SALT_MASTER_CREDENTIALS)
+        }
 
-    stage("Deploy GlusterFS") {
-        salt.enforceState(saltMaster, 'I@haproxy:proxy', 'haproxy,keepalived')
-    }
+        //
+        // Install
+        //
 
-    stage("Setup Docker Swarm") {
-        salt.enforceState(saltMaster, 'I@docker:host', 'docker.host', true)
-        salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'docker.swarm', true)
-        salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'salt', true)
-        salt.runSaltProcessStep(saltMaster, 'I@docker:swarm:role:master', 'mine.flush')
-        salt.runSaltProcessStep(saltMaster, 'I@docker:swarm:role:master', 'mine.update')
-        salt.enforceState(saltMaster, 'I@docker:swarm', 'docker.swarm', true)
-        print salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', 'docker node ls')
-    }
+        stage('Install core infra') {
+            // salt.master, reclass
+            // refresh_pillar
+            // sync_all
+            // linux,openssh,salt.minion.ntp
 
-    stage("Deploy Docker services") {
-        salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'docker.client')
+            orchestrate.installFoundationInfra(saltMaster)
+            orchestrate.validateFoundationInfra(saltMaster)
+        }
 
-        // XXX: Hack to fix dependency of gerrit on mysql
-        print salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', "docker service rm gerrit; sleep 5; rm -rf /srv/volumes/gerrit/*")
-        sleep(10)
-        print salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', "apt-get install -y mysql-client; mysql -ppassword -h172.16.10.254 -e'drop database gerrit;create database gerrit;'")
-        salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'docker.client')
-        // ---- cut here (end of hack) ----
+        stage("Deploy GlusterFS") {
+            salt.enforceState(saltMaster, 'I@glusterfs:server', 'glusterfs.server.service', true)
+            salt.enforceState(saltMaster, 'ci01*', 'glusterfs.server.setup', true)
+            sleep(5)
+            salt.enforceState(saltMaster, 'I@glusterfs:client', 'glusterfs.client', true)
+            print salt.cmdRun(saltMaster, 'I@glusterfs:client', 'mount|grep fuse.glusterfs || echo "Command failed"')
+        }
 
-        retry(30) {
-            out = salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', """/bin/bash -c 'docker service ls | grep -E "0/[0-9]+"' && echo 'Some services are not running'""")
-            for (int a = 0; a < out['return'].size(); a++) {
-                def entry = a
-                for (int i = 0; i < entry.size(); i++) {
-                    def node = entry[i]
-                    if (node.value =~ /Some services are not running/) {
-                        sleep(10)
-                        throw new Exception("$node.key: $node.value")
-                    } else {
-                        print out
+        stage("Deploy GlusterFS") {
+            salt.enforceState(saltMaster, 'I@haproxy:proxy', 'haproxy,keepalived')
+        }
+
+        stage("Setup Docker Swarm") {
+            salt.enforceState(saltMaster, 'I@docker:host', 'docker.host', true)
+            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'docker.swarm', true)
+            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'salt', true)
+            salt.runSaltProcessStep(saltMaster, 'I@docker:swarm:role:master', 'mine.flush')
+            salt.runSaltProcessStep(saltMaster, 'I@docker:swarm:role:master', 'mine.update')
+            salt.enforceState(saltMaster, 'I@docker:swarm', 'docker.swarm', true)
+            print salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', 'docker node ls')
+        }
+
+        stage("Deploy Docker services") {
+            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'docker.client')
+
+            // XXX: Hack to fix dependency of gerrit on mysql
+            print salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', "docker service rm gerrit; sleep 5; rm -rf /srv/volumes/gerrit/*")
+            sleep(10)
+            print salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', "apt-get install -y mysql-client; mysql -ppassword -h172.16.10.254 -e'drop database gerrit;create database gerrit;'")
+            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'docker.client')
+            // ---- cut here (end of hack) ----
+
+            retry(30) {
+                out = salt.cmdRun(saltMaster, 'I@docker:swarm:role:master', """/bin/bash -c 'docker service ls | grep -E "0/[0-9]+"' && echo 'Some services are not running'""")
+                for (int a = 0; a < out['return'].size(); a++) {
+                    def entry = out['return'].get(a)
+                    for (int i = 0; i < entry.size(); i++) {
+                        def node = entry.get(i)
+                        if (node) {
+                            if (node.value =~ /Some services are not running/) {
+                                sleep(10)
+                                throw new Exception("$node.key: $node.value")
+                            } else {
+                                print out
+                            }
+                        }
                     }
                 }
             }
         }
-    }
 
-    stage("Configure CI/CD services") {
-        salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'aptly', true)
-        retry(2) {
-            // Needs to run twice to pass __virtual__ method of gerrit module
-            // after installation of dependencies
-            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'gerrit', true)
+        stage("Configure CI/CD services") {
+            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'aptly', true)
+            retry(2) {
+                // Needs to run twice to pass __virtual__ method of gerrit module
+                // after installation of dependencies
+                salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'gerrit', true)
+            }
+            retry(2) {
+                // Same for jenkins
+                salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'jenkins', true)
+            }
         }
-        retry(2) {
-            // Same for jenkins
-            salt.enforceState(saltMaster, 'I@docker:swarm:role:master', 'jenkins', true)
-        }
-    }
-
-    //
-    // Cleanup
-    //
-
-    if (HEAT_STACK_DELETE == 'true') {
-        stage('Trigger cleanup job') {
-            build job: 'deploy_heat_cleanup', parameters: [[$class: 'StringParameterValue', name: 'HEAT_STACK_NAME', value: HEAT_STACK_NAME]]
+    } catch (Throwable e) {
+        // If there was an error or exception thrown, the build failed
+        currentBuild.result = "FAILURE"
+        throw e
+    } finally {
+        // Cleanup
+        if (HEAT_STACK_DELETE == 'true') {
+            stage('Trigger cleanup job') {
+                build job: 'deploy_heat_cleanup', parameters: [[$class: 'StringParameterValue', name: 'HEAT_STACK_NAME', value: HEAT_STACK_NAME]]
+            }
         }
     }
 }
diff --git a/lab-pipeline.groovy b/lab-pipeline.groovy
new file mode 100644
index 0000000..b10d410
--- /dev/null
+++ b/lab-pipeline.groovy
@@ -0,0 +1,170 @@
+/**
+ *
+ * Launch heat stack with basic k8s
+ * Flow parameters:
+ *   STACK_TYPE                 Orchestration engine: heat, ''
+ *   INSTALL                    What should be installed (k8s, openstack, ...)
+ *   TESTS                      What should be tested (k8s, openstack, ...)
+ *
+ * Expected parameters:
+ *
+ * required for STACK_TYPE=heat
+ *   HEAT_TEMPLATE_URL          URL to git repo with Heat templates
+ *   HEAT_TEMPLATE_CREDENTIALS  Credentials to the Heat templates repo
+ *   HEAT_TEMPLATE_BRANCH       Heat templates repo branch
+ *   HEAT_STACK_TEMPLATE        Heat stack HOT template
+ *   HEAT_STACK_ENVIRONMENT     Heat stack environmental parameters
+ *   HEAT_STACK_ZONE            Heat stack availability zone
+ *   HEAT_STACK_PUBLIC_NET      Heat stack floating IP pool
+ *   HEAT_STACK_DELETE          Delete Heat stack when finished (bool)
+ *   HEAT_STACK_CLEANUP_JOB     Name of job for deleting Heat stack
+ *   HEAT_STACK_REUSE           Reuse Heat stack (don't create one)
+ *   OPENSTACK_API_URL          OpenStack API address
+ *   OPENSTACK_API_CREDENTIALS  Credentials to the OpenStack API
+ *   OPENSTACK_API_PROJECT      OpenStack project to connect to
+ *   OPENSTACK_API_CLIENT       Versions of OpenStack python clients
+ *   OPENSTACK_API_VERSION      Version of the OpenStack API (2/3)
+ *
+ *   SALT_MASTER_CREDENTIALS    Credentials to the Salt API
+ *
+ * required for STACK_TYPE=NONE or empty string
+ *   SALT_MASTER_URL            URL of Salt-API
+
+ *   K8S_API_SERVER             Kubernetes API address
+ *   K8S_CONFORMANCE_IMAGE      Path to docker image with conformance e2e tests
+ *
+ */
+
+git = new com.mirantis.mk.Git()
+openstack = new com.mirantis.mk.Openstack()
+salt = new com.mirantis.mk.Salt()
+orchestrate = new com.mirantis.mk.Orchestrate()
+
+node {
+
+    //
+    // Prepare machines
+    //
+
+    stage ('Create infrastructure') {
+        IF (STACK_TYPE == 'heat') {
+            // value defaults
+            def openstackCloud
+            def openstackVersion = OPENSTACK_API_CLIENT ? OPENSTACK_API_CLIENT : 'liberty'
+            def openstackEnv = "${env.WORKSPACE}/venv"
+
+
+            if (HEAT_STACK_NAME == '') {
+                HEAT_STACK_NAME = BUILD_TAG
+            }
+
+            // get templates
+            git.checkoutGitRepository('template', HEAT_TEMPLATE_URL, HEAT_TEMPLATE_BRANCH, HEAT_TEMPLATE_CREDENTIALS)
+
+            // create openstack env
+            openstack.setupOpenstackVirtualenv(openstackEnv, openstackVersion)
+            openstackCloud = openstack.createOpenstackEnv(OPENSTACK_API_URL, OPENSTACK_API_CREDENTIALS, OPENSTACK_API_PROJECT)
+            openstack.getKeystoneToken(openstackCloud, openstackEnv)
+
+
+            // launch stack
+            if (HEAT_STACK_REUSE == 'false') {
+                stage('Launch new Heat stack') {
+                    // create stack
+                    envParams = [
+                        'instance_zone': HEAT_STACK_ZONE,
+                        'public_net': HEAT_STACK_PUBLIC_NET
+                    ]
+                    openstack.createHeatStack(openstackCloud, HEAT_STACK_NAME, HEAT_STACK_TEMPLATE, envParams, HEAT_STACK_ENVIRONMENT, openstackEnv)
+                }
+            }
+
+            // get SALT_MASTER_URL
+            saltMasterHost = openstack.getHeatStackOutputParam(openstackCloud, HEAT_STACK_NAME, 'salt_master_ip', openstackEnv)
+            SALT_MASTER_URL = "http://${saltMasterHost}:8088"
+        }
+    }
+
+    //
+    // Connect to Salt master
+    //
+
+    def saltMaster
+    stage('Connect to Salt API') {
+        saltMaster = salt.connection(SALT_MASTER_URL, SALT_MASTER_CREDENTIALS)
+    }
+
+    //
+    // Install
+    //
+
+    stage('Install core infrastructure') {
+        // salt.master, reclass
+        // refresh_pillar
+        // sync_all
+        // linux,openssh,salt.minion.ntp
+
+        orchestrate.installFoundationInfra(saltMaster)
+        orchestrate.validateFoundationInfra(saltMaster)
+    }
+
+
+    // install k8s
+    if (INSTALL.toLowerCase().contains('k8s')) {
+        stage('Install Kubernetes infra') {
+            orchestrate.installOpenstackMcpInfra(saltMaster)
+        }
+
+        stage('Install Kubernetes control') {
+            orchestrate.installOpenstackMcpControl(saltMaster)
+        }
+
+    }
+
+    // install openstack
+    if (INSTALL.toLowerCase().contains('openstack')) {
+        // install Infra and control, tests, ...
+
+        stage('Install OpenStack infra') {
+            orchestrate.installOpenstackMkInfra(saltMaster)
+        }
+
+        stage('Install OpenStack control') {
+            orchestrate.installOpenstackMkControl(saltMaster)
+        }
+
+        stage('Install OpenStack network') {
+            orchestrate.installOpenstackMkNetwork(saltMaster)
+        }
+
+        stage('Install OpenStack compute') {
+            orchestrate.installOpenstackMkCompute(saltMaster)
+        }
+
+    }
+
+    //
+    // Test
+    //
+
+    if (TESTS.toLowerCase().contains('k8s')) {
+        stage('Run k8s bootstrap tests') {
+            orchestrate.runConformanceTests(saltMaster, K8S_API_SERVER, 'tomkukral/k8s-scripts')
+        }
+
+        stage('Run k8s conformance e2e tests') {
+            orchestrate.runConformanceTests(saltMaster, K8S_API_SERVER, K8S_CONFORMANCE_IMAGE)
+        }
+    }
+
+
+    //
+    // Clean
+    //
+
+    if (HEAT_STACK_DELETE == 'true' && STACK_TYPE == 'heat') {
+        stage('Trigger cleanup job') {
+            build job: 'deploy_heat_cleanup', parameters: [[$class: 'StringParameterValue', name: 'HEAT_STACK_NAME', value: HEAT_STACK_NAME]]
+        }
+    }
+}