try{

          stage('Pre Setup Node'){

          }

          stage('Clone Test Suite') {

  	python -c 'import cherrypy'

  	python -c 'import M2Crypto'

  	python -c 'import lasso'

  	python -c 'import ldap'

  	python -c 'import pam'

  	python -c 'import fedora'

  	python -c 'import psycopg2'

  	# And now everything else

  	ls /usr/lib*/security/pam_sss.so

  	ls /usr/lib*/httpd/modules/mod_wsgi_python3.so

  	ls /usr/libexec/mod_auth_mellon

  # Running within containers

  container-quickrun:

  	echo "Building quickrun container ..."

  	echo "quickrun container built"

  quickrun: container-quickrun

  	echo "Starting Quickrun ..."

  # Testing within containers

  container-centos8-stream:

  	@echo "Building CentOS 8 Stream container ..."

  	@echo "CentOS 8 Stream container built"

  container-centos9-stream:

  	@echo "Building CentOS 9 Stream container ..."

  	@echo "CentOS 9 Stream container built"

  	@echo "Containers built"

  containertest-centos8-stream: container-centos8-stream

  	@echo "Starting CentOS 8 Stream tests ..."

  	@echo "CentOS 8 Stream passed"

  containertest-centos9-stream: container-centos9-stream

  	@echo "Starting CentOS 9 Stream tests ..."

  	@echo "CentOS 9 Stream passed"

  # This containertest is failing on lasso library randomly

  # Removing it from containertest till new version of lasso library is available

  # https://src.fedoraproject.org/rpms/lasso

  	@echo "Starting code lint tests ..."

  	@echo "Code lint tests passed"

  	@echo "Container tests passed"

    config.hostmanager.manage_guest = true

    config.vm.define "freeipa" do |freeipa|

      freeipa.vm.hostname = "ipa.ipsilon.test"

      freeipa.hostmanager.aliases = ("kerberos.ipsilon.test")

    end

    config.vm.define "ipsilon" do |ipsilon|

      ipsilon.vm.hostname = "ipsilon.test"

      ipsilon.vm.synced_folder ".", "/vagrant", disabled: true

      ipsilon.vm.synced_folder ".", "/home/vagrant/ipsilon", type: "sshfs" # , rsync__exclude: ['./testdir*']

      ipsilon.vm.provider :libvirt do |libvirt|

        libvirt.cpus = 2

      end

      ipsilon.vm.provision "ansible" do |ansible|

  License:        GPLv3+

  Requires:       %{name}-base = %{version}-%{release}

  Requires:       python3-sssdconfig

  Requires:       sssd >= 1.12.4

  BuildArch:      noarch

        - openldap-servers

        - openssl

        - sssd

        - gcc

        - krb5-devel

        - krb5-server

  #

  # Copyright (C) 2015 Ipsilon project Contributors, for license see COPYING

  import argparse

  import cherrypy

  import logging

  #!/usr/bin/python

  # Copyright (C) 2014 Ipsilon project Contributors, for license see COPYING

  from ipsilon.login.common import LoginMgrsInstall

  from ipsilon.info.common import InfoProviderInstall

  from ipsilon.providers.common import ProvidersInstall

      data_dir = os.path.join(DATADIR, args['instance'])

      try:

          tconf.read(os.path.join(instance_conf, 'ipsilon.conf'))

          cache_dir = tconf.get('global', 'cache_dir')

      except (configparser.NoOptionError, configparser.NoSectionError):

  #

  # Copyright (C) 2015 Ipsilon project Contributors, for license see COPYING

  from argparse import ArgumentParser

  import sys

  import logging

  # These lines make sure that we have at least a minimum version of some

  # packages, since we depend on features provided by them.

  import __main__

  import sys

  sys.stdout = sys.stderr

          if old_version == 1:

              # In schema version 2, we added indexes and primary keys

              # pylint: disable=protected-access

              return 2

          elif old_version == 2:

              return 3

          """

          headers = {'Content-Type': SOAP_MEDIA_TYPE}

          try:

                                       headers=headers, timeout=30)

          except Exception as e:  # pylint: disable=broad-except

              self.error('SOAP HTTP request failed: (%s) (on %s)' %

  class BaseStore(Log):

      # Some helper functions used for upgrades

          raise NotImplementedError()

          raise NotImplementedError()

                                         **pool_args)

          self.is_readonly = False

          if self._dbengine.dialect.name != 'sqlite':

              # It is impossible to add constraints to a pre-existing table for

              #  SQLite

              # source: http://www.sqlite.org/omitted.html

      def debug(self, fact):

          if self.db_conn_log:

          for index in table_def['indexes']:

              idx_name = 'idx_%s_%s' % (name, '_'.join(index))

              table_creation.append(Index(idx_name, *index))

          return table

      def _where(self, kvfilter):

          if kvfilter is not None:

              for k in kvfilter:

          return where

      def _columns(self, columns=None):

          self._trans.commit()

      def create(self):

      def drop(self):

      def select(self, kvfilter=None, columns=None):

      def insert(self, values, ttl=None):

      def update(self, values, kvfilter):

      def delete(self, kvfilter):

      def perform_auto_cleanup(self):

          table = self._table

              where(and_(table.c.name == 'expiration_time',

                         table.c.value <= str(datetime.datetime.now())))

          # pylint: disable=no-value-for-parameter

          d = table.delete().where(table.c.uuid.in_(sel))

  class FileStore(BaseStore):

              self._timestamp = timestamp

          return self._config

          raise NotImplementedError()

          raise NotImplementedError()

          self.is_readonly = False

          raise NotImplementedError()

          raise NotImplementedError()

      def close(self):

          return rows

          """Insert a new object into the store.

          ttl is the time for which the object is supposed to be kept.

          """

          path, _ = self._get_most_specific_dir(values, False, update=True)

          self._store.client.write(path, json.dumps(values), ttl=ttl)

          path, levels_unused = self._get_most_specific_dir(kvfilter)

          if levels_unused == 0 or len(kvfilter) == 0:

              try:

              except etcd.EtcdKeyNotFound:

                  return

              for key in kvfilter:

                          q.update({'value': options[opt]},

                                   {'name': name, 'option': opt})

                      else:

                  for opt in curvals:

                      if opt not in options:

          with q:

              try:

                  for name in data:

                  if expiration_time:

              except Exception as e:  # pylint: disable=broad-except

                  self.error("Failed to store %s data: [%s]" % (table, e))

                  raise

                                           {'uuid': uid, 'name': name})

                          else:

                              if datum[name] is not None:

              except Exception as e:  # pylint: disable=broad-except

                  self.error("Failed to store data in %s: [%s]" % (table, e))

      def del_unique_data(self, table, uuidval):

          kvfilter = {'uuid': uuidval}

          with q:

              try:

                  q.delete(kvfilter)

                        'login_config',

                        'provider_config',

                        'authz_config']:

      def _upgrade_schema(self, old_version):

          if old_version == 1:

                            'login_config',

                            'provider_config']:

                  # pylint: disable=protected-access

              return 2

          elif old_version == 2:

              # Version 3 adds the authz config table

              q = self._query(self._db, 'authz_config', OPTIONS_TABLE,

              self.save_options('authz_config', 'global', {'enabled': 'allow'})

              return 3

          else:

          if not self.is_readonly:

              table = plugin_name+'_data'

              q = self._query(self._db, table, UNIQUE_DATA_TABLE,

  class UserStore(Store):

                      q.update({'value': parameters}, {'name': user,

                                                       'option': key})

                  else:

              except Exception as e:  # pylint: disable=broad-except

                  self.error('Failed to store consent: [%s]' % e)

                  raise

          return d

      def _initialize_table(self, tablename):

      def _initialize_schema(self):

          self._initialize_table('users')

          if old_version == 1:

              # In schema version 2, we added indexes and primary keys

              # pylint: disable=protected-access

              return 2

          elif old_version == 2:

              # In schema 3 for UserStore, we added user_consent

      def _initialize_schema(self):

          q = self._query(self._db, self.table, UNIQUE_DATA_TABLE,

      def _upgrade_schema(self, old_version):

          if old_version == 1:

              # In schema version 2, we added indexes and primary keys

              # pylint: disable=protected-access

              return 2

          elif old_version == 2:

              return 3

      def _initialize_schema(self):

          q = self._query(self._db, self.table, UNIQUE_DATA_TABLE,

      def _upgrade_schema(self, old_version):

          if old_version == 1:

              # In schema version 2, we added indexes and primary keys

              # pylint: disable=protected-access

              return 2

          elif old_version == 2:

              return 3

          if old_version == 1:

              # In schema version 2, we added indexes and primary keys

              # pylint: disable=protected-access

              return 2

          elif old_version == 2:

              return 3

      def _cleanup(self):

          # pylint: disable=protected-access

          # pylint: disable=no-value-for-parameter

  class SqlSession(Session):

          with q:

              q.delete({'id': self.id})

              data = json.dumps((self._data, expiration_time)).encode('utf-8')

      def _delete(self):

          q = SqlQuery(self._db, 'sessions', SESSION_TABLE)

  fi

  export PYTHONPATH=.

  # This should be kept in sync with the develop page on the website.

  # Distro-specific and python packages should go in the distro sub-dockerfiles.

  RUN yum install -y make httpd mod_auth_mellon postgresql-server \

  	krb5-server socket_wrapper nss_wrapper nodejs krb5-workstation \

  	sqlite mod_ssl mod_auth_openidc

      ipsilonconf = os.path.join(testdir, 'etc', idpname, 'ipsilon.conf')

      newconf = configparser.ConfigParser()

      with open(ipsilonconf, 'r') as f:

      with open(ipsilonconf, 'w+') as f:

          newconf.set('global', 'admin.config.db',

                      '"configfile://%s"' % adminconf)

          return result.text

      def fetch_page(self, idp, target_url, follow_redirect=True, krb=False,

          """

          Fetch a page and parse the response code to determine what to do

          next.

                          continue

                  except WrongPage:

                      pass

                  page = PageTree(r)

                  try:

                  return page

              else:

      def auth_to_idp(self, idp, krb=False, rule=None, expected=None):

              payload = {'name': desc}

              r = self.post(url, headers=headers, data=payload, files=metafile)

          if r.status_code != expected_status:

          if not rest:

              page = PageTree(r)

      Options +Includes

      Require all granted

  </Directory>

  """

      t = Template(location)

      text = t.substitute({'HTTPDIR': httpdir})

      os.mkdir(httpdir + '/sp')

      with open(httpdir + '/sp/index.html', 'w') as f:

          f.write(index)

  def convert_to_dict(envlist):

      with TC.case('Access first SP Protected Area with IdP deny, with '

                   'pre-auth'):

          sess2.auth_to_idp(idpname)

          check_text_results(page.text,

                             'OpenID Connect Provider error: access_denied')

      # Sessions are valid for one minute, and we clean up once per minute.

      # However, checking after two minute is kinda cutting it close, so we add ten

      # seconds to make sure the system has had time to clean up.

      time.sleep(130)

      with TC.case('Verify logged out state'):

          conn = sqlite3.connect(sess_db)

          cur = conn.cursor()

          cur.execute('SELECT * FROM saml2_sessions;')

      with TC.case('Checking that refreshable OpenIDC tokens are not expired'):

              )

          tokens = store.get_unique_data("token")

          if list(tokens.keys())[0] != token_refreshable["token_id"]:

              raise Exception("The refreshable token has been cleaned up")

  #

  # Copyright (C) 2014-2017 Ipsilon project Contributors, for license see COPYING

  import argparse

  from ipsilon.util import plugin

  import os