Reorganized deployment tools.

The pkispawn and pkidestroy scripts have been moved into sbin folder.
The Python deployment library and the scriptlets were moved into
pki.server.deployment and pki.server.deployment.scriptlets packages,
respectively.

2 files changed, 697 insertions, 0 deletions

diff --git a/base/server/sbin/pkidestroy b/base/server/sbin/pkidestroy
new file mode 100755
index 000000000..e61b3fabe
--- /dev/null
+++ b/base/server/sbin/pkidestroy
@@ -0,0 +1,265 @@
+#!/usr/bin/python -tu
+# Authors:
+#     Matthew Harmsen <mharmsen@redhat.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Copyright (C) 2011 Red Hat, Inc.
+# All rights reserved.
+#
+
+# System Imports
+import sys
+import signal
+
+if not hasattr(sys, "hexversion") or sys.hexversion < 0x020700f0:
+    print "Python version %s.%s.%s is too old." % sys.version_info[:3]
+    print "Please upgrade to at least Python 2.7.0."
+    sys.exit(1)
+try:
+    import os
+    import socket
+    import struct
+    import subprocess
+    import time
+    from time import strftime as date
+    from pki.server.deployment import pkiconfig as config
+    from pki.server.deployment.pkiparser import PKIConfigParser
+    from pki.server.deployment import pkilogging
+    from pki.server.deployment import pkimessages as log
+    import pki.server.deployment.pkihelper as util
+except ImportError:
+    print >> sys.stderr, """\
+There was a problem importing one of the required Python modules. The
+error was:
+
+    %s
+""" % sys.exc_value
+    sys.exit(1)
+
+#Handle the Keyboard Interrupt
+# pylint: disable-msg=W0613
+def interrupt_handler(event, frame):
+    print
+    print '\nUninstallation canceled.'
+    sys.exit(1)
+
+# PKI Deployment Functions
+def main(argv):
+    "main entry point"
+
+    config.pki_deployment_executable = os.path.basename(argv[0])
+
+    # Only run this program as "root".
+    if not os.geteuid() == 0:
+        sys.exit("'%s' must be run as root!" % argv[0])
+
+    # Set the umask
+    os.umask(config.PKI_DEPLOYMENT_DEFAULT_UMASK)
+
+    # Set installation time
+    ticks = time.time()
+    config.pki_install_time = time.asctime(time.localtime(ticks))
+
+    # Generate a timestamp
+    config.pki_timestamp = date('%Y%m%d%H%M%S', time.localtime(ticks))
+    config.pki_certificate_timestamp =\
+        date('%Y-%m-%d %H:%M:%S', time.localtime(ticks))
+
+    # Obtain the architecture bit-size
+    config.pki_architecture = struct.calcsize("P") * 8
+
+    # Retrieve hostname
+    config.pki_hostname = socket.getfqdn()
+
+    # Retrieve DNS domainname
+    config.pki_dns_domainname = None
+    try:
+        config.pki_dns_domainname = subprocess.check_output("dnsdomainname",
+                                                            shell=True)
+        config.pki_dns_domainname = config.pki_dns_domainname.rstrip('\n')
+        if not len(config.pki_dns_domainname):
+            print log.PKI_DNS_DOMAIN_NOT_SET
+            sys.exit(1)
+    except subprocess.CalledProcessError as exc:
+        print log.PKI_SUBPROCESS_ERROR_1 % exc
+        sys.exit(1)
+
+    # Read and process command-line arguments.
+    parser = PKIConfigParser(
+        'PKI Instance Removal',
+        log.PKIDESTROY_EPILOG)
+
+    parser.optional.add_argument('-i',
+        dest='pki_deployed_instance_name',
+        action='store',
+        nargs=1, metavar='<instance>',
+        help='FORMAT:  ${pki_instance_name}')
+
+    parser.optional.add_argument('-u',
+        dest='pki_secdomain_user',
+        action='store',
+        nargs=1, metavar='<security domain user>',
+        help='security domain user')
+    
+    parser.optional.add_argument('-W',
+        dest='pki_secdomain_pass_file',
+        action='store',
+        nargs=1, metavar='<security domain password file>',
+        help='security domain password file path')
+                                 
+
+    args = parser.process_command_line_arguments()
+
+    interactive = False
+
+    while True:
+
+        # -s <subsystem>
+        if args.pki_subsystem is None:
+            interactive = True
+            config.pki_subsystem = parser.read_text('Subsystem (CA/KRA/OCSP/TKS/TPS)',
+                options=['CA', 'KRA', 'OCSP', 'TKS', 'TPS'],
+                default='CA', caseSensitive=False).upper()
+        else:
+            config.pki_subsystem = str(args.pki_subsystem).strip('[\']')
+
+        # -i <instance name>
+        if args.pki_deployed_instance_name is None:
+            interactive = True
+            config.pki_deployed_instance_name = parser.read_text('Instance', default='pki-tomcat')
+        else:
+            config.pki_deployed_instance_name = str(args.pki_deployed_instance_name).strip('[\']')
+
+        if interactive:
+            print
+            parser.indent = 0
+
+            begin = parser.read_text('Begin uninstallation (Yes/No/Quit)',
+                options=['Yes', 'Y', 'No', 'N', 'Quit', 'Q'],
+                sign='?', allowEmpty=False, caseSensitive=False).lower()
+
+            print
+
+            if begin == 'q' or begin == 'quit':
+                print "Uninstallation canceled."
+                sys.exit(0)
+
+            elif begin == 'y' or begin == 'yes':
+                break
+
+        else:
+            break
+
+    #    '-u'
+    if args.pki_secdomain_user:
+        config.pki_secdomain_user = str(args.pki_secdomain_user).strip('[\']')
+
+    #    '-W' password file
+    if args.pki_secdomain_pass_file:
+        with open(str(args.pki_secdomain_pass_file).strip('[\']'),'r') as pwd_file:
+            config.pki_secdomain_pass = pwd_file.readline().strip('\n')
+
+    # verify that previously deployed instance exists
+    deployed_pki_instance_path = config.pki_root_prefix +\
+                                 config.PKI_DEPLOYMENT_BASE_ROOT + "/" +\
+                                 config.pki_deployed_instance_name
+    if not os.path.exists(deployed_pki_instance_path):
+        print "ERROR:  " + log.PKI_INSTANCE_DOES_NOT_EXIST_1 %\
+              deployed_pki_instance_path
+        print
+        parser.arg_parser.exit(-1)
+
+    # verify that previously deployed subsystem for this instance exists
+    deployed_pki_subsystem_path = deployed_pki_instance_path + "/" +\
+                                  config.pki_subsystem.lower()
+    if not os.path.exists(deployed_pki_subsystem_path):
+        print "ERROR:  " + log.PKI_SUBSYSTEM_DOES_NOT_EXIST_2 %\
+              (config.pki_subsystem, deployed_pki_instance_path)
+        print
+        parser.arg_parser.exit(-1)
+
+    config.default_deployment_cfg = config.PKI_DEPLOYMENT_DEFAULT_CONFIGURATION_FILE
+
+    # establish complete path to previously deployed configuration file
+    config.user_deployment_cfg =\
+        deployed_pki_subsystem_path + "/" +\
+        "registry" + "/" +\
+        config.pki_subsystem.lower() + "/" +\
+        config.USER_DEPLOYMENT_CONFIGURATION
+
+    parser.validate()
+    parser.init_config()
+
+    # Enable 'pkidestroy' logging.
+    config.pki_log_dir = config.pki_root_prefix +\
+                         config.PKI_DEPLOYMENT_LOG_ROOT
+    config.pki_log_name = "pki" + "-" +\
+                          config.pki_subsystem.lower() +\
+                          "-" + "destroy" + "." +\
+                          config.pki_timestamp + "." + "log"
+    rv = pkilogging.enable_pki_logger(config.pki_log_dir,
+                                      config.pki_log_name,
+                                      config.pki_log_level,
+                                      config.pki_console_log_level,
+                                      "pkidestroy")
+    if rv != OSError:
+        config.pki_log = rv
+    else:
+        print log.PKI_UNABLE_TO_CREATE_LOG_DIRECTORY_1 % config.pki_log_dir
+        sys.exit(1)
+
+    # Read the specified PKI configuration file.
+    rv = parser.read_pki_configuration_file()
+    if rv != 0:
+        config.pki_log.error(log.PKI_UNABLE_TO_PARSE_1, rv,
+                             extra=config.PKI_INDENTATION_LEVEL_0)
+        sys.exit(1)
+
+    # Combine the various sectional dictionaries into a PKI master dictionary
+    parser.compose_pki_master_dictionary()
+    parser.pki_master_dict['pki_destroy_log'] = config.pki_log_dir + "/" +\
+                                                config.pki_log_name
+    config.pki_log.debug(log.PKI_DICTIONARY_MASTER,
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+    config.pki_log.debug(pkilogging.log_format(parser.pki_master_dict),
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+
+    print "Uninstalling " + config.pki_subsystem + " from " + deployed_pki_instance_path + "."
+
+    # Process the various "scriptlets" to remove the specified PKI subsystem.
+    pki_subsystem_scriptlets = parser.pki_master_dict['destroy_scriplets'].split()
+    deployer = util.PKIDeployer(parser.pki_master_dict)
+    rv = 0
+    for pki_scriptlet in pki_subsystem_scriptlets:
+        scriptlet = __import__("pki.server.deployment.scriptlets." +
+                               pki_scriptlet,
+                               fromlist = [pki_scriptlet])
+        instance = scriptlet.PkiScriptlet()
+        rv = instance.destroy(deployer)
+        if rv != 0:
+            sys.exit(1)
+    config.pki_log.debug(log.PKI_DICTIONARY_MASTER,
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+    config.pki_log.debug(pkilogging.log_format(parser.pki_master_dict),
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+
+    print
+    print "Uninstallation complete."
+
+
+# PKI Deployment Entry Point
+if __name__ == "__main__":
+    signal.signal(signal.SIGINT, interrupt_handler)
+    main(sys.argv)
diff --git a/base/server/sbin/pkispawn b/base/server/sbin/pkispawn
new file mode 100755
index 000000000..d07016efc
--- /dev/null
+++ b/base/server/sbin/pkispawn
@@ -0,0 +1,432 @@
+#!/usr/bin/python -tu
+# Authors:
+#     Matthew Harmsen <mharmsen@redhat.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Copyright (C) 2011 Red Hat, Inc.
+# All rights reserved.
+#
+
+# System Imports
+import os
+import sys
+import signal
+
+if not hasattr(sys, "hexversion") or sys.hexversion < 0x020700f0:
+    print "Python version %s.%s.%s is too old." % sys.version_info[:3]
+    print "Please upgrade to at least Python 2.7.0."
+    sys.exit(1)
+try:
+    import ldap
+    import os
+    import requests
+    import socket
+    import struct
+    import subprocess
+    import time
+    import traceback
+    from time import strftime as date
+    from pki.server.deployment import pkiconfig as config
+    from pki.server.deployment.pkiparser import PKIConfigParser
+    from pki.server.deployment import pkilogging
+    from pki.server.deployment import pkimessages as log
+    import pki.server.deployment.pkihelper as util
+except ImportError:
+    print >> sys.stderr, """\
+There was a problem importing one of the required Python modules. The
+error was:
+
+    %s
+""" % sys.exc_value
+    sys.exit(1)
+
+# Handle the Keyboard Interrupt
+# pylint: disable-msg=W0613
+def interrupt_handler(event, frame):
+    print
+    print '\nInstallation canceled.'
+    sys.exit(1)
+
+# PKI Deployment Functions
+def main(argv):
+    "main entry point"
+
+    config.pki_deployment_executable = os.path.basename(argv[0])
+
+    # Only run this program as "root".
+    if not os.geteuid() == 0:
+        sys.exit("'%s' must be run as root!" % argv[0])
+
+    # Set the umask
+    os.umask(config.PKI_DEPLOYMENT_DEFAULT_UMASK)
+
+    # Set installation time
+    ticks = time.time()
+    config.pki_install_time = time.asctime(time.localtime(ticks))
+
+    # Generate a timestamp
+    config.pki_timestamp = date('%Y%m%d%H%M%S', time.localtime(ticks))
+    config.pki_certificate_timestamp = \
+        date('%Y-%m-%d %H:%M:%S', time.localtime(ticks))
+
+    # Obtain the architecture bit-size
+    config.pki_architecture = struct.calcsize("P") * 8
+
+    # Retrieve hostname
+    config.pki_hostname = socket.getfqdn()
+
+    # Retrieve DNS domainname
+    try:
+        config.pki_dns_domainname = subprocess.check_output("dnsdomainname",
+                                                            shell = True)
+        config.pki_dns_domainname = config.pki_dns_domainname.rstrip('\n')
+        if not len(config.pki_dns_domainname):
+            print log.PKI_DNS_DOMAIN_NOT_SET
+            sys.exit(1)
+    except subprocess.CalledProcessError as exc:
+        print log.PKI_SUBPROCESS_ERROR_1 % exc
+        sys.exit(1)
+
+    # Read and process command-line arguments.
+    parser = PKIConfigParser(
+        'PKI Instance Installation and Configuration',
+        log.PKISPAWN_EPILOG)
+
+    parser.optional.add_argument('-f',
+        dest='user_deployment_cfg', action='store',
+        nargs=1, metavar='<file>',
+        help='configuration filename '
+            '(MUST specify complete path)')
+
+    args = parser.process_command_line_arguments()
+
+    config.default_deployment_cfg = config.PKI_DEPLOYMENT_DEFAULT_CONFIGURATION_FILE
+
+    # -f <user deployment config>
+    if args.user_deployment_cfg is not None:
+        config.user_deployment_cfg = str(args.user_deployment_cfg).strip('[\']')
+
+    parser.validate()
+    interactive = False
+
+    while True:
+
+        # -s <subsystem>
+        if args.pki_subsystem is None:
+            interactive = True
+            parser.indent = 0
+
+            config.pki_subsystem = parser.read_text('Subsystem (CA/KRA/OCSP/TKS/TPS)',
+                options=['CA', 'KRA', 'OCSP', 'TKS', 'TPS'],
+                default='CA', caseSensitive=False).upper()
+            print
+        else:
+            config.pki_subsystem = str(args.pki_subsystem).strip('[\']')
+
+        parser.init_config()
+
+        if config.user_deployment_cfg is None:
+            interactive = True
+            parser.indent = 2
+
+            print "Tomcat:"
+            parser.read_text('Instance', 'DEFAULT', 'pki_instance_name')
+            parser.read_text('HTTP port', config.pki_subsystem, 'pki_http_port')
+            parser.read_text('Secure HTTP port', config.pki_subsystem, 'pki_https_port')
+            parser.read_text('AJP port', config.pki_subsystem, 'pki_ajp_port')
+            parser.read_text('Management port', config.pki_subsystem, 'pki_tomcat_server_port')
+            print
+
+            print "Administrator:"
+            parser.read_text('Username', config.pki_subsystem, 'pki_admin_uid')
+
+            admin_password = parser.read_password(
+                'Password', config.pki_subsystem, 'pki_admin_password',
+                verifyMessage='Verify password')
+
+            parser.set_property(config.pki_subsystem, 'pki_backup_password', admin_password)
+            parser.set_property(config.pki_subsystem, 'pki_client_database_password', admin_password)
+            parser.set_property(config.pki_subsystem, 'pki_client_pkcs12_password', admin_password)
+
+            if parser.pki_master_dict['pki_import_admin_cert'] == 'True':
+                import_cert = 'Y'
+            else:
+                import_cert = 'N'
+
+            import_cert = parser.read_text('Import certificate (Yes/No)',
+                default=import_cert, options=['Yes', 'Y', 'No', 'N'],
+                sign='?', caseSensitive=False).lower()
+
+            if import_cert == 'y' or import_cert == 'yes':
+                parser.set_property(config.pki_subsystem, 'pki_import_admin_cert', 'True')
+                parser.read_text('Import certificate from', config.pki_subsystem, 'pki_admin_cert_file')
+            else:
+                parser.set_property(config.pki_subsystem, 'pki_import_admin_cert', 'False')
+
+            parser.read_text('Export certificate to', config.pki_subsystem, 'pki_client_admin_cert')
+            print
+
+            print "Directory Server:"
+            while True:
+                parser.read_text('Hostname', config.pki_subsystem, 'pki_ds_hostname')
+                parser.read_text('Port', config.pki_subsystem, 'pki_ds_ldap_port')
+
+                try:
+                    parser.ds_connect()
+                    break
+
+                except ldap.LDAPError as e:
+                    parser.print_text('ERROR: ' + e.message['desc'])
+
+            while True:
+                parser.read_text('Bind DN', config.pki_subsystem, 'pki_ds_bind_dn')
+                parser.read_password('Password', config.pki_subsystem, 'pki_ds_password')
+
+                try:
+                    parser.ds_bind()
+                    break
+
+                except ldap.LDAPError as e:
+                    parser.print_text('ERROR: ' + e.message['desc'])
+
+            while True:
+                parser.read_text('Base DN', config.pki_subsystem, 'pki_ds_base_dn')
+                try:
+                    if not parser.ds_base_dn_exists():
+                        break
+
+                except ldap.LDAPError as e:
+                    parser.print_text('ERROR: ' + e.message['desc'])
+                    continue
+
+                remove = parser.read_text('Base DN already exists. Overwrite (Yes/No/Quit)',
+                    options=['Yes', 'Y', 'No', 'N', 'Quit', 'Q'],
+                    sign='?', allowEmpty=False, caseSensitive=False).lower()
+
+                if remove == 'q' or remove == 'quit':
+                    print "Installation canceled."
+                    sys.exit(0)
+
+                if remove == 'y' or remove == 'yes':
+                    break
+
+            parser.ds_close()
+
+            print
+
+            print "Security Domain:"
+
+            if config.pki_subsystem == "CA":
+                parser.read_text('Name', config.pki_subsystem, 'pki_security_domain_name')
+
+            else:
+                while True:
+                    parser.read_text('Hostname', config.pki_subsystem, 'pki_security_domain_hostname')
+                    parser.read_text('Secure HTTP port', config.pki_subsystem, 'pki_security_domain_https_port')
+
+                    try:
+                        parser.sd_connect()
+                        info = parser.sd_get_info()
+                        parser.print_text('Name: ' + info.name)
+                        parser.set_property(config.pki_subsystem, 'pki_security_domain_name', info.name)
+                        break
+                    except requests.exceptions.ConnectionError as e:
+                        parser.print_text('ERROR: ' + str(e))
+
+                while True:
+                    parser.read_text('Username', config.pki_subsystem, 'pki_security_domain_user')
+                    parser.read_password('Password', config.pki_subsystem, 'pki_security_domain_password')
+
+                    try:
+                        parser.sd_authenticate()
+                        break
+                    except requests.exceptions.HTTPError as e:
+                        parser.print_text('ERROR: ' + str(e))
+
+            print
+
+        if interactive:
+            parser.indent = 0
+
+            begin = parser.read_text('Begin installation (Yes/No/Quit)',
+                options=['Yes', 'Y', 'No', 'N', 'Quit', 'Q'],
+                sign='?', allowEmpty=False, caseSensitive=False).lower()
+            print
+
+            if begin == 'q' or begin == 'quit':
+                print "Installation canceled."
+                sys.exit(0)
+
+            if begin == 'y' or begin == 'yes':
+                break
+
+        else:
+            break
+
+    if not os.path.exists(config.PKI_DEPLOYMENT_SOURCE_ROOT + \
+                          "/" + config.pki_subsystem.lower()):
+        print "ERROR:  " + log.PKI_SUBSYSTEM_NOT_INSTALLED_1 % \
+            config.pki_subsystem.lower()
+        sys.exit(1)
+
+    # Enable 'pkispawn' logging.
+    rv = 0
+    config.pki_log_dir = config.pki_root_prefix + \
+                         config.PKI_DEPLOYMENT_LOG_ROOT
+    config.pki_log_name = "pki" + "-" + \
+                          config.pki_subsystem.lower() + \
+                          "-" + "spawn" + "." + \
+                          config.pki_timestamp + "." + "log"
+    rv = pkilogging.enable_pki_logger(config.pki_log_dir,
+                                      config.pki_log_name,
+                                      config.pki_log_level,
+                                      config.pki_console_log_level,
+                                      "pkispawn")
+    if rv != OSError:
+        config.pki_log = rv
+    else:
+        print log.PKI_UNABLE_TO_CREATE_LOG_DIRECTORY_1 % config.pki_log_dir
+        sys.exit(1)
+
+    # Read the specified PKI configuration file.
+    rv = parser.read_pki_configuration_file()
+    if rv != 0:
+        config.pki_log.error(log.PKI_UNABLE_TO_PARSE_1, rv,
+                             extra=config.PKI_INDENTATION_LEVEL_0)
+        sys.exit(1)
+
+    # Read in the PKI slots configuration file.
+    parser.compose_pki_slots_dictionary()
+    config.pki_log.debug(log.PKI_DICTIONARY_SLOTS,
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+    config.pki_log.debug(pkilogging.log_format(parser.pki_slots_dict),
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+
+    # Combine the various sectional dictionaries into a PKI master dictionary
+    parser.compose_pki_master_dictionary()
+
+    parser.pki_master_dict['pki_spawn_log'] = config.pki_log_dir + "/" + \
+                                              config.pki_log_name
+    config.pki_log.debug(log.PKI_DICTIONARY_MASTER,
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+    config.pki_log.debug(pkilogging.log_format(parser.pki_master_dict),
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+
+    if not interactive and\
+        not config.str2bool(parser.pki_master_dict['pki_skip_configuration']):
+        try:
+            parser.ds_connect()
+            parser.ds_bind()
+
+            if parser.ds_base_dn_exists() and\
+                not config.str2bool(parser.pki_master_dict['pki_ds_remove_data']):
+                print 'ERROR:  Base DN already exists.'
+                sys.exit(1)
+
+            parser.ds_close()
+
+        except ldap.LDAPError as e:
+            print 'ERROR:  Unable to access directory server: ' + e.message['desc']
+            sys.exit(1)
+
+        if config.pki_subsystem != "CA" or\
+            config.str2bool(parser.pki_master_dict['pki_clone']) or\
+            config.str2bool(parser.pki_master_dict['pki_subordinate']):
+            try:
+                parser.sd_connect()
+                info = parser.sd_get_info()
+                parser.set_property(config.pki_subsystem, 'pki_security_domain_name', info.name)
+                parser.sd_authenticate()
+
+            except requests.exceptions.ConnectionError as e:
+                print('ERROR:  Unable to access security domain: ' + str(e))
+                sys.exit(1)
+
+            except requests.exceptions.HTTPError as e:
+                print('ERROR:  Unable to access security domain: ' + str(e))
+                sys.exit(1)
+
+    print "Installing " + config.pki_subsystem + " into " + parser.pki_master_dict['pki_instance_path'] + "."
+
+    # Process the various "scriptlets" to create the specified PKI subsystem.
+    pki_subsystem_scriptlets = parser.pki_master_dict['spawn_scriplets'].split()
+    deployer = util.PKIDeployer(parser.pki_master_dict, parser.pki_slots_dict)
+    rv = 0
+    for pki_scriptlet in pki_subsystem_scriptlets:
+        scriptlet = __import__("pki.server.deployment.scriptlets." +
+                               pki_scriptlet,
+                               fromlist=[pki_scriptlet])
+        instance = scriptlet.PkiScriptlet()
+        try:
+            rv = instance.spawn(deployer)
+        # pylint: disable-msg=W0703
+        except Exception:
+            log_error_details()
+            print
+            print "Installation failed."
+            print
+            sys.exit(1)
+        if rv != 0:
+            print "Nothing here!!!"
+            print "Installation failed."
+            sys.exit(1)
+    config.pki_log.debug(log.PKI_DICTIONARY_MASTER,
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+    config.pki_log.debug(pkilogging.log_format(parser.pki_master_dict),
+                         extra=config.PKI_INDENTATION_LEVEL_0)
+
+    print_install_information(parser.pki_master_dict)
+
+def print_install_information(pki_master_dict):
+
+    skip_configuration = config.str2bool(pki_master_dict['pki_skip_configuration'])
+    print log.PKI_SPAWN_INFORMATION_HEADER
+    if skip_configuration:
+        print log.PKI_CONFIGURATION_URL_1 % pki_master_dict['pki_configuration_url']
+        print
+        print log.PKI_CONFIGURATION_RESTART_1 % \
+              pki_master_dict['pki_registry_initscript_command']
+    else:
+        print "      Administrator's username:             %s" % pki_master_dict['pki_admin_uid']
+        if os.path.isfile(pki_master_dict['pki_client_admin_cert_p12']):
+            print "      Administrator's PKCS #12 file:\n            %s" % (pki_master_dict['pki_client_dir'] + '/ca_admin_cert.p12')
+        if not config.str2bool(pki_master_dict['pki_client_database_purge']):
+            print
+            print "      Administrator's certificate nickname: %s" % pki_master_dict['pki_admin_nickname']
+            print "      Administrator's certificate database:\n            %s" % pki_master_dict['pki_client_database_dir']
+        print
+        print log.PKI_CHECK_STATUS_MESSAGE % pki_master_dict['pki_instance_name']
+        print log.PKI_INSTANCE_RESTART_MESSAGE % pki_master_dict['pki_instance_name']
+        print log.PKI_ACCESS_URL % (pki_master_dict['pki_hostname'],
+                                    pki_master_dict['pki_https_port'],
+                                    config.pki_subsystem.lower())
+    print log.PKI_SPAWN_INFORMATION_FOOTER
+
+def log_error_details():
+
+    e_type, e_value, e_stacktrace = sys.exc_info()
+    config.pki_log.debug("Error Type: " + e_type.__name__, extra=config.PKI_INDENTATION_LEVEL_2)
+    config.pki_log.debug("Error Message: " + str(e_value), extra=config.PKI_INDENTATION_LEVEL_2)
+    stacktrace_list = traceback.format_list(traceback.extract_tb(e_stacktrace))
+    e_stacktrace = ""
+    for l in stacktrace_list:
+        e_stacktrace += l
+    config.pki_log.debug(e_stacktrace, extra=config.PKI_INDENTATION_LEVEL_2)
+    sys.exc_clear()
+
+# PKI Deployment Entry Point
+if __name__ == "__main__":
+    signal.signal(signal.SIGINT, interrupt_handler)
+    main(sys.argv)