API tools faq
paste
arvind_gluu

setup.py

arvind_gluu
Nov 20th, 2017
58
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 132.13 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/python
  2. # The MIT License (MIT)
  3. #
  4. # Copyright (c) 2014 Gluu
  5. #
  6. # Permission is hereby granted, free of charge, to any person obtaining a copy
  7. # of this software and associated documentation files (the "Software"), to deal
  8. # in the Software without restriction, including without limitation the rights
  9. # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10. # copies of the Software, and to permit persons to whom the Software is
  11. # furnished to do so, subject to the following conditions:
  12. #
  13. # The above copyright notice and this permission notice shall be included in all
  14. # copies or substantial portions of the Software.
  15. #
  16. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17. # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18. # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19. # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20. # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21. # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22. # SOFTWARE.
  23.  
  24.  
  25. import os.path
  26. import Properties
  27. import random
  28. import shutil
  29. import socket
  30. import string
  31. import time
  32. import uuid
  33. import json
  34. import traceback
  35. import subprocess
  36. import sys
  37. import getopt
  38. import hashlib
  39. import re
  40. import glob
  41. import base64
  42.  
  43. from pyDes import *
  44.  
  45.  
  46. class Setup(object):
  47.     def __init__(self, install_dir=None):
  48.         self.install_dir = install_dir
  49.  
  50.         self.oxVersion = '3.1.1.Final'
  51.         self.githubBranchName = 'version_3.1.1'
  52.  
  53.         # Used only if -w (get wars) options is given to setup.py
  54.         self.oxauth_war = 'https://ox.gluu.org/maven/org/xdi/oxauth-server/%s/oxauth-server-%s.war' % (self.oxVersion, self.oxVersion)
  55.         self.oxauth_rp_war = 'https://ox.gluu.org/maven/org/xdi/oxauth-rp/%s/oxauth-rp-%s.war' % (self.oxVersion, self.oxVersion)
  56.         self.oxtrust_war = 'https://ox.gluu.org/maven/org/xdi/oxtrust-server/%s/oxtrust-server-%s.war' % (self.oxVersion, self.oxVersion)
  57.         self.idp3_war = 'http://ox.gluu.org/maven/org/xdi/oxshibbolethIdp/%s/oxshibbolethIdp-%s.war' % (self.oxVersion, self.oxVersion)
  58.         self.idp3_dist_jar = 'http://ox.gluu.org/maven/org/xdi/oxShibbolethStatic/%s/oxShibbolethStatic-%s.jar' % (self.oxVersion, self.oxVersion)
  59.         self.idp3_cml_keygenerator = 'http://ox.gluu.org/maven/org/xdi/oxShibbolethKeyGenerator/%s/oxShibbolethKeyGenerator-%s.jar' % (self.oxVersion, self.oxVersion)
  60.         self.asimba_war = 'http://ox.gluu.org/maven/org/asimba/asimba-wa/%s/asimba-wa-%s.war' % (self.oxVersion, self.oxVersion)
  61.         self.ce_setup_zip = 'https://github.com/GluuFederation/community-edition-setup/archive/%s.zip' % self.githubBranchName
  62.         self.java_1_8_jce_zip = 'http://download.oracle.com/otn-pub/java/jce/8/jce_policy-8.zip'
  63.  
  64.         self.downloadWars = None
  65.         self.templateRenderingDict = {}
  66.  
  67.         # OS commands
  68.         self.cmd_ln = '/bin/ln'
  69.         self.cmd_chmod = '/bin/chmod'
  70.         self.cmd_chown = '/bin/chown'
  71.         self.cmd_chgrp = '/bin/chgrp'
  72.         self.cmd_mkdir = '/bin/mkdir'
  73.         self.cmd_rpm = '/bin/rpm'
  74.         self.cmd_dpkg = '/usr/bin/dpkg'
  75.         self.opensslCommand = '/usr/bin/openssl'
  76.  
  77.         self.sysemProfile = "/etc/profile"
  78.  
  79.         # java commands
  80.         self.jre_home = '/opt/jre'
  81.         self.cmd_java = '%s/bin/java' % self.jre_home
  82.         self.cmd_keytool = '%s/bin/keytool' % self.jre_home
  83.         self.cmd_jar = '%s/bin/jar' % self.jre_home
  84.  
  85.         # Component versions
  86.         self.jre_version = '112'
  87.         self.jetty_version = '9.3.15.v20161220'
  88.         self.jython_version = '2.7.0'
  89.         self.node_version = '6.9.1'
  90.         self.apache_version = None
  91.         self.opendj_version = None
  92.  
  93.         # Gluu components installation status
  94.         self.installOxAuth = True
  95.         self.installOxTrust = True
  96.         self.installLdap = True
  97.         self.installHttpd = True
  98.         self.installSaml = False
  99.         self.installAsimba = False
  100.         self.installOxAuthRP = False
  101.         self.installPassport = False
  102.         self.allowPreReleasedApplications = False
  103.         self.allowDeprecatedApplications = False
  104.  
  105.     self.jreDestinationPath = '/opt/jdk1.8.0_%s' % self.jre_version
  106.  
  107.     self.os_types = ['centos', 'redhat', 'fedora', 'ubuntu', 'debian']
  108.         self.os_type = None
  109.         self.os_initdaemon = None
  110.  
  111.         self.shibboleth_version = 'v3'
  112.  
  113.         self.distFolder = '/opt/dist'
  114.         self.distAppFolder = '%s/app' % self.distFolder
  115.         self.distGluuFolder = '%s/gluu' % self.distFolder
  116.         self.distTmpFolder = '%s/tmp' % self.distFolder
  117.  
  118.         self.setup_properties_fn = '%s/setup.properties' % self.install_dir
  119.         self.log = '%s/setup.log' % self.install_dir
  120.         self.logError = '%s/setup_error.log' % self.install_dir
  121.         self.savedProperties = '%s/setup.properties.last' % self.install_dir
  122.  
  123.         self.gluuOptFolder = '/opt/gluu'
  124.         self.gluuOptBinFolder = '%s/bin' % self.gluuOptFolder
  125.         self.gluuOptSystemFolder = '%s/system' % self.gluuOptFolder
  126.         self.gluuOptPythonFolder = '%s/python' % self.gluuOptFolder
  127.         self.gluuBaseFolder = '/etc/gluu'
  128.         self.configFolder = '%s/conf' % self.gluuBaseFolder
  129.         self.certFolder = '/etc/certs'
  130.  
  131.         self.oxBaseDataFolder = "/var/ox"
  132.         self.oxPhotosFolder = "/var/ox/photos"
  133.         self.oxTrustRemovedFolder = "/var/ox/identity/removed"
  134.         self.oxTrustCacheRefreshFolder = "/var/ox/identity/cr-snapshots"
  135.  
  136.         self.etc_hosts = '/etc/hosts'
  137.         self.etc_hostname = '/etc/hostname'
  138.         # OS /etc/default folder
  139.         self.osDefault = '/etc/default'
  140.  
  141.         self.jython_home = '/opt/jython'
  142.  
  143.         self.node_home = '/opt/node'
  144.         self.node_initd_script = '%s/static/system/initd/node' % self.install_dir
  145.         self.node_base = '%s/node' % self.gluuOptFolder
  146.         self.node_user_home = '/home/node'
  147.  
  148.         self.jetty_dist = '/opt/jetty-9.3'
  149.         self.jetty_home = '/opt/jetty'
  150.         self.jetty_base = '%s/jetty' % self.gluuOptFolder
  151.         self.jetty_user_home = '/home/jetty'
  152.         self.jetty_user_home_lib = '%s/lib' % self.jetty_user_home
  153.         self.jetty_app_configuration = {
  154.                 'oxauth' : {'name' : 'oxauth',
  155.                             'jetty' : {'modules' : 'deploy,http,logging,jsp,servlets,ext,http-forwarded,websocket'},
  156.                             'memory' : {'ratio' : 0.3, "jvm_heap_ration" : 0.7, "max_allowed_mb" : 4096},
  157.                             'installed' : False
  158.             },
  159.                 'identity' : {'name' : 'identity',
  160.                               'jetty' : {'modules' : 'deploy,http,logging,jsp,ext,http-forwarded,websocket'},
  161.                               'memory' : {'ratio' : 0.2, "jvm_heap_ration" : 0.7, "max_allowed_mb" : 2048},
  162.                               'installed' : False
  163.             },
  164.                 'idp' : {'name' : 'idp',
  165.                          'jetty' : {'modules' : 'deploy,http,logging,jsp,http-forwarded'},
  166.                          'memory' : {'ratio' : 0.2, "jvm_heap_ration" : 0.7, "max_allowed_mb" : 1024},
  167.                          'installed' : False
  168.             },
  169.                 'asimba' : {'name' : 'asimba',
  170.                          'jetty' : {'modules' : 'deploy,http,logging,jsp,http-forwarded'},
  171.                          'memory' : {'ratio' : 0.1, "jvm_heap_ration" : 0.7, "max_allowed_mb" : 1024},
  172.                          'installed' : False
  173.             },
  174.                 'oxauth-rp' : {'name' : 'oxauth-rp',
  175.                          'jetty' : {'modules' : 'deploy,http,logging,jsp,http-forwarded,websocket'},
  176.                          'memory' : {'ratio' : 0.1, "jvm_heap_ration" : 0.7, "max_allowed_mb" : 512},
  177.                          'installed' : False
  178.             },
  179.                 'passport' : {'name' : 'passport',
  180.                          'node' : {},
  181.                          'memory' : {'ratio' : 0.05, "max_allowed_mb" : 1024},
  182.                          'installed' : False
  183.             }
  184.         }
  185.  
  186.         self.app_custom_changes = {
  187.             'jetty' : {
  188.                 'name' : 'jetty',
  189.                 'files' : [{
  190.                        'path' : '%s/etc/webdefault.xml' % self.jetty_home,
  191.                        'replace' : [
  192.                            {
  193.                                'pattern' : r'(\<param-name\>dirAllowed<\/param-name\>)(\s*)(\<param-value\>)true(\<\/param-value\>)',
  194.                                'update' : r'\1\2\3false\4'
  195.                             }
  196.                         ]
  197.                 },
  198.                 {
  199.                        'path' : '%s/etc/jetty.xml' % self.jetty_home,
  200.                        'replace' : [
  201.                            {
  202.                                'pattern' : '<New id="DefaultHandler" class="org.eclipse.jetty.server.handler.DefaultHandler"/>',
  203.                                'update' : '<New id="DefaultHandler" class="org.eclipse.jetty.server.handler.DefaultHandler">\n\t\t\t\t <Set name="showContexts">false</Set>\n\t\t\t </New>'
  204.                             }
  205.                         ]
  206.                 }]
  207.             }
  208.         }
  209.  
  210.         self.idp3Folder = "/opt/shibboleth-idp"
  211.         self.idp3MetadataFolder = "%s/metadata" % self.idp3Folder
  212.         self.idp3MetadataCredentialsFolder = "%s/credentials" % self.idp3MetadataFolder
  213.         self.idp3LogsFolder = "%s/logs" % self.idp3Folder
  214.         self.idp3LibFolder = "%s/lib" % self.idp3Folder
  215.         self.idp3ConfFolder = "%s/conf" % self.idp3Folder
  216.         self.idp3ConfAuthnFolder = "%s/conf/authn" % self.idp3Folder
  217.         self.idp3CredentialsFolder = "%s/credentials" % self.idp3Folder
  218.         self.idp3WebappFolder = "%s/webapp" % self.idp3Folder
  219.         # self.idp3WarFolder = "%s/war"
  220.  
  221.         self.hostname = None
  222.         self.ip = None
  223.         self.orgName = None
  224.         self.orgShortName = None
  225.         self.countryCode = None
  226.         self.city = None
  227.         self.state = None
  228.         self.admin_email = None
  229.         self.encoded_ox_ldap_pw = None
  230.         self.encoded_ldap_pw = None
  231.         self.encoded_shib_jks_pw = None
  232.         self.application_max_ram = None    # in MB
  233.         self.encode_salt = None
  234.  
  235.         self.baseInum = None
  236.         self.inumOrg = None
  237.         self.inumAppliance = None
  238.         self.inumOrgFN = None
  239.         self.inumApplianceFN = None
  240.         self.ldapBaseFolderldapPass = None
  241.         self.oxauth_client_id = None
  242.         self.oxauthClient_pw = None
  243.         self.oxauthClient_encoded_pw = None
  244.         self.oxTrustConfigGeneration = None
  245.  
  246.         self.outputFolder = '%s/output' % self.install_dir
  247.         self.templateFolder = '%s/templates' % self.install_dir
  248.  
  249.         self.extensionFolder = '%s/static/extension' % self.install_dir
  250.  
  251.         self.oxauth_error_json = '%s/static/oxauth/oxauth-errors.json' % self.install_dir
  252.  
  253.         self.oxauth_openid_jwks_fn = "%s/oxauth-keys.json" % self.certFolder
  254.         self.oxauth_openid_jks_fn = "%s/oxauth-keys.jks" % self.certFolder
  255.         self.oxauth_openid_jks_pass = None
  256.  
  257.         self.httpdKeyPass = None
  258.         self.httpdKeyFn = '%s/httpd.key' % self.certFolder
  259.         self.httpdCertFn = '%s/httpd.crt' % self.certFolder
  260.         self.shibJksPass = None
  261.         self.shibJksFn = '%s/shibIDP.jks' % self.certFolder
  262.         self.asimbaJksPass = None
  263.         self.asimbaJksFn = '%s/asimbaIDP.jks' % self.certFolder
  264.  
  265.         self.opendj_ldap_binddn = 'cn=directory manager'
  266.         self.ldap_hostname = "localhost"
  267.         self.ldap_port = '1389'
  268.         self.ldaps_port = '1636'
  269.         self.ldap_jmx_port = '1689'
  270.         self.ldap_admin_port = '4444'
  271.         self.ldapBaseFolder = '/opt/opendj'
  272.         self.ldap_user_home = '/home/ldap'
  273.         self.ldapPassFn = '%s/.pw' % self.ldap_user_home
  274.         self.ldap_backend_type = 'je'
  275.         self.importLdifCommand = '%s/bin/import-ldif' % self.ldapBaseFolder
  276.         self.ldapModifyCommand = '%s/bin/ldapmodify' % self.ldapBaseFolder
  277.         self.loadLdifCommand = self.ldapModifyCommand
  278.         self.gluuScriptFiles = ['%s/static/scripts/logmanager.sh' % self.install_dir,
  279.                                 '%s/static/scripts/testBind.py' % self.install_dir]
  280.         self.redhat_services = ['memcached', 'httpd', 'rsyslog']
  281.         self.debian_services = ['memcached', 'apache2', 'rsyslog']
  282.  
  283.         self.apache_start_script = '/etc/init.d/httpd'
  284.  
  285.         self.defaultTrustStoreFN = '%s/jre/lib/security/cacerts' % self.jre_home
  286.         self.defaultTrustStorePW = 'changeit'
  287.  
  288.         self.openldapBaseFolder = '/opt/symas'
  289.         self.openldapBinFolder = '/opt/symas/bin'
  290.         self.openldapConfFolder = '/opt/symas/etc/openldap'
  291.         self.openldapRootUser = "cn=directory manager,o=gluu"
  292.         self.openldapSiteUser = "cn=directory manager,o=site"
  293.         self.openldapKeyPass = None
  294.         self.openldapTLSCACert = '%s/openldap.pem' % self.certFolder
  295.         self.openldapTLSCert = '%s/openldap.crt' % self.certFolder
  296.         self.openldapTLSKey = '%s/openldap.key' % self.certFolder
  297.         self.openldapJksPass = None
  298.         self.openldapJksFn = '%s/openldap.jks' % self.certFolder
  299.  
  300.         self.passportSpKeyPass = None
  301.         self.passportSpTLSCACert = '%s/passport-sp.pem' % self.certFolder
  302.         self.passportSpTLSCert = '%s/passport-sp.crt' % self.certFolder
  303.         self.passportSpTLSKey = '%s/passport-sp.key' % self.certFolder
  304.         self.passportSpJksPass = None
  305.         self.passportSpJksFn = '%s/passport-sp.jks' % self.certFolder        
  306.  
  307.         self.openldapSlapdConf = '%s/slapd.conf' % self.outputFolder
  308.         self.openldapSymasConf = '%s/symas-openldap.conf' % self.outputFolder
  309.         self.openldapRootSchemaFolder = "%s/schema" % self.gluuOptFolder
  310.         self.openldapSchemaFolder = "%s/openldap" % self.openldapRootSchemaFolder
  311.         self.openldapLogDir = "/var/log/openldap/"
  312.         self.openldapSyslogConf = "%s/static/openldap/openldap-syslog.conf" % self.install_dir
  313.         self.openldapLogrotate = "%s/static/openldap/openldap_logrotate" % self.install_dir
  314.         self.openldapSetupAccessLog = False
  315.         self.accessLogConfFile = "%s/static/openldap/accesslog.conf" % self.install_dir
  316.         self.gluuAccessLogConf = "%s/static/openldap/o_gluu_accesslog.conf" % self.install_dir
  317.         self.opendlapIndexDef = "%s/static/openldap/index.json" % self.install_dir
  318.  
  319.         # Stuff that gets rendered; filename is necessary. Full path should
  320.         # reflect final path if the file must be copied after its rendered.
  321.         self.oxauth_config_json = '%s/oxauth-config.json' % self.outputFolder
  322.         self.oxtrust_config_json = '%s/oxtrust-config.json' % self.outputFolder
  323.         self.oxtrust_cache_refresh_json = '%s/oxtrust-cache-refresh.json' % self.outputFolder
  324.         self.oxtrust_import_person_json = '%s/oxtrust-import-person.json' % self.outputFolder
  325.         self.oxidp_config_json = '%s/oxidp-config.json' % self.outputFolder
  326.         self.oxasimba_config_json = '%s/oxasimba-config.json' % self.outputFolder
  327.         self.gluu_python_base = '%s/python' % self.gluuOptFolder
  328.         self.gluu_python_readme = '%s/libs/python.txt' % self.gluuOptPythonFolder
  329.         self.ox_ldap_properties = '%s/ox-ldap.properties' % self.configFolder
  330.         self.oxauth_static_conf_json = '%s/oxauth-static-conf.json' % self.outputFolder
  331.         self.oxTrust_log_rotation_configuration = "%s/conf/oxTrustLogRotationConfiguration.xml" % self.gluuBaseFolder
  332.         self.apache2_conf = '%s/httpd.conf' % self.outputFolder
  333.         self.apache2_ssl_conf = '%s/https_gluu.conf' % self.outputFolder
  334.         self.apache2_24_conf = '%s/httpd_2.4.conf' % self.outputFolder
  335.         self.apache2_ssl_24_conf = '%s/https_gluu.conf' % self.outputFolder
  336.         self.ldif_base = '%s/base.ldif' % self.outputFolder
  337.         self.ldif_appliance = '%s/appliance.ldif' % self.outputFolder
  338.         self.ldif_attributes = '%s/attributes.ldif' % self.outputFolder
  339.         self.ldif_scopes = '%s/scopes.ldif' % self.outputFolder
  340.         self.ldif_clients = '%s/clients.ldif' % self.outputFolder
  341.         self.ldif_people = '%s/people.ldif' % self.outputFolder
  342.         self.ldif_groups = '%s/groups.ldif' % self.outputFolder
  343.         self.ldif_site = '%s/static/cache-refresh/o_site.ldif' % self.install_dir
  344.         self.ldif_scripts = '%s/scripts.ldif' % self.outputFolder
  345.         self.ldif_configuration = '%s/configuration.ldif' % self.outputFolder
  346.         self.ldif_scim = '%s/scim.ldif' % self.outputFolder
  347.         self.ldif_asimba = '%s/asimba.ldif' % self.outputFolder
  348.         self.ldif_passport = '%s/passport.ldif' % self.outputFolder
  349.         self.ldif_idp = '%s/oxidp.ldif' % self.outputFolder
  350.         self.passport_config = '%s/passport-config.json' % self.configFolder
  351.         self.encode_script = '%s/bin/encode.py' % self.gluuOptFolder
  352.         self.network = "/etc/sysconfig/network"
  353.         self.system_profile_update = '%s/system_profile' % self.outputFolder
  354.        
  355.         self.asimba_conf_folder = '%s/asimba' % self.configFolder
  356.         self.asimba_configuration_xml = '%s/asimba.xml' % self.asimba_conf_folder
  357.         self.asimba_configuration = '%s/asimba.xml' % self.outputFolder
  358.         self.asimba_selector_configuration = '%s/asimba-selector.xml' % self.outputFolder
  359.         self.asimba_properties = '%s/asimba.properties' % self.outputFolder
  360.         self.asimba_selector_configuration_xml = '%s/asimba-selector.xml' % self.asimba_conf_folder
  361.  
  362.         self.staticIDP3FolderConf = '%s/static/idp3/conf' % self.install_dir
  363.         self.staticIDP3FolderMetadata = '%s/static/idp3/metadata' % self.install_dir
  364.         self.idp3_configuration_properties = 'idp.properties'
  365.         self.idp3_configuration_ldap_properties = 'ldap.properties'
  366.         self.idp3_configuration_saml_nameid = 'saml-nameid.properties'
  367.         self.idp3_configuration_services = 'services.properties'
  368.         self.idp3_configuration_password_authn = 'authn/password-authn-config.xml'
  369.         self.idp3_metadata = 'idp-metadata.xml'
  370.  
  371.         ### rsyslog file customised for init.d
  372.         self.rsyslogUbuntuInitFile = "%s/static/system/ubuntu/rsyslog" % self.install_dir
  373.  
  374.         self.ldap_setup_properties = '%s/opendj-setup.properties' % self.templateFolder
  375.  
  376.         # oxAuth/oxTrust Base64 configuration files
  377.         self.pairwiseCalculationKey = None
  378.         self.pairwiseCalculationSalt = None
  379.  
  380.         # OpenID key generation default setting
  381.         self.default_openid_jks_dn_name = 'CN=oxAuth CA Certificates'
  382.         self.default_key_algs = 'RS256 RS384 RS512 ES256 ES384 ES512'
  383.         self.default_key_expiration = 365
  384.  
  385.         # oxTrust SCIM configuration
  386.         self.scim_rs_client_id = None
  387.         self.scim_rs_client_jwks = None
  388.         self.scim_rs_client_jks_fn = "%s/scim-rs.jks" % self.certFolder
  389.         self.scim_rs_client_jks_pass = None
  390.         self.scim_rs_client_jks_pass_encoded = None
  391.  
  392.         self.scim_rp_client_id = None
  393.         self.scim_rp_client_jwks = None
  394.         self.scim_rp_client_jks_fn = "%s/scim-rp.jks" % self.outputFolder
  395.         self.scim_rp_client_jks_pass = 'secret'
  396.  
  397.         # oxPassport Configuration
  398.         self.gluu_passport_base = '%s/passport' % self.node_base
  399.         self.ldif_passport_config = '%s/oxpassport-config.ldif' % self.outputFolder
  400.  
  401.         self.passport_rs_client_id = None
  402.         self.passport_rs_client_jwks = None
  403.         self.passport_rs_client_jks_fn = "%s/passport-rs.jks" % self.certFolder
  404.         self.passport_rs_client_jks_pass = None
  405.         self.passport_rs_client_jks_pass_encoded = None
  406.  
  407.         self.passport_rp_client_id = None
  408.         self.passport_rp_client_jwks = None
  409.         self.passport_rp_client_jks_fn = "%s/passport-rp.jks" % self.certFolder
  410.         self.passport_rp_client_cert_alg = "RS512"
  411.         self.passport_rp_client_cert_alias = None
  412.         self.passport_rp_client_cert_fn = "%s/passport-rp.pem" % self.certFolder
  413.         self.passport_rp_client_jks_pass = 'secret'
  414.  
  415.         self.ldif_files = [self.ldif_base,
  416.                            self.ldif_appliance,
  417.                            self.ldif_attributes,
  418.                            self.ldif_scopes,
  419.                            self.ldif_clients,
  420.                            self.ldif_people,
  421.                            self.ldif_groups,
  422.                            self.ldif_site,
  423.                            self.ldif_scripts,
  424.                            self.ldif_configuration,
  425.                            self.ldif_scim,
  426.                            self.ldif_asimba,
  427.                            self.ldif_passport,
  428.                            self.ldif_passport_config,
  429.                            self.ldif_idp
  430.                            ]
  431.  
  432.         self.ce_templates = {self.oxauth_config_json: False,
  433.                      self.gluu_python_readme: True,
  434.                      self.oxtrust_config_json: False,
  435.                      self.oxtrust_cache_refresh_json: False,
  436.                      self.oxtrust_import_person_json: False,
  437.                      self.oxidp_config_json: False,
  438.                      self.oxasimba_config_json: False,
  439.                      self.ox_ldap_properties: True,
  440.                      self.oxauth_static_conf_json: False,
  441.                      self.oxTrust_log_rotation_configuration: True,
  442.                      self.ldap_setup_properties: False,
  443.                      self.apache2_conf: False,
  444.                      self.apache2_ssl_conf: False,
  445.                      self.apache2_24_conf: False,
  446.                      self.apache2_ssl_24_conf: False,
  447.                      self.etc_hosts: False,
  448.                      self.etc_hostname: False,
  449.                      self.ldif_base: False,
  450.                      self.ldif_appliance: False,
  451.                      self.ldif_attributes: False,
  452.                      self.ldif_scopes: False,
  453.                      self.ldif_clients: False,
  454.                      self.ldif_people: False,
  455.                      self.ldif_groups: False,
  456.                      self.ldif_scripts: False,
  457.                      self.ldif_scim: False,
  458.                      self.ldif_asimba: False,
  459.                      self.ldif_passport: False,
  460.                      self.ldif_passport_config: False,
  461.                      self.ldif_idp: False,
  462.                      self.asimba_configuration: False,
  463.                      self.asimba_properties: False,
  464.                      self.asimba_selector_configuration: False,
  465.                      self.network: False,
  466.                      }
  467.  
  468.         self.oxauth_keys_utils_libs = [ 'bcprov-jdk15on-*.jar', 'bcpkix-jdk15on-*.jar', 'commons-lang-*.jar',
  469.                                         'log4j-*.jar', 'commons-codec-*.jar', 'commons-cli-*.jar', 'commons-io-*.jar',
  470.                                         'jackson-core-*.jar', 'jackson-core-asl-*.jar', 'jackson-mapper-asl-*.jar', 'jackson-xc-*.jar',
  471.                                         'jettison-*.jar', 'oxauth-model-*.jar', 'oxauth-client-*.jar' ]
  472.  
  473.     def __repr__(self):
  474.         try:
  475.             return 'hostname'.ljust(30) + self.hostname.rjust(35) + "\n" \
  476.                 + 'orgName'.ljust(30) + self.orgName.rjust(35) + "\n" \
  477.                 + 'os'.ljust(30) + self.os_type.rjust(35) + "\n" \
  478.                 + 'city'.ljust(30) + self.city.rjust(35) + "\n" \
  479.                 + 'state'.ljust(30) + self.state.rjust(35) + "\n" \
  480.                 + 'countryCode'.ljust(30) + self.countryCode.rjust(35) + "\n" \
  481.                 + 'support email'.ljust(30) + self.admin_email.rjust(35) + "\n" \
  482.                 + 'Applications max ram'.ljust(30) + self.application_max_ram.rjust(35) + "\n" \
  483.                 + 'Admin Pass'.ljust(30) + self.ldapPass.rjust(35) + "\n" \
  484.                 + 'Install oxAuth'.ljust(30) + repr(self.installOxAuth).rjust(35) + "\n" \
  485.                 + 'Install oxTrust'.ljust(30) + repr(self.installOxTrust).rjust(35) + "\n" \
  486.                 + 'Install LDAP'.ljust(30) + repr(self.installLdap).rjust(35) + "\n" \
  487.                 + 'Install JCE 1.8'.ljust(30) + repr(self.installJce).rjust(35) + "\n" \
  488.                 + 'Install Apache 2 web server'.ljust(30) + repr(self.installHttpd).rjust(35) + "\n" \
  489.                 + 'Install Shibboleth SAML IDP'.ljust(30) + repr(self.installSaml).rjust(35) + "\n" \
  490.                 + 'Install Asimba SAML Proxy'.ljust(30) + repr(self.installAsimba).rjust(35) + "\n" \
  491.                 + 'Install oxAuth RP'.ljust(30) + repr(self.installOxAuthRP).rjust(35) + "\n" \
  492.                 + 'Install Passport '.ljust(30) + repr(self.installPassport).rjust(35) + "\n"
  493.         except:
  494.             s = ""
  495.             for key in self.__dict__.keys():
  496.                 val = self.__dict__[key]
  497.                 s = s + "%s\n%s\n%s\n\n" % (key, "-" * len(key), val)
  498.             return s
  499.  
  500.     def set_ownership(self):
  501.         self.logIt("Changing ownership")
  502.         realCertFolder = os.path.realpath(self.certFolder)
  503.         realConfigFolder = os.path.realpath(self.configFolder)
  504.         realOptPythonFolderFolder = os.path.realpath(self.gluuOptPythonFolder)
  505.         realAsimbaJks = os.path.realpath(self.asimbaJksFn)
  506.  
  507.         self.run([self.cmd_chown, '-R', 'root:gluu', realCertFolder])
  508.         self.run([self.cmd_chown, '-R', 'root:gluu', realConfigFolder])
  509.         self.run([self.cmd_chown, '-R', 'root:gluu', realOptPythonFolderFolder])
  510.         self.run([self.cmd_chown, '-R', 'root:gluu', self.oxBaseDataFolder])
  511.  
  512.         # Set right permissions
  513.         self.run([self.cmd_chmod, '-R', '440', realCertFolder])
  514.         self.run([self.cmd_chmod, 'a+X', realCertFolder])
  515.        
  516.         # Set write permission for Asimba's keystore (oxTrust can change it)
  517.         self.run([self.cmd_chmod, 'u+w', realAsimbaJks])
  518.  
  519.         if self.installOxAuth:
  520.             self.run([self.cmd_chown, '-R', 'jetty:jetty', self.oxauth_openid_jwks_fn])
  521.             self.run([self.cmd_chown, '-R', 'jetty:jetty', self.oxauth_openid_jks_fn])
  522.  
  523.         if self.installSaml:
  524.             realIdp3Folder = os.path.realpath(self.idp3Folder)
  525.             self.run([self.cmd_chown, '-R', 'jetty:jetty', realIdp3Folder])
  526.  
  527.     def set_permissions(self):
  528.         self.logIt("Changing permissions")
  529.  
  530.         ### Below commands help us to set permissions readable if umask is set as 077
  531.         self.run(['find', "/opt", '-user', 'root', '-perm', '700', '-exec', 'chmod', "755", '{}',  ';'])
  532.         self.run(['find', "/opt", '-user', 'root', '-perm', '600', '-exec', 'chmod', "644", '{}',  ';'])
  533.         self.run(['find', "/opt", '-user', 'root', '-perm', '400', '-exec', 'chmod', "444", '{}',  ';'])
  534.  
  535.         self.run(['find', "%s" % self.gluuBaseFolder, '-perm', '700', '-exec', self.cmd_chmod, "755", '{}', ';'])
  536.         self.run(['find', "%s" % self.gluuBaseFolder, '-perm', '600', '-exec', self.cmd_chmod, "644", '{}', ';'])
  537.  
  538.         self.run(['find', "%s" % self.osDefault, '-perm', '700', '-exec', self.cmd_chmod, "755", '{}', ';'])
  539.         self.run(['find', "%s" % self.osDefault, '-perm', '600', '-exec', self.cmd_chmod, "644", '{}', ';'])
  540.  
  541.         self.run(['/bin/chmod', '-R', '644', self.etc_hosts])
  542.  
  543.         if self.os_type in ['debian', 'ubuntu']:
  544.             self.run(['/bin/chmod', '-f', '644', self.etc_hostname])
  545.  
  546.         if self.installSaml:
  547.             realIdp3Folder = os.path.realpath(self.idp3Folder)
  548.             realIdp3BinFolder = "%s/bin" % realIdp3Folder;
  549.             if os.path.exists(realIdp3BinFolder):
  550.                 self.run(['find', realIdp3BinFolder, '-name', '*.sh', '-exec', 'chmod', "755", '{}',  ';'])
  551.  
  552.     def get_ip(self):
  553.         testIP = None
  554.         detectedIP = None
  555.         try:
  556.             testSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  557.             detectedIP = [(testSocket.connect(('8.8.8.8', 80)),
  558.                            testSocket.getsockname()[0],
  559.                            testSocket.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]
  560.         except:
  561.             self.logIt("No detected IP address", True)
  562.             self.logIt(traceback.format_exc(), True)
  563.         if detectedIP:
  564.             testIP = self.getPrompt("Enter IP Address", detectedIP)
  565.         else:
  566.             testIP = self.getPrompt("Enter IP Address")
  567.         if not self.isIP(testIP):
  568.             testIP = None
  569.             print 'ERROR: The IP Address is invalid. Try again\n'
  570.         return testIP
  571.  
  572.     def check_properties(self):
  573.         self.logIt('Checking properties')
  574.         while not self.hostname:
  575.             testhost = raw_input('Hostname of this server: ').strip()
  576.             if len(testhost.split('.')) >= 3:
  577.                 self.hostname = testhost
  578.             else:
  579.                 print 'The hostname has to be at least three domain components. Try again\n'
  580.         while not self.ip:
  581.             self.ip = self.get_ip()
  582.         while not self.orgName:
  583.             self.orgName = raw_input('Organization Name: ').strip()
  584.         while not self.countryCode:
  585.             testCode = raw_input('2 Character Country Code: ').strip()
  586.             if len(testCode) == 2:
  587.                 self.countryCode = testCode
  588.             else:
  589.                 print 'Country code should only be two characters. Try again\n'
  590.         while not self.city:
  591.             self.city = raw_input('City: ').strip()
  592.         while not self.state:
  593.             self.state = raw_input('State or Province: ').strip()
  594.         if not self.admin_email:
  595.             tld = None
  596.             try:
  597.                 tld = ".".join(self.hostname.split(".")[-2:])
  598.             except:
  599.                 tld = self.hostname
  600.             self.admin_email = "support@%s" % tld
  601.         if not self.httpdKeyPass:
  602.             self.httpdKeyPass = self.getPW()
  603.         if not self.ldapPass:
  604.             self.ldapPass = self.getPW()
  605.         if not self.shibJksPass:
  606.             self.shibJksPass = self.getPW()
  607.         if not self.oxauth_openid_jks_pass:
  608.             self.oxauth_openid_jks_pass = self.getPW()
  609.         if not self.asimbaJksPass:
  610.             self.asimbaJksPass = self.getPW()
  611.         if not self.openldapKeyPass:
  612.             self.openldapKeyPass = self.getPW()
  613.             self.openldapJksPass = self.getPW()
  614.         if not self.passportSpKeyPass:
  615.             self.passportSpKeyPass = self.getPW()
  616.             self.passportSpJksPass = self.getPW()    
  617.         if not self.encode_salt:
  618.             self.encode_salt= self.getPW() + self.getPW()
  619.         if not self.baseInum:
  620.             self.baseInum = '@!%s.%s.%s.%s' % tuple([self.getQuad() for i in xrange(4)])
  621.         if not self.inumOrg:
  622.             orgTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  623.             self.inumOrg = '%s!0001!%s' % (self.baseInum, orgTwoQuads)
  624.         if not self.inumAppliance:
  625.             applianceTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  626.             self.inumAppliance = '%s!0002!%s' % (self.baseInum, applianceTwoQuads)
  627.         if not self.oxauth_client_id:
  628.             clientTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  629.             self.oxauth_client_id = '%s!0008!%s' % (self.inumOrg, clientTwoQuads)
  630.         if not self.scim_rs_client_id:
  631.             scimClientTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  632.             self.scim_rs_client_id = '%s!0008!%s' % (self.inumOrg, scimClientTwoQuads)
  633.         if not self.scim_rp_client_id:
  634.             scimClientTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  635.             self.scim_rp_client_id = '%s!0008!%s' % (self.inumOrg, scimClientTwoQuads)
  636.         if not self.passport_rs_client_id:
  637.             passportClientTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  638.             self.passport_rs_client_id = '%s!0008!%s' % (self.inumOrg, passportClientTwoQuads)
  639.         if not self.passport_rp_client_id:
  640.             passportClientTwoQuads = '%s.%s' % tuple([self.getQuad() for i in xrange(2)])
  641.             self.passport_rp_client_id = '%s!0008!%s' % (self.inumOrg, passportClientTwoQuads)
  642.         if not self.inumApplianceFN:
  643.             self.inumApplianceFN = self.inumAppliance.replace('@', '').replace('!', '').replace('.', '')
  644.         if not self.inumOrgFN:
  645.             self.inumOrgFN = self.inumOrg.replace('@', '').replace('!', '').replace('.', '')
  646.         if not self.application_max_ram:
  647.             self.application_max_ram = 3072
  648.  
  649.     def choose_from_list(self, list_of_choices, choice_name="item", default_choice_index=0):
  650.         return_value = None
  651.         choice_map = {}
  652.         chosen_index = 0
  653.         print "\nSelect the number for the %s from the following list:" % choice_name
  654.         for choice in list_of_choices:
  655.             choice_map[chosen_index] = choice
  656.             chosen_index += 1
  657.             print "  [%i]   %s" % (chosen_index, choice)
  658.         while not return_value:
  659.             choice_number = self.getPrompt("Please select a number listed above", str(default_choice_index + 1))
  660.             try:
  661.                 choice_number = int(choice_number) - 1
  662.                 if (choice_number >= 0) & (choice_number < len(list_of_choices)):
  663.                     return_value = choice_map[choice_number]
  664.                 else:
  665.                     print '"%i" is not a valid choice' % (choice_number + 1)
  666.             except:
  667.                 print 'Cannot convert "%s" to a number' % choice_number
  668.                 self.logIt(traceback.format_exc(), True)
  669.         return return_value
  670.  
  671.     # = File system  =================================================================
  672.     def findFiles(self, filePatterns, filesFolder):
  673.         foundFiles = []
  674.         try:
  675.             for filePattern in filePatterns:
  676.                 fileFullPathPattern = "%s/%s" % (filesFolder, filePattern)
  677.                 for fileFullPath in glob.iglob(fileFullPathPattern):
  678.                     foundFiles.append(fileFullPath)
  679.         except:
  680.             self.logIt("Error finding files %s in folder %s" % (":".join(filePatterns), filesFolder), True)
  681.             self.logIt(traceback.format_exc(), True)
  682.  
  683.         return foundFiles
  684.  
  685.     def readFile(self, inFilePath):
  686.         inFilePathText = None
  687.  
  688.         try:
  689.             f = open(inFilePath)
  690.             inFilePathText = f.read()
  691.             f.close
  692.         except:
  693.             self.logIt("Error reading %s" % inFilePathText, True)
  694.             self.logIt(traceback.format_exc(), True)
  695.  
  696.         return inFilePathText
  697.  
  698.     def writeFile(self, outFilePath, text):
  699.         inFilePathText = None
  700.  
  701.         try:
  702.             f = open(outFilePath, 'w')
  703.             f.write(text)
  704.             f.close()
  705.         except:
  706.             self.logIt("Error writing %s" % inFilePathText, True)
  707.             self.logIt(traceback.format_exc(), True)
  708.  
  709.         return inFilePathText
  710.  
  711.     def commentOutText(self, text):
  712.         textLines = text.split('\n')
  713.  
  714.         lines = []
  715.         for textLine in textLines:
  716.             lines.append('#%s' % textLine)
  717.    
  718.         return "\n".join(lines)
  719.  
  720.     def replaceInText(self, text, pattern, update):
  721.         rePattern = re.compile(pattern,  flags=re.DOTALL | re.M)
  722.         return rePattern.sub(update, text)
  723.  
  724.     def applyChangesInFiles(self, changes):
  725.         self.logIt("Applying changes to %s files..." % changes['name'])
  726.         for change in changes['files']:
  727.             file = change['path']
  728.  
  729.             text = self.readFile(file)
  730.             file_backup = '%s.bak' % file
  731.             self.writeFile(file_backup, text)
  732.             self.logIt("Created backup of %s file %s..." % (changes['name'], file_backup))
  733.  
  734.             for replace in change['replace']:
  735.                 text = self.replaceInText(text, replace['pattern'], replace['update'])
  736.            
  737.             self.writeFile(file, text)
  738.             self.logIt("Wrote updated %s file %s..." % (changes['name'], file))
  739.  
  740.     def copyFile(self, inFile, destFolder):
  741.         try:
  742.             shutil.copy(inFile, destFolder)
  743.             self.logIt("Copied %s to %s" % (inFile, destFolder))
  744.         except:
  745.             self.logIt("Error copying %s to %s" % (inFile, destFolder), True)
  746.             self.logIt(traceback.format_exc(), True)
  747.  
  748.     def copyTree(self, src, dst, overwrite=False):
  749.         try:
  750.             if not os.path.exists(dst):
  751.                 os.makedirs(dst)
  752.  
  753.             for item in os.listdir(src):
  754.                 s = os.path.join(src, item)
  755.                 d = os.path.join(dst, item)
  756.                 if os.path.isdir(s):
  757.                     self.copyTree(s, d, overwrite)
  758.                 else:
  759.                     if overwrite and os.path.exists(d):
  760.                         self.removeFile(d)
  761.  
  762.                     if not os.path.exists(d) or os.stat(s).st_mtime - os.stat(d).st_mtime > 1:
  763.                         shutil.copy2(s, d)
  764.  
  765.             self.logIt("Copied tree %s to %s" % (src, dst))
  766.         except:
  767.             self.logIt("Error copying tree %s to %s" % (src, dst), True)
  768.             self.logIt(traceback.format_exc(), True)
  769.  
  770.     def createDirs(self, name):
  771.         try:
  772.             if not os.path.exists(name):
  773.                 os.makedirs(name, 0700)
  774.                 self.logIt('Created dir: %s' % name)
  775.         except:
  776.             self.logIt("Error making directory %s" % name, True)
  777.             self.logIt(traceback.format_exc(), True)
  778.  
  779.     def removeDirs(self, name):
  780.         try:
  781.             if os.path.exists(name):
  782.                 shutil.rmtree(name)
  783.                 self.logIt('Removed dir: %s' % name)
  784.         except:
  785.             self.logIt("Error removing directory %s" % name, True)
  786.             self.logIt(traceback.format_exc(), True)
  787.  
  788.     def removeFile(self, fileName):
  789.         try:
  790.             if os.path.exists(fileName):
  791.                 os.remove(fileName)
  792.                 self.logIt('Removed file: %s' % fileName)
  793.         except:
  794.             self.logIt("Error removing file %s" % fileName, True)
  795.             self.logIt(traceback.format_exc(), True)
  796.  
  797.     # = Utilities ====================================================================
  798.  
  799.     def logIt(self, msg, errorLog=False):
  800.         if errorLog:
  801.             f = open(self.logError, 'a')
  802.             f.write('%s %s\n' % (time.strftime('%X %x'), msg))
  803.             f.close()
  804.         f = open(self.log, 'a')
  805.         f.write('%s %s\n' % (time.strftime('%X %x'), msg))
  806.         f.close()
  807.  
  808.     def appendLine(self, line, fileName=False):
  809.         try:
  810.             f = open(fileName, 'a')
  811.             f.write('%s\n' % line)
  812.             f.close()
  813.         except:
  814.             self.logIt("Error loading file %s" % fileName)
  815.  
  816.     def set_ulimits(self):
  817.         try:
  818.             if self.os_type in ['centos', 'redhat', 'fedora']:
  819.                 apache_user = 'apache'
  820.             else:
  821.                 apache_user = 'www-data'
  822.  
  823.             self.appendLine("ldap       soft nofile     131072", "/etc/security/limits.conf")
  824.             self.appendLine("ldap       hard nofile     262144", "/etc/security/limits.conf")
  825.             self.appendLine("%s     soft nofile     131072" % apache_user, "/etc/security/limits.conf")
  826.             self.appendLine("%s     hard nofile     262144" % apache_user, "/etc/security/limits.conf")
  827.             self.appendLine("jetty      soft nofile     131072", "/etc/security/limits.conf")
  828.             self.appendLine("jetty      hard nofile     262144", "/etc/security/limits.conf")
  829.         except:
  830.             self.logIt("Could not set limits.")
  831.             self.logIt(traceback.format_exc(), True)
  832.  
  833.     def load_properties(self, fn):
  834.         self.logIt('Loading Properties %s' % fn)
  835.         p = Properties.Properties()
  836.         try:
  837.             p.load(open(fn))
  838.             properties_list = p.keys()
  839.             for prop in properties_list:
  840.                 try:
  841.                     self.__dict__[prop] = p[prop]
  842.                     if p[prop] == 'True':
  843.                         self.__dict__[prop] = True
  844.                     elif p[prop] == 'False':
  845.                         self.__dict__[prop] = False
  846.                 except:
  847.                     self.logIt("Error loading property %s" % prop)
  848.                     self.logIt(traceback.format_exc(), True)
  849.         except:
  850.             self.logIt("Error loading properties", True)
  851.             self.logIt(traceback.format_exc(), True)
  852.  
  853.     def load_json(self, fn):
  854.         self.logIt('Loading JSON from %s' % fn)
  855.         try:
  856.             json_file = open(fn)
  857.             json_text = json_file.read()
  858.             json_file.close()
  859.             return json.loads(json_text)
  860.         except:
  861.             self.logIt("Unable to read or parse json file from %s" % fn, True)
  862.             self.logIt(traceback.format_exc(), True)
  863.         return None
  864.  
  865.     def obscure(self, data=""):
  866.         engine = triple_des(self.encode_salt, ECB, pad=None, padmode=PAD_PKCS5)
  867.         data = data.encode('ascii')
  868.         en_data = engine.encrypt(data)
  869.         return base64.b64encode(en_data)
  870.  
  871.     # ================================================================================
  872.  
  873.     def configure_httpd(self):
  874.         # Detect sevice path and apache service name
  875.         service_path = '/sbin/service'
  876.         apache_service_name = 'httpd'
  877.         if self.os_type in ['debian', 'ubuntu']:
  878.             service_path = '/usr/sbin/service'
  879.             apache_service_name = 'apache2'
  880.  
  881.         self.run([service_path, apache_service_name, 'stop'])
  882.  
  883.         # CentOS 7.* + systemd + apache 2.4
  884.         if self.os_type in ['centos', 'redhat', 'fedora'] and self.os_initdaemon == 'systemd' and self.apache_version == "2.4":
  885.             self.copyFile(self.apache2_24_conf, '/etc/httpd/conf/httpd.conf')
  886.             self.copyFile(self.apache2_ssl_24_conf, '/etc/httpd/conf.d/https_gluu.conf')
  887.  
  888.         # CentOS 6.* + init + apache 2.2
  889.         if self.os_type == 'centos' and self.os_initdaemon == 'init':
  890.             self.copyFile(self.apache2_conf, '/etc/httpd/conf/httpd.conf')
  891.             self.copyFile(self.apache2_ssl_conf, '/etc/httpd/conf.d/https_gluu.conf')
  892.         if self.os_type in ['redhat', 'fedora'] and self.os_initdaemon == 'init':
  893.             self.copyFile(self.apache2_conf, '/etc/httpd/conf/httpd.conf')
  894.             self.copyFile(self.apache2_ssl_conf, '/etc/httpd/conf.d/https_gluu.conf')
  895.         if self.os_type in ['debian', 'ubuntu']:
  896.             self.copyFile(self.apache2_ssl_conf, '/etc/apache2/sites-available/https_gluu.conf')
  897.             self.run([self.cmd_ln, '-s', '/etc/apache2/sites-available/https_gluu.conf',
  898.                       '/etc/apache2/sites-enabled/https_gluu.conf'])
  899.  
  900.         self.run([service_path, apache_service_name, 'start'])
  901.  
  902.     def copy_output(self):
  903.         self.logIt("Copying rendered templates to final destination")
  904.  
  905.         for dest_fn in self.ce_templates.keys():
  906.             if self.ce_templates[dest_fn]:
  907.                 fn = os.path.split(dest_fn)[-1]
  908.                 output_fn = os.path.join(self.outputFolder, fn)
  909.                 try:
  910.                     self.logIt("Copying %s to %s" % (output_fn, dest_fn))
  911.                     dest_dir = os.path.dirname(dest_fn)
  912.                     if not os.path.exists(dest_dir):
  913.                         self.logIt("Created destination folder %s" % dest_dir)
  914.                         os.makedirs(dest_dir)
  915.                     shutil.copyfile(output_fn, dest_fn)
  916.                 except:
  917.                     self.logIt("Error writing %s to %s" % (output_fn, dest_fn), True)
  918.                     self.logIt(traceback.format_exc(), True)
  919.  
  920.     def copy_scripts(self):
  921.         self.logIt("Copying script files")
  922.         for script in self.gluuScriptFiles:
  923.             self.copyFile(script, self.gluuOptBinFolder)
  924.         self.logIt("Rendering encode.py")
  925.         try:
  926.             f = open('%s/encode.py' % self.templateFolder)
  927.             encode_script = f.read()
  928.             f.close()
  929.             f = open("%s/encode.py" % self.gluuOptBinFolder, 'w')
  930.             f.write(encode_script % self.merge_dicts(self.__dict__, self.templateRenderingDict))
  931.             f.close()
  932.         except:
  933.             self.logIt("Error rendering encode script")
  934.             self.logIt(traceback.format_exc(), True)
  935.         self.run([self.cmd_chmod, '-R', '700', self.gluuOptBinFolder])
  936.  
  937.     def copy_static(self):
  938.         if self.installOxAuth:
  939.             self.copyFile("%s/static/auth/lib/duo_web.py" % self.install_dir, "%s/libs" % self.gluuOptPythonFolder)
  940.             self.copyFile("%s/static/auth/conf/duo_creds.json" % self.install_dir, "%s/" % self.certFolder)
  941.             self.copyFile("%s/static/auth/conf/gplus_client_secrets.json" % self.install_dir, "%s/" % self.certFolder)
  942.             self.copyFile("%s/static/auth/conf/super_gluu_creds.json" % self.install_dir, "%s/" % self.certFolder)
  943.             self.copyFile("%s/static/auth/conf/cert_creds.json" % self.install_dir, "%s/" % self.certFolder)
  944.             self.copyFile("%s/static/auth/conf/otp_configuration.json" % self.install_dir, "%s/" % self.certFolder)
  945.  
  946.     def detect_os_type(self):
  947.         # TODO: Change this to support more distros. For example according to
  948.         # http://unix.stackexchange.com/questions/6345/how-can-i-get-distribution-name-and-version-number-in-a-simple-shell-script
  949.         distro_info = self.readFile('/etc/redhat-release')
  950.         if distro_info == None:
  951.             distro_info = self.readFile('/etc/os-release')
  952.  
  953.         if 'CentOS' in distro_info:
  954.             return self.os_types[0]
  955.         elif 'Red Hat' in distro_info:
  956.             return self.os_types[1]
  957.         elif 'Ubuntu' in distro_info:
  958.             return self.os_types[3]
  959.         elif 'Debian' in distro_info:
  960.             return self.os_types[4]
  961.  
  962.         else:
  963.             return self.choose_from_list(self.os_types, "Operating System")
  964.  
  965.     def detect_initd(self):
  966.         return open(os.path.join('/proc/1/status'), 'r').read().split()[1]
  967.  
  968.     def determineApacheVersion(self, apache_cmd):
  969.         cmd = "/usr/sbin/%s -v | egrep '^Server version'" % apache_cmd
  970.         PIPE = subprocess.PIPE
  971.         p = subprocess.Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=subprocess.STDOUT, close_fds=True, cwd=None)
  972.         apache_version = p.stdout.read().strip().split(' ')[2].split('/')[1]
  973.         if re.match(r'2\.4\..*', apache_version):
  974.             return "2.4"
  975.  
  976.         return "2.2"
  977.  
  978.     def determineApacheVersionForOS(self):
  979.         if self.os_type in ['centos', 'redhat', 'fedora']:
  980.             # httpd -v
  981.             # Server version: Apache/2.2.15 (Unix)  /etc/redhat-release  CentOS release 6.7 (Final)
  982.             # OR
  983.             # Server version: Apache/2.4.6 (CentOS) /etc/redhat-release  CentOS Linux release 7.1.1503 (Core)
  984.             return self.determineApacheVersion("httpd")
  985.         else:
  986.             return self.determineApacheVersion("apache2")
  987.  
  988.     def determineOpenDJVersion(self):
  989.         f = open('/opt/opendj/template/config/buildinfo', 'r')
  990.         encode_script = f.read().split()[0]
  991.         f.close()
  992.  
  993.         if re.match(r'2\.6\.0\..*', encode_script):
  994.             return "2.6"
  995.  
  996.         return "3.0"
  997.  
  998.     def installJRE(self):
  999.         self.logIt("Installing server JRE 1.8 %s..." % self.jre_version)
  1000.  
  1001.         jreArchive = 'server-jre-8u%s-linux-x64.tar.gz' % self.jre_version
  1002.        
  1003.     try:
  1004.             self.logIt("Extracting %s into /opt/" % jreArchive)
  1005.             self.run(['tar', '-xzf', '%s/%s' % (self.distAppFolder, jreArchive), '-C', '/opt/', '--no-xattrs', '--no-same-owner', '--no-same-permissions'])
  1006.         except:
  1007.             self.logIt("Error encountered while extracting archive %s" % jreArchive)
  1008.             self.logIt(traceback.format_exc(), True)
  1009.  
  1010.         jceArchive = 'jce_policy-8.zip'
  1011.         jceArchivePath = '%s/%s' % (self.distAppFolder, jceArchive)
  1012.         if self.installJce or os.path.exists(jceArchivePath):
  1013.             try:
  1014.                 self.logIt("Unzipping %s in /tmp" % jceArchive)
  1015.                 self.run(['unzip', '-n', '-q', jceArchivePath, '-d', '/tmp' ])
  1016.                 self.copyTree('/tmp/UnlimitedJCEPolicyJDK8', '%s/jre/lib/security' % self.jreDestinationPath, True)
  1017.                 self.removeDirs('/tmp/UnlimitedJCEPolicyJDK8')
  1018.             except:
  1019.                 self.logIt("Error encountered while doing unzip %s -d /tmp" % jceArchivePath)
  1020.                 self.logIt(traceback.format_exc(), True)
  1021.  
  1022.         self.run([self.cmd_ln, '-sf', self.jreDestinationPath, self.jre_home])
  1023.         self.run([self.cmd_chmod, '-R', "755", "%s/bin/" % self.jreDestinationPath])
  1024.         self.run([self.cmd_chown, '-R', 'root:root', self.jreDestinationPath])
  1025.         self.run([self.cmd_chown, '-h', 'root:root', self.jre_home])
  1026.  
  1027.     def extractOpenDJ(self):
  1028.         openDJArchive = 'opendj-server-3.0.0.zip'
  1029.         try:
  1030.             self.logIt("Unzipping %s in /opt/" % openDJArchive)
  1031.             self.run(['unzip', '-n', '-q', '%s/%s' % (self.distAppFolder, openDJArchive), '-d', '/opt/' ])
  1032.         except:
  1033.             self.logIt("Error encountered while doing unzip %s/%s -d /opt/" % (self.distAppFolder, openDJArchive))
  1034.             self.logIt(traceback.format_exc(), True)
  1035.  
  1036.         realLdapBaseFolder = os.path.realpath(self.ldapBaseFolder)
  1037.         self.run([self.cmd_chown, '-R', 'ldap:ldap', realLdapBaseFolder])
  1038.  
  1039.     def installJetty(self):
  1040.         self.logIt("Installing jetty %s..." % self.jetty_version)
  1041.  
  1042.         jettyTemp = '%s/temp' % self.jetty_dist
  1043.         self.run([self.cmd_mkdir, '-p', jettyTemp])
  1044.         self.run([self.cmd_chown, '-R', 'jetty:jetty', jettyTemp])
  1045.  
  1046.         jettyArchive = 'jetty-distribution-%s.tar.gz' % self.jetty_version
  1047.         jettyDestinationPath = '%s/jetty-distribution-%s' % (self.jetty_dist, self.jetty_version)
  1048.         try:
  1049.             self.logIt("Extracting %s into /opt/jetty" % jettyArchive)
  1050.             self.run(['tar', '-xzf', '%s/%s' % (self.distAppFolder, jettyArchive), '-C', self.jetty_dist, '--no-xattrs', '--no-same-owner', '--no-same-permissions'])
  1051.         except:
  1052.             self.logIt("Error encountered while extracting archive %s" % jettyArchive)
  1053.             self.logIt(traceback.format_exc(), True)
  1054.  
  1055.         self.run([self.cmd_ln, '-sf', jettyDestinationPath, self.jetty_home])
  1056.         self.run([self.cmd_chmod, '-R', "755", "%s/bin/" % jettyDestinationPath])
  1057.  
  1058.         self.applyChangesInFiles(self.app_custom_changes['jetty'])
  1059.  
  1060.         self.run([self.cmd_chown, '-R', 'jetty:jetty', jettyDestinationPath])
  1061.         self.run([self.cmd_chown, '-h', 'jetty:jetty', self.jetty_home])
  1062.  
  1063.         self.run([self.cmd_mkdir, '-p', self.jetty_base])
  1064.         self.run([self.cmd_chown, '-R', 'jetty:jetty', self.jetty_base])
  1065.  
  1066.     def installNode(self):
  1067.         self.logIt("Installing node %s..." % self.node_version)
  1068.  
  1069.         nodeArchive = 'node-v%s-linux-x64.tar.xz' % self.node_version
  1070.         nodeDestinationPath = '/opt/node-v%s-linux-x64' % self.node_version
  1071.         try:
  1072.             self.logIt("Extracting %s into /opt" % nodeArchive)
  1073.             self.run(['tar', '-xJf', '%s/%s' % (self.distAppFolder, nodeArchive), '-C', '/opt/', '--no-xattrs', '--no-same-owner', '--no-same-permissions'])
  1074.         except:
  1075.             self.logIt("Error encountered while extracting archive %s" % nodeArchive)
  1076.             self.logIt(traceback.format_exc(), True)
  1077.  
  1078.         self.run([self.cmd_ln, '-sf', nodeDestinationPath, self.node_home])
  1079.         self.run([self.cmd_chmod, '-R', "755", "%s/bin/" % nodeDestinationPath])
  1080.  
  1081.         # Create temp folder
  1082.         self.run([self.cmd_mkdir, '-p', "%s/temp" % self.node_home])
  1083.  
  1084.         # Copy init.d script
  1085.         self.copyFile(self.node_initd_script, self.gluuOptSystemFolder)
  1086.         self.run([self.cmd_chmod, '-R', "755", "%s/node" % self.gluuOptSystemFolder])
  1087.  
  1088.         self.run([self.cmd_chown, '-R', 'node:node', nodeDestinationPath])
  1089.         self.run([self.cmd_chown, '-h', 'node:node', self.node_home])
  1090.  
  1091.         self.run([self.cmd_mkdir, '-p', self.node_base])
  1092.         self.run([self.cmd_chown, '-R', 'node:node', self.node_base])
  1093.  
  1094.     def installJettyService(self, serviceConfiguration, supportCustomizations=False):
  1095.         serviceName = serviceConfiguration['name']
  1096.         self.logIt("Installing jetty service %s..." % serviceName)
  1097.         jettyServiceBase = '%s/%s' % (self.jetty_base, serviceName)
  1098.         jettyModules = serviceConfiguration['jetty']['modules']
  1099.         jettyModulesList = jettyModules.split(',')
  1100.  
  1101.         self.logIt("Preparing %s service base folders" % serviceName)
  1102.         self.run([self.cmd_mkdir, '-p', jettyServiceBase])
  1103.  
  1104.         # Create ./ext/lib folder for custom libraries only if installed Jetty "ext" module
  1105.         if "ext" in jettyModulesList:
  1106.             self.run([self.cmd_mkdir, '-p', "%s/lib/ext" % jettyServiceBase])
  1107.  
  1108.         # Create ./custom/pages and ./custom/static folders for custom pages and static resources, only if application supports them
  1109.         if supportCustomizations:
  1110.             if not os.path.exists("%s/custom" % jettyServiceBase):
  1111.                 self.run([self.cmd_mkdir, '-p', "%s/custom" % jettyServiceBase])
  1112.             self.run([self.cmd_mkdir, '-p', "%s/custom/pages" % jettyServiceBase])
  1113.             self.run([self.cmd_mkdir, '-p', "%s/custom/static" % jettyServiceBase])
  1114.             self.run([self.cmd_mkdir, '-p', "%s/custom/libs" % jettyServiceBase])
  1115.  
  1116.         self.logIt("Preparing %s service base configuration" % serviceName)
  1117.         jettyEnv = os.environ.copy()
  1118.         jettyEnv['PATH'] = '%s/bin:' % self.jre_home + jettyEnv['PATH']
  1119.  
  1120.         self.run([self.cmd_java, '-jar', '%s/start.jar' % self.jetty_home, 'jetty.home=%s' % self.jetty_home, 'jetty.base=%s' % jettyServiceBase, '--add-to-start=%s' % jettyModules], None, jettyEnv)
  1121.         self.run([self.cmd_chown, '-R', 'jetty:jetty', jettyServiceBase])
  1122.  
  1123.         jettyServiceConfiguration = '%s/jetty/%s' % (self.outputFolder, serviceName)
  1124.         self.copyFile(jettyServiceConfiguration, "/etc/default")
  1125.         self.run([self.cmd_chown, 'root:root', "/etc/default/%s" % serviceName])
  1126.  
  1127.         if os.path.exists(jettyServiceConfiguration+"_web_resources.xml"):
  1128.             self.copyFile(jettyServiceConfiguration+"_web_resources.xml", self.jetty_base+"/"+serviceName+"/webapps")
  1129.  
  1130.         self.copyFile('%s/bin/jetty.sh' % self.jetty_home, '/etc/init.d/%s' % serviceName)
  1131.         source_string = '# Provides:          jetty'
  1132.         target_string = '# Provides:          %s' % serviceName
  1133.         self.run(['sed', '-i', 's/^%s/%s/' % (source_string, target_string), '/etc/init.d/%s' % serviceName])
  1134.  
  1135.         # Enable service autoload on Gluu-Server startup
  1136.         if self.os_type in ['centos', 'fedora', 'redhat']:
  1137.             if self.os_initdaemon == 'systemd':
  1138.                 self.run(["/usr/bin/systemctl", 'enable', serviceName])
  1139.             else:
  1140.                 self.run(["/sbin/chkconfig", serviceName, "on"])
  1141.         elif self.os_type in ['ubuntu', 'debian']:
  1142.             self.run(["/usr/sbin/update-rc.d", serviceName, 'defaults', '60', '20'])
  1143.  
  1144.         serviceConfiguration['installed'] = True
  1145.  
  1146.     def installNodeService(self, serviceName):
  1147.         self.logIt("Installing node service %s..." % serviceName)
  1148.  
  1149.         nodeServiceConfiguration = '%s/node/%s' % (self.outputFolder, serviceName)
  1150.         self.copyFile(nodeServiceConfiguration, '/etc/default')
  1151.         self.run([self.cmd_chown, 'root:root', '/etc/default/%s' % serviceName])
  1152.  
  1153.         self.run([self.cmd_ln, '-sf', '%s/node' % self.gluuOptSystemFolder, '/etc/init.d/%s' % serviceName])
  1154.  
  1155.         # Enable service autoload on Gluu-Server startup
  1156.         if self.os_type in ['centos', 'fedora', 'redhat']:
  1157.             if self.os_initdaemon == 'systemd':
  1158.                 self.run(["/usr/bin/systemctl", 'enable', serviceName])
  1159.             else:
  1160.                 self.run(["/sbin/chkconfig", serviceName, "on"])
  1161.         elif self.os_type in ['ubuntu', 'debian']:
  1162.             self.run(["/usr/sbin/update-rc.d", serviceName, 'defaults', '70', '30'])
  1163.  
  1164.     def installJython(self):
  1165.         self.logIt("Installing Jython %s..." % self.jython_version)
  1166.         jythonInstaller = 'jython-%s.jar' % self.jython_version
  1167.  
  1168.         try:
  1169.             self.run(['rm', '-fr', '/opt*-%s' % self.jython_version])
  1170.             self.run([self.cmd_java, '-jar', '%s/jython-installer-%s.jar' % (self.distAppFolder, self.jython_version), '-v', '-s', '-d', '/opt/jython-%s' % self.jython_version, '-t', 'standard', '-e', 'ensurepip'])
  1171.         except:
  1172.             self.logIt("Error installing jython-installer-%s.jar" % self.jython_version)
  1173.             self.logIt(traceback.format_exc(), True)
  1174.  
  1175.         self.run([self.cmd_ln, '-sf', '/opt/jython-%s' % self.jython_version, self.jython_home])
  1176.         self.run([self.cmd_chown, '-R', 'root:root', '/opt/jython-%s' % self.jython_version])
  1177.         self.run([self.cmd_chown, '-h', 'root:root', self.jython_home])
  1178.  
  1179.     def downloadWarFiles(self):
  1180.         if self.downloadWars:
  1181.             print "Downloading oxAuth war file..."
  1182.             self.run(['/usr/bin/wget', self.oxauth_war, '--no-verbose', '--retry-connrefused', '--tries=10', '-O', '%s/oxauth.war' % self.distGluuFolder])
  1183.             print "Downloading oxTrust war file..."
  1184.             self.run(['/usr/bin/wget', self.oxtrust_war, '--no-verbose', '--retry-connrefused', '--tries=10', '-O', '%s/identity.war' % self.distGluuFolder])
  1185.  
  1186.             print "Finished downloading latest war files"
  1187.  
  1188.         if self.installAsimba:
  1189.             # Asimba is not part of CE package. We need to download it if needed
  1190.             distAsimbaPath = '%s/%s' % (self.distGluuFolder, "asimba.war")
  1191.             if not os.path.exists(distAsimbaPath):
  1192.                 print "Downloading Asimba war file..."
  1193.                 self.run(['/usr/bin/wget', self.asimba_war, '--no-verbose', '--retry-connrefused', '--tries=10', '-O', '%s/asimba.war' % self.distGluuFolder])
  1194.  
  1195.         if self.installOxAuthRP:
  1196.             # oxAuth RP is not part of CE package. We need to download it if needed
  1197.             distOxAuthRpPath = '%s/%s' % (self.distGluuFolder, "oxauth-rp.war")
  1198.             if not os.path.exists(distOxAuthRpPath):
  1199.                 print "Downloading oxAuth RP war file..."
  1200.                 self.run(['/usr/bin/wget', self.oxauth_rp_war, '--no-verbose', '--retry-connrefused', '--tries=10', '-O', '%s/oxauth-rp.war' % self.distGluuFolder])
  1201.  
  1202.         if self.downloadWars and self.installSaml:
  1203.             print "Downloading Shibboleth IDP v3 war file..."
  1204.             self.run(['/usr/bin/wget', self.idp3_war, '--no-verbose', '-c', '--retry-connrefused', '--tries=10', '-O', '%s/idp.war' % self.distGluuFolder])
  1205.             print "Downloading Shibboleth IDP v3 keygenerator..."
  1206.             self.run(['/usr/bin/wget', self.idp3_cml_keygenerator, '--no-verbose', '-c', '--retry-connrefused', '--tries=10', '-O', self.distGluuFolder + '/idp3_cml_keygenerator.jar'])
  1207.             print "Downloading Shibboleth IDP v3 binary distributive file..."
  1208.             self.run(['/usr/bin/wget', self.idp3_dist_jar, '--no-verbose', '-c', '--retry-connrefused', '--tries=10', '-O', self.distGluuFolder + '/shibboleth-idp.jar'])
  1209.  
  1210.         jceArchive = 'jce_policy-8.zip'
  1211.         jceArchivePath = '%s/%s' % (self.distAppFolder, jceArchive)
  1212.         if self.installJce and not os.path.exists(jceArchivePath):
  1213.             print "Downloading JCE 1.8 zip file..."
  1214.             self.run(['/usr/bin/curl', self.java_1_8_jce_zip, '-s', '-j', '-k', '-L', '-H', 'Cookie:oraclelicense=accept-securebackup-cookie', '-o', jceArchivePath])
  1215.            
  1216.  
  1217.     def encode_passwords(self):
  1218.         self.logIt("Encoding passwords")
  1219.         try:
  1220.             self.encoded_ldap_pw = self.ldap_encode(self.ldapPass)
  1221.             self.encoded_shib_jks_pw = self.obscure(self.shibJksPass)
  1222.             self.encoded_ox_ldap_pw = self.obscure(self.ldapPass)
  1223.             self.encoded_openldapJksPass = self.obscure(self.openldapJksPass)
  1224.             self.oxauthClient_pw = self.getPW()
  1225.             self.oxauthClient_encoded_pw = self.obscure(self.oxauthClient_pw)
  1226.         except:
  1227.             self.logIt("Error encoding passwords", True)
  1228.             self.logIt(traceback.format_exc(), True)
  1229.  
  1230.     def encode_test_passwords(self):
  1231.         self.logIt("Encoding test passwords")
  1232.         try:
  1233.             self.templateRenderingDict['oxauthClient_2_pw'] = self.getPW()
  1234.             self.templateRenderingDict['oxauthClient_2_encoded_pw'] = self.obscure(self.templateRenderingDict['oxauthClient_2_pw'])
  1235.  
  1236.             self.templateRenderingDict['oxauthClient_3_pw'] = self.getPW()
  1237.             self.templateRenderingDict['oxauthClient_3_encoded_pw'] = self.obscure(self.templateRenderingDict['oxauthClient_3_pw'])
  1238.  
  1239.             self.templateRenderingDict['oxauthClient_4_pw'] = self.getPW()
  1240.             self.templateRenderingDict['oxauthClient_4_encoded_pw'] = self.obscure(self.templateRenderingDict['oxauthClient_4_pw'])
  1241.         except:
  1242.             self.logIt("Error encoding test passwords", True)
  1243.             self.logIt(traceback.format_exc(), True)
  1244.  
  1245.     def gen_cert(self, suffix, password, user='root', cn=None):
  1246.         self.logIt('Generating Certificate for %s' % suffix)
  1247.         key_with_password = '%s/%s.key.orig' % (self.certFolder, suffix)
  1248.         key = '%s/%s.key' % (self.certFolder, suffix)
  1249.         csr = '%s/%s.csr' % (self.certFolder, suffix)
  1250.         public_certificate = '%s/%s.crt' % (self.certFolder, suffix)
  1251.         self.run([self.opensslCommand,
  1252.                   'genrsa',
  1253.                   '-des3',
  1254.                   '-out',
  1255.                   key_with_password,
  1256.                   '-passout',
  1257.                   'pass:%s' % password,
  1258.                   '2048'
  1259.         ])
  1260.         self.run([self.opensslCommand,
  1261.                   'rsa',
  1262.                   '-in',
  1263.                   key_with_password,
  1264.                   '-passin',
  1265.                   'pass:%s' % password,
  1266.                   '-out',
  1267.                   key
  1268.         ])
  1269.  
  1270.         certCn = cn
  1271.         if certCn == None:
  1272.             certCn = self.hostname
  1273.              
  1274.         self.run([self.opensslCommand,
  1275.                   'req',
  1276.                   '-new',
  1277.                   '-key',
  1278.                   key,
  1279.                   '-out',
  1280.                   csr,
  1281.                   '-subj',
  1282.                   '/C=%s/ST=%s/L=%s/O=%s/CN=%s/emailAddress=%s' % (self.countryCode, self.state, self.city, self.orgName, certCn, self.admin_email)
  1283.         ])
  1284.         self.run([self.opensslCommand,
  1285.                   'x509',
  1286.                   '-req',
  1287.                   '-days',
  1288.                   '365',
  1289.                   '-in',
  1290.                   csr,
  1291.                   '-signkey',
  1292.                   key,
  1293.                   '-out',
  1294.                   public_certificate
  1295.         ])
  1296.         self.run([self.cmd_chown, '%s:%s' % (user, user), key_with_password])
  1297.         self.run([self.cmd_chmod, '700', key_with_password])
  1298.         self.run([self.cmd_chown, '%s:%s' % (user, user), key])
  1299.         self.run([self.cmd_chmod, '700', key])
  1300.  
  1301.         self.run([self.cmd_keytool, "-import", "-trustcacerts", "-alias", "%s_%s" % (self.hostname, suffix), \
  1302.                   "-file", public_certificate, "-keystore", self.defaultTrustStoreFN, \
  1303.                   "-storepass", "changeit", "-noprompt"])
  1304.  
  1305.     def generate_crypto(self):
  1306.         try:
  1307.             self.logIt('Generating certificates and keystores')
  1308.             self.gen_cert('httpd', self.httpdKeyPass, 'jetty')
  1309.             self.gen_cert('shibIDP', self.shibJksPass, 'jetty')
  1310.             self.gen_cert('idp-encryption', self.shibJksPass, 'jetty')
  1311.             self.gen_cert('idp-signing', self.shibJksPass, 'jetty')
  1312.             self.gen_cert('asimba', self.asimbaJksPass, 'jetty')
  1313.             self.gen_cert('openldap', self.openldapKeyPass, 'ldap', self.ldap_hostname)
  1314.             self.gen_cert('passport-sp', self.passportSpKeyPass, 'ldap', self.ldap_hostname)
  1315.             # Shibboleth IDP and Asimba will be added soon...
  1316.             self.gen_keystore('shibIDP',
  1317.                               self.shibJksFn,
  1318.                               self.shibJksPass,
  1319.                               '%s/shibIDP.key' % self.certFolder,
  1320.                               '%s/shibIDP.crt' % self.certFolder,
  1321.                               'jetty')
  1322.             self.gen_keystore('asimba',
  1323.                               self.asimbaJksFn,
  1324.                               self.asimbaJksPass,
  1325.                               '%s/asimba.key' % self.certFolder,
  1326.                               '%s/asimba.crt' % self.certFolder,
  1327.                               'jetty')
  1328.             self.gen_keystore('openldap',
  1329.                               self.openldapJksFn,
  1330.                               self.openldapJksPass,
  1331.                               '%s/openldap.key' % self.certFolder,
  1332.                               '%s/openldap.crt' % self.certFolder,
  1333.                               'jetty')
  1334.             self.gen_keystore('passport-sp',
  1335.                               self.passportSpJksFn,
  1336.                               self.passportSpJksPass,
  1337.                               '%s/passport-sp.key' % self.certFolder,
  1338.                               '%s/passport-sp.crt' % self.certFolder,
  1339.                               'jetty')
  1340.             self.run([self.cmd_chown, '-R', 'jetty:jetty', self.certFolder])
  1341.             self.run([self.cmd_chmod, '-R', '500', self.certFolder])
  1342.             # oxTrust UI can add key to asimba's keystore
  1343.             self.run([self.cmd_chmod, 'u+w', self.asimbaJksFn])
  1344.         except:
  1345.             self.logIt("Error generating cyrpto")
  1346.             self.logIt(traceback.format_exc(), True)
  1347.  
  1348.     def gen_keystore(self, suffix, keystoreFN, keystorePW, inKey, inCert, user='root'):
  1349.         self.logIt("Creating keystore %s" % suffix)
  1350.         # Convert key to pkcs12
  1351.         pkcs_fn = '%s/%s.pkcs12' % (self.certFolder, suffix)
  1352.         self.run([self.opensslCommand,
  1353.                   'pkcs12',
  1354.                   '-export',
  1355.                   '-inkey',
  1356.                   inKey,
  1357.                   '-in',
  1358.                   inCert,
  1359.                   '-out',
  1360.                   pkcs_fn,
  1361.                   '-name',
  1362.                   self.hostname,
  1363.                   '-passout',
  1364.                   'pass:%s' % keystorePW
  1365.         ])
  1366.         # Import p12 to keystore
  1367.         self.run([self.cmd_keytool,
  1368.                   '-importkeystore',
  1369.                   '-srckeystore',
  1370.                   '%s/%s.pkcs12' % (self.certFolder, suffix),
  1371.                   '-srcstorepass',
  1372.                   keystorePW,
  1373.                   '-srcstoretype',
  1374.                   'PKCS12',
  1375.                   '-destkeystore',
  1376.                   keystoreFN,
  1377.                   '-deststorepass',
  1378.                   keystorePW,
  1379.                   '-deststoretype',
  1380.                   'JKS',
  1381.                   '-keyalg',
  1382.                   'RSA',
  1383.                   '-noprompt'
  1384.         ])
  1385.         self.run([self.cmd_chown, '%s:%s' % (user, user), pkcs_fn])
  1386.         self.run([self.cmd_chmod, '700', pkcs_fn])
  1387.         self.run([self.cmd_chown, '%s:%s' % (user, user), keystoreFN])
  1388.         self.run([self.cmd_chmod, '700', keystoreFN])
  1389.  
  1390.     def gen_openid_jwks_jks_keys(self, jks_path, jks_pwd, jks_create = True, key_expiration = None, dn_name = None, key_algs = None):
  1391.         self.logIt("Generating oxAuth OpenID Connect keys")
  1392.  
  1393.         if dn_name == None:
  1394.             dn_name = self.default_openid_jks_dn_name
  1395.  
  1396.         if key_algs == None:
  1397.             key_algs = self.default_key_algs
  1398.  
  1399.         if key_expiration == None:
  1400.             key_expiration = self.default_key_expiration
  1401.  
  1402.  
  1403.         # We can remove this once KeyGenerator will do the same
  1404.         if jks_create == True:
  1405.             self.logIt("Creating empty JKS keystore")
  1406.             # Create JKS with dummy key
  1407.             cmd = " ".join([self.cmd_keytool,
  1408.                       '-genkey',
  1409.                       '-alias',
  1410.                       'dummy',
  1411.                       '-keystore',
  1412.                       jks_path,
  1413.                       '-storepass',
  1414.                       jks_pwd,
  1415.                       '-keypass',
  1416.                       jks_pwd,
  1417.                       '-dname',
  1418.                       '"%s"' % dn_name])
  1419.             self.run(['/bin/sh', '-c', cmd])
  1420.  
  1421.             # Delete dummy key from JKS
  1422.             cmd = " ".join([self.cmd_keytool,
  1423.                       '-delete',
  1424.                       '-alias',
  1425.                       'dummy',
  1426.                       '-keystore',
  1427.                       jks_path,
  1428.                       '-storepass',
  1429.                       jks_pwd,
  1430.                       '-keypass',
  1431.                       jks_pwd,
  1432.                       '-dname',
  1433.                       '"%s"' % dn_name])
  1434.             self.run(['/bin/sh', '-c', cmd])
  1435.  
  1436.         oxauth_lib_files = self.findFiles(self.oxauth_keys_utils_libs, self.jetty_user_home_lib)
  1437.  
  1438.         cmd = " ".join([self.cmd_java,
  1439.                         "-Dlog4j.defaultInitOverride=true",
  1440.                         "-cp",
  1441.                         ":".join(oxauth_lib_files),
  1442.                         "org.xdi.oxauth.util.KeyGenerator",
  1443.                         "-keystore",
  1444.                         jks_path,
  1445.                         "-keypasswd",
  1446.                         jks_pwd,
  1447.                         "-algorithms",
  1448.                         "%s" % key_algs,
  1449.                         "-dnname",
  1450.                         '"%s"' % dn_name,
  1451.                         "-expiration",
  1452.                         "%s" % key_expiration])
  1453.         args = ['/bin/sh', '-c', cmd]
  1454.  
  1455.         self.logIt("Runnning: %s" % " ".join(args))
  1456.         try:
  1457.             p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  1458.             output, err = p.communicate()
  1459.             p.wait()
  1460.             if err:
  1461.                 self.logIt(err, True)
  1462.             if output:
  1463.                 return output.split(os.linesep)
  1464.         except:
  1465.             self.logIt("Error running command : %s" % " ".join(args), True)
  1466.             self.logIt(traceback.format_exc(), True)
  1467.  
  1468.         return None
  1469.  
  1470.     def export_openid_key(self, jks_path, jks_pwd, cert_alias, cert_path):
  1471.         self.logIt("Exporting oxAuth OpenID Connect keys")
  1472.  
  1473.         oxauth_lib_files = self.findFiles(self.oxauth_keys_utils_libs, self.jetty_user_home_lib)
  1474.  
  1475.         cmd = " ".join([self.cmd_java,
  1476.                         "-Dlog4j.defaultInitOverride=true",
  1477.                         "-cp",
  1478.                         ":".join(oxauth_lib_files),
  1479.                         "org.xdi.oxauth.util.KeyExporter",
  1480.                         "-keystore",
  1481.                         jks_path,
  1482.                         "-keypasswd",
  1483.                         jks_pwd,
  1484.                         "-alias",
  1485.                         cert_alias,
  1486.                         "-exportfile",
  1487.                         cert_path])
  1488.         self.run(['/bin/sh', '-c', cmd])
  1489.  
  1490.     def write_openid_keys(self, fn, jwks):
  1491.         self.logIt("Writing oxAuth OpenID Connect keys")
  1492.         if not jwks:
  1493.             self.logIt("Failed to write oxAuth OpenID Connect key to %s" % fn)
  1494.             return
  1495.  
  1496.         try:
  1497.             jwks_text = '\n'.join(jwks)
  1498.             f = open(fn, 'w')
  1499.             f.write(jwks_text)
  1500.             f.close()
  1501.             self.run([self.cmd_chown, 'jetty:jetty', fn])
  1502.             self.run([self.cmd_chmod, '600', fn])
  1503.             self.logIt("Wrote oxAuth OpenID Connect key to %s" % fn)
  1504.         except:
  1505.             self.logIt("Error writing command : %s" % fn, True)
  1506.             self.logIt(traceback.format_exc(), True)
  1507.  
  1508.     def generate_oxauth_openid_keys(self):
  1509.         jwks = self.gen_openid_jwks_jks_keys(self.oxauth_openid_jks_fn, self.oxauth_openid_jks_pass)
  1510.         self.write_openid_keys(self.oxauth_openid_jwks_fn, jwks)
  1511.  
  1512.     def generate_base64_string(self, lines, num_spaces):
  1513.         if not lines:
  1514.             return None
  1515.  
  1516.         plain_text = ''.join(lines)
  1517.         plain_b64encoded_text = plain_text.encode('base64').strip()
  1518.  
  1519.         if num_spaces > 0:
  1520.             plain_b64encoded_text = self.reindent(plain_b64encoded_text, num_spaces)
  1521.  
  1522.         return plain_b64encoded_text
  1523.  
  1524.     def genRandomString(self, N):
  1525.         return ''.join(random.SystemRandom().choice(string.ascii_lowercase
  1526.                                      + string.ascii_uppercase
  1527.                                      + string.digits) for _ in range(N))
  1528.  
  1529.     def generate_scim_configuration(self):
  1530.         self.scim_rs_client_jks_pass = self.getPW()
  1531.  
  1532.         self.scim_rs_client_jks_pass_encoded = self.obscure(self.scim_rs_client_jks_pass)
  1533.  
  1534.         self.scim_rs_client_jwks = self.gen_openid_jwks_jks_keys(self.scim_rs_client_jks_fn, self.scim_rs_client_jks_pass)
  1535.         self.templateRenderingDict['scim_rs_client_base64_jwks'] = self.generate_base64_string(self.scim_rs_client_jwks, 1)
  1536.  
  1537.         self.scim_rp_client_jwks = self.gen_openid_jwks_jks_keys(self.scim_rp_client_jks_fn, self.scim_rp_client_jks_pass)
  1538.         self.templateRenderingDict['scim_rp_client_base64_jwks'] = self.generate_base64_string(self.scim_rp_client_jwks, 1)
  1539.  
  1540.     def generate_passport_configuration(self):
  1541.         self.passport_rs_client_jks_pass = self.getPW()
  1542.  
  1543.         self.passport_rs_client_jks_pass_encoded = self.obscure(self.passport_rs_client_jks_pass)
  1544.  
  1545.         self.passport_rs_client_jwks = self.gen_openid_jwks_jks_keys(self.passport_rs_client_jks_fn, self.passport_rs_client_jks_pass)
  1546.         self.templateRenderingDict['passport_rs_client_base64_jwks'] = self.generate_base64_string(self.passport_rs_client_jwks, 1)
  1547.  
  1548.         self.passport_rp_client_jwks = self.gen_openid_jwks_jks_keys(self.passport_rp_client_jks_fn, self.passport_rp_client_jks_pass)
  1549.         self.templateRenderingDict['passport_rp_client_base64_jwks'] = self.generate_base64_string(self.passport_rp_client_jwks, 1)
  1550.  
  1551.     def getPrompt(self, prompt, defaultValue=None):
  1552.         try:
  1553.             if defaultValue:
  1554.                 user_input = raw_input("%s [%s] : " % (prompt, defaultValue)).strip()
  1555.                 if user_input == '':
  1556.                     return defaultValue
  1557.                 else:
  1558.                     return user_input
  1559.             else:
  1560.                 input = False
  1561.                 while not input:
  1562.                     user_input = raw_input("%s : " % prompt).strip()
  1563.                     if user_input != '':
  1564.                         input = True
  1565.                         return user_input
  1566.         except KeyboardInterrupt:
  1567.             sys.exit()
  1568.         except:
  1569.             return None
  1570.  
  1571.     def getPW(self, size=12, chars=string.ascii_uppercase + string.digits + string.lowercase):
  1572.         return ''.join(random.choice(chars) for _ in range(size))
  1573.  
  1574.     def getQuad(self):
  1575.         return str(uuid.uuid4())[:4].upper()
  1576.  
  1577.     def prepare_openid_keys_generator(self):
  1578.         self.logIt("Preparing files needed to run OpenId keys generator")
  1579.         # Unpack oxauth.war to get libs needed to run key generator
  1580.         oxauthWar = 'oxauth.war'
  1581.         distOxAuthPath = '%s/%s' % (self.distGluuFolder, oxauthWar)
  1582.  
  1583.         tmpOxAuthDir = '%s/tmp_oxauth' % self.distGluuFolder
  1584.  
  1585.         self.logIt("Unpacking %s..." % oxauthWar)
  1586.         self.removeDirs(tmpOxAuthDir)
  1587.         self.createDirs(tmpOxAuthDir)
  1588.  
  1589.         self.run([self.cmd_jar,
  1590.                   'xf',
  1591.                   distOxAuthPath], tmpOxAuthDir)
  1592.  
  1593.         tmpLibsOxAuthPath = '%s/WEB-INF/lib' % tmpOxAuthDir
  1594.  
  1595.         self.logIt("Copying files to %s..." % self.jetty_user_home_lib)
  1596.         oxauth_lib_files = self.findFiles(self.oxauth_keys_utils_libs, tmpLibsOxAuthPath)
  1597.         for oxauth_lib_file in oxauth_lib_files:
  1598.             self.copyFile(oxauth_lib_file, self.jetty_user_home_lib)
  1599.  
  1600.         self.removeDirs(tmpOxAuthDir)
  1601.  
  1602.     def install_gluu_base(self):
  1603.         self.logIt("Installing Gluu base...")
  1604.         self.prepare_openid_keys_generator()
  1605.  
  1606.         self.generate_scim_configuration()
  1607.         self.generate_passport_configuration()
  1608.  
  1609.         self.ldap_binddn = self.openldapRootUser
  1610.         self.ldap_site_binddn = self.openldapSiteUser
  1611.  
  1612.         if self.installSaml:
  1613.             self.oxTrustConfigGeneration = "true"
  1614.         else:
  1615.             self.oxTrustConfigGeneration = "false"
  1616.  
  1617.     def load_certificate_text(self, filePath):
  1618.         self.logIt("Load certificate %s" % filePath)
  1619.         f = open(filePath)
  1620.         certificate_text = f.read()
  1621.         f.close()
  1622.         certificate_text = certificate_text.replace('-----BEGIN CERTIFICATE-----', '').replace('-----END CERTIFICATE-----', '').strip()
  1623.         return certificate_text
  1624.  
  1625.     def install_oxauth(self):
  1626.         self.logIt("Copying identity.war into jetty webapps folder...")
  1627.  
  1628.         jettyServiceName = 'oxauth'
  1629.         self.installJettyService(self.jetty_app_configuration[jettyServiceName], True)
  1630.  
  1631.         jettyServiceWebapps = '%s/%s/webapps' % (self.jetty_base, jettyServiceName)
  1632.         self.copyFile('%s/oxauth.war' % self.distGluuFolder, jettyServiceWebapps)
  1633.  
  1634.     def install_oxtrust(self):
  1635.         self.logIt("Copying oxauth.war into jetty webapps folder...")
  1636.  
  1637.         jettyServiceName = 'identity'
  1638.         self.installJettyService(self.jetty_app_configuration[jettyServiceName], True)
  1639.  
  1640.         jettyServiceWebapps = '%s/%s/webapps' % (self.jetty_base, jettyServiceName)
  1641.         self.copyFile('%s/identity.war' % self.distGluuFolder, jettyServiceWebapps)
  1642.  
  1643.     def install_saml(self):
  1644.         if self.installSaml:
  1645.             self.logIt("Install SAML Shibboleth IDP v3...")
  1646.  
  1647.             # Put latest SAML templates
  1648.             identityWar = 'identity.war'
  1649.             distIdentityPath = '%s/%s' % (self.distGluuFolder, identityWar)
  1650.  
  1651.             tmpIdentityDir = '%s/tmp_identity' % self.distGluuFolder
  1652.  
  1653.             self.logIt("Unpacking %s from %s..." % ('oxtrust-configuration.jar', identityWar))
  1654.             self.removeDirs(tmpIdentityDir)
  1655.             self.createDirs(tmpIdentityDir)
  1656.  
  1657.             identityConfFilePattern = 'WEB-INF/lib/oxtrust-configuration-%s.jar' % self.oxVersion
  1658.  
  1659.             self.run([self.cmd_jar,
  1660.                       'xf',
  1661.                       distIdentityPath], tmpIdentityDir)
  1662.  
  1663.             self.logIt("Unpacking %s..." % 'oxtrust-configuration.jar')
  1664.             self.run([self.cmd_jar,
  1665.                       'xf',
  1666.                       identityConfFilePattern], tmpIdentityDir)
  1667.  
  1668.             self.logIt("Preparing SAML templates...")
  1669.             self.removeDirs('%s/conf/shibboleth3' % self.gluuBaseFolder)
  1670.             self.createDirs('%s/conf/shibboleth3/idp' % self.gluuBaseFolder)
  1671.  
  1672.             # Put IDP templates to oxTrust conf folder
  1673.             jettyIdentityServiceName = 'identity'
  1674.             jettyIdentityServiceConf = '%s/%s/conf' % (self.jetty_base, jettyIdentityServiceName)
  1675.             self.run([self.cmd_mkdir, '-p', jettyIdentityServiceConf])
  1676.  
  1677.             self.copyTree('%s/shibboleth3' % tmpIdentityDir, '%s/shibboleth3' % jettyIdentityServiceConf)
  1678.  
  1679.             self.removeDirs(tmpIdentityDir)
  1680.  
  1681.             # unpack IDP3 JAR with static configs
  1682.             self.run([self.cmd_jar, 'xf', self.distGluuFolder + '/shibboleth-idp.jar'], '/opt')
  1683.             self.removeDirs('/opt/META-INF')
  1684.  
  1685.             # Process templates
  1686.             self.renderTemplateInOut(self.idp3_configuration_properties, self.staticIDP3FolderConf, self.idp3ConfFolder)
  1687.             self.renderTemplateInOut(self.idp3_configuration_ldap_properties, self.staticIDP3FolderConf, self.idp3ConfFolder)
  1688.             self.renderTemplateInOut(self.idp3_configuration_saml_nameid, self.staticIDP3FolderConf, self.idp3ConfFolder)
  1689.             self.renderTemplateInOut(self.idp3_configuration_services, self.staticIDP3FolderConf, self.idp3ConfFolder)
  1690.             self.renderTemplateInOut(self.idp3_configuration_password_authn, self.staticIDP3FolderConf + '/authn', self.idp3ConfFolder + '/authn')
  1691.  
  1692.             # load certificates to update metadata
  1693.             self.templateRenderingDict['idp3EncryptionCertificateText'] = self.load_certificate_text(self.certFolder + '/idp-encryption.crt')
  1694.             self.templateRenderingDict['idp3SigningCertificateText'] = self.load_certificate_text(self.certFolder + '/idp-signing.crt')
  1695.             # update IDP3 metadata
  1696.             self.renderTemplateInOut(self.idp3_metadata, self.staticIDP3FolderMetadata, self.idp3MetadataFolder)
  1697.  
  1698.             self.idpWarFullPath = '%s/idp.war' % self.distGluuFolder
  1699.  
  1700.             # generate new keystore with AES symmetric key
  1701.             # there is one throuble with Shibboleth IDP 3.x - it doesn't load keystore from /etc/certs. It accepts %{idp.home}/credentials/sealer.jks  %{idp.home}/credentials/sealer.kver path format only.
  1702.             self.run([self.cmd_java,'-classpath', self.distGluuFolder + '/idp3_cml_keygenerator.jar', 'org.xdi.oxshibboleth.keygenerator.KeyGenerator', self.idp3CredentialsFolder, self.shibJksPass], self.idp3CredentialsFolder)
  1703.  
  1704.             jettyIdpServiceName = 'idp'
  1705.             jettyIdpServiceWebapps = '%s/%s/webapps' % (self.jetty_base, jettyIdpServiceName)
  1706.  
  1707.             self.installJettyService(self.jetty_app_configuration[jettyIdpServiceName])
  1708.             self.copyFile('%s/idp.war' % self.distGluuFolder, jettyIdpServiceWebapps)
  1709.            
  1710.             # Prepare libraries needed to for command line IDP3 utilities
  1711.             self.install_saml_libraries()
  1712.  
  1713.             # chown -R jetty:jetty /opt/shibboleth-idp
  1714.             # self.run([self.cmd_chown,'-R', 'jetty:jetty', self.idp3Folder], '/opt')
  1715.             self.run([self.cmd_chown, '-R', 'jetty:jetty', jettyIdpServiceWebapps], '/opt')
  1716.  
  1717.     def install_saml_libraries(self):
  1718.         # Unpack oxauth.war to get bcprov-jdk16.jar
  1719.         idpWar = 'idp.war'
  1720.         distIdpPath = '%s/idp.war' % self.distGluuFolder
  1721.  
  1722.         tmpIdpDir = '%s/tmp/tmp_idp' % self.distFolder
  1723.  
  1724.         self.logIt("Unpacking %s..." % idpWar)
  1725.         self.removeDirs(tmpIdpDir)
  1726.         self.createDirs(tmpIdpDir)
  1727.  
  1728.         self.run([self.cmd_jar,
  1729.                   'xf',
  1730.                   distIdpPath], tmpIdpDir)
  1731.  
  1732.         # Copy libraries into webapp
  1733.         idp3WebappLibFolder = "%s/WEB-INF/lib" % self.idp3WebappFolder
  1734.         self.createDirs(idp3WebappLibFolder)
  1735.         self.copyTree('%s/WEB-INF/lib' % tmpIdpDir, idp3WebappLibFolder)
  1736.  
  1737.         self.removeDirs(tmpIdpDir)
  1738.  
  1739.     def install_asimba(self):
  1740.         asimbaWar = 'asimba.war'
  1741.         distAsimbaPath = '%s/%s' % (self.distGluuFolder, asimbaWar)
  1742.        
  1743.         self.logIt("Configuring Asimba...")
  1744.         self.copyFile(self.asimba_configuration, self.asimba_configuration_xml)
  1745.         self.copyFile(self.asimba_selector_configuration, self.asimba_selector_configuration_xml)
  1746.         self.run([self.cmd_chmod, '-R', 'uga+x', self.asimba_conf_folder])
  1747.         self.run([self.cmd_chmod, '-R', 'ug+w', self.asimba_conf_folder])
  1748.         self.run([self.cmd_chmod, '-R', 'uga+r', self.asimba_configuration_xml, self.asimba_selector_configuration_xml])
  1749.         self.run([self.cmd_chown, '-R', 'jetty:jetty', self.asimba_conf_folder+'/metadata'])
  1750.        
  1751.         self.logIt("Copying asimba.war into jetty webapps folder...")
  1752.         jettyServiceName = 'asimba'
  1753.         self.installJettyService(self.jetty_app_configuration[jettyServiceName])
  1754.  
  1755.         jettyServiceWebapps = '%s/%s/webapps' % (self.jetty_base, jettyServiceName)
  1756.         self.copyFile(distAsimbaPath, jettyServiceWebapps)
  1757.  
  1758.     def install_oxauth_rp(self):
  1759.         oxAuthRPWar = 'oxauth-rp.war'
  1760.         distOxAuthRpPath = '%s/%s' % (self.distGluuFolder, oxAuthRPWar)
  1761.  
  1762.         self.logIt("Copying oxauth-rp.war into jetty webapps folder...")
  1763.  
  1764.         jettyServiceName = 'oxauth-rp'
  1765.         self.installJettyService(self.jetty_app_configuration[jettyServiceName])
  1766.  
  1767.         jettyServiceWebapps = '%s/%s/webapps' % (self.jetty_base, jettyServiceName)
  1768.         self.copyFile('%s/oxauth-rp.war' % self.distGluuFolder, jettyServiceWebapps)
  1769.  
  1770.     def install_passport(self):
  1771.         self.logIt("Installing Passport...")
  1772.  
  1773.         self.logIt("Preparing passport service base folders")
  1774.         self.run([self.cmd_mkdir, '-p', self.gluu_passport_base])
  1775.  
  1776.         # Extract package
  1777.         passportArchive = 'passport.tgz'
  1778.         try:
  1779.             self.logIt("Extracting %s into %s" % (passportArchive, self.gluu_passport_base))
  1780.             self.run(['tar', '--strip', '1', '-xzf', '%s/%s' % (self.distGluuFolder, passportArchive), '-C', self.gluu_passport_base, '--no-xattrs', '--no-same-owner', '--no-same-permissions'])
  1781.         except:
  1782.             self.logIt("Error encountered while extracting archive %s" % passportArchive)
  1783.             self.logIt(traceback.format_exc(), True)
  1784.  
  1785.         # Install dependencies
  1786.         try:
  1787.             self.logIt("Running npm install in %s" % self.gluu_passport_base)
  1788.  
  1789.             nodeEnv = os.environ.copy()
  1790.             nodeEnv['PATH'] = '%s/bin:' % self.node_home + nodeEnv['PATH']
  1791.  
  1792.             self.run(['npm', 'install', '-P'], self.gluu_passport_base, nodeEnv, True)
  1793.         except:
  1794.             self.logIt("Error encountered running npm install in %s" % self.gluu_passport_base)
  1795.             self.logIt(traceback.format_exc(), True)
  1796.  
  1797.         # Create logs folder
  1798.         self.run([self.cmd_mkdir, '-p', '%s/server/logs' % self.gluu_passport_base])
  1799.  
  1800.         self.run([self.cmd_chown, '-R', 'node:node', self.gluu_passport_base])
  1801.  
  1802.         self.logIt("Preparing Passport OpenID RP certificate...")
  1803.         passport_rp_client_jwks_json = json.loads(''.join(self.passport_rp_client_jwks))
  1804.         for jwks_key in passport_rp_client_jwks_json["keys"]:
  1805.             if jwks_key["alg"]  == self.passport_rp_client_cert_alg:
  1806.                 self.passport_rp_client_cert_alias = jwks_key["kid"]
  1807.                 break
  1808.  
  1809.         self.export_openid_key(self.passport_rp_client_jks_fn, self.passport_rp_client_jks_pass, self.passport_rp_client_cert_alias, self.passport_rp_client_cert_fn)
  1810.         self.renderTemplateInOut(self.passport_config, self.templateFolder, self.configFolder)
  1811.        
  1812.         # Install passport system service script
  1813.         self.installNodeService('passport')
  1814.  
  1815.     def install_gluu_components(self):
  1816.         if self.installLdap:
  1817.             self.install_ldap_server()
  1818.  
  1819.         if self.installHttpd:
  1820.             self.configure_httpd()
  1821.  
  1822.         if self.installOxAuth:
  1823.             self.install_oxauth()
  1824.  
  1825.         if self.installOxTrust:
  1826.             self.install_oxtrust()
  1827.  
  1828.         if self.installSaml:
  1829.             self.install_saml()
  1830.  
  1831.         if self.installAsimba:
  1832.             self.install_asimba()
  1833.  
  1834.         if self.installOxAuthRP:
  1835.             self.install_oxauth_rp()
  1836.  
  1837.         if self.installPassport:
  1838.             self.install_passport()
  1839.  
  1840.     def isIP(self, address):
  1841.         try:
  1842.             socket.inet_aton(address)
  1843.             return True
  1844.         except socket.error:
  1845.             return False
  1846.  
  1847.     def ldap_encode(self, password):
  1848.         salt = os.urandom(4)
  1849.         sha = hashlib.sha1(password)
  1850.         sha.update(salt)
  1851.         b64encoded = '{0}{1}'.format(sha.digest(), salt).encode('base64').strip()
  1852.         encrypted_password = '{{SSHA}}{0}'.format(b64encoded)
  1853.         return encrypted_password
  1854.  
  1855.     def createUser(self, userName, homeDir):
  1856.         try:
  1857.             useradd = '/usr/sbin/useradd'
  1858.             self.run([useradd, '--system', '--create-home', '--user-group', '--shell', '/bin/bash', '--home-dir', homeDir, userName])
  1859.         except:
  1860.             self.logIt("Error adding user", True)
  1861.             self.logIt(traceback.format_exc(), True)
  1862.  
  1863.     def createGroup(self, groupName):
  1864.         try:
  1865.             groupadd = '/usr/sbin/groupadd'
  1866.             self.run([groupadd, groupName])
  1867.         except:
  1868.             self.logIt("Error adding group", True)
  1869.             self.logIt(traceback.format_exc(), True)
  1870.  
  1871.     def addUserToGroup(self, groupName, userName):
  1872.         try:
  1873.             usermod = '/usr/sbin/usermod'
  1874.             self.run([usermod, '-a', '-G', groupName, userName])
  1875.         except:
  1876.             self.logIt("Error adding group", True)
  1877.             self.logIt(traceback.format_exc(), True)
  1878.  
  1879.     def createUsers(self):
  1880.         self.createUser('ldap', self.ldap_user_home)
  1881.         self.createUser('jetty', self.jetty_user_home)
  1882.         self.createUser('node', self.node_user_home)
  1883.  
  1884.         self.createGroup('gluu')
  1885.        
  1886.         self.addUserToGroup('gluu', 'ldap')
  1887.         self.addUserToGroup('gluu', 'jetty')
  1888.         self.addUserToGroup('gluu', 'node')
  1889.  
  1890.         self.addUserToGroup('adm', 'ldap')
  1891.  
  1892.     def makeFolders(self):
  1893.         try:
  1894.             # Allow write to /tmp
  1895.             self.run([self.cmd_chmod, 'ga+w', "/tmp"])
  1896.  
  1897.             # Create these folder on all instances
  1898.             self.run([self.cmd_mkdir, '-p', self.gluuOptFolder])
  1899.             self.run([self.cmd_mkdir, '-p', self.gluuOptBinFolder])
  1900.             self.run([self.cmd_mkdir, '-p', self.gluuOptSystemFolder])
  1901.             self.run([self.cmd_mkdir, '-p', self.gluuOptPythonFolder])
  1902.             self.run([self.cmd_mkdir, '-p', self.configFolder])
  1903.             self.run([self.cmd_mkdir, '-p', self.certFolder])
  1904.             self.run([self.cmd_mkdir, '-p', self.outputFolder])
  1905.             self.run([self.cmd_mkdir, '-p', self.jetty_user_home_lib])
  1906.  
  1907.             if not os.path.exists(self.osDefault):
  1908.                 self.run([self.cmd_mkdir, '-p', self.osDefault])
  1909.  
  1910.             if self.installOxTrust | self.installOxAuth:
  1911.                 self.run([self.cmd_mkdir, '-m', '775', '-p', self.oxPhotosFolder])
  1912.                 self.run([self.cmd_mkdir, '-m', '775', '-p', self.oxTrustRemovedFolder])
  1913.                 self.run([self.cmd_mkdir, '-m', '775', '-p', self.oxTrustCacheRefreshFolder])
  1914.  
  1915.                 self.run([self.cmd_chown, '-R', 'root:gluu', self.oxPhotosFolder])
  1916.                 self.run([self.cmd_chown, '-R', 'root:gluu', self.oxTrustRemovedFolder])
  1917.                 self.run([self.cmd_chown, '-R', 'root:gluu', self.oxTrustCacheRefreshFolder])
  1918.  
  1919.             if self.installSaml:
  1920.                 self.run([self.cmd_mkdir, '-p', self.idp3Folder])
  1921.                 self.run([self.cmd_mkdir, '-p', self.idp3MetadataFolder])
  1922.                 self.run([self.cmd_mkdir, '-p', self.idp3MetadataCredentialsFolder])
  1923.                 self.run([self.cmd_mkdir, '-p', self.idp3LogsFolder])
  1924.                 self.run([self.cmd_mkdir, '-p', self.idp3LibFolder])
  1925.                 self.run([self.cmd_mkdir, '-p', self.idp3ConfFolder])
  1926.                 self.run([self.cmd_mkdir, '-p', self.idp3ConfAuthnFolder])
  1927.                 self.run([self.cmd_mkdir, '-p', self.idp3CredentialsFolder])
  1928.                 self.run([self.cmd_mkdir, '-p', self.idp3WebappFolder])
  1929.                 # self.run([self.cmd_mkdir, '-p', self.idp3WarFolder])
  1930.                 self.run([self.cmd_chown, '-R', 'jetty:jetty', self.idp3Folder])
  1931.  
  1932.             if self.installLdap:
  1933.                 self.run([self.cmd_mkdir, '-p', '/opt/gluu/data/main_db'])
  1934.                 self.run([self.cmd_mkdir, '-p', '/opt/gluu/data/site_db'])
  1935.                
  1936.             if self.installAsimba:
  1937.                 self.run([self.cmd_mkdir, '-p', self.asimba_conf_folder])
  1938.                 self.run([self.cmd_mkdir, '-p', self.asimba_conf_folder+'/metadata'])
  1939.                 self.run([self.cmd_mkdir, '-p', self.asimba_conf_folder+'/metadata/idp'])
  1940.                 self.run([self.cmd_mkdir, '-p', self.asimba_conf_folder+'/metadata/sp'])
  1941.                 self.run([self.cmd_chown, '-R', 'jetty:jetty', self.asimba_conf_folder+'/metadata'])
  1942.                
  1943.         except:
  1944.             self.logIt("Error making folders", True)
  1945.             self.logIt(traceback.format_exc(), True)
  1946.  
  1947.     def customiseSystem(self):
  1948.         # Render customized part
  1949.         if self.os_initdaemon == 'init':
  1950.             self.renderTemplate(self.system_profile_update)
  1951.             renderedSystemProfile = self.readFile(self.system_profile_update)
  1952.    
  1953.             # Read source file
  1954.             currentSystemProfile = self.readFile(self.sysemProfile)
  1955.    
  1956.             # Write merged file
  1957.             resultSystemProfile = "\n".join((currentSystemProfile, renderedSystemProfile))
  1958.             self.writeFile(self.sysemProfile, resultSystemProfile)
  1959.    
  1960.             # Fix new file permissions
  1961.             self.run([self.cmd_chmod, '644', self.sysemProfile])
  1962.  
  1963.     def configureSystem(self):
  1964.         self.customiseSystem()
  1965.         self.createUsers()
  1966.         self.makeFolders()
  1967.  
  1968.     def make_salt(self):
  1969.         try:
  1970.             f = open("%s/salt" % self.configFolder, 'w')
  1971.             f.write('encodeSalt = %s' % self.encode_salt)
  1972.             f.close()
  1973.         except:
  1974.             self.logIt("Error writing salt", True)
  1975.             self.logIt(traceback.format_exc(), True)
  1976.             sys.exit()
  1977.  
  1978.  
  1979.     def make_oxauth_salt(self):
  1980.         self.pairwiseCalculationKey = self.genRandomString(random.randint(20,30))
  1981.         self.pairwiseCalculationSalt = self.genRandomString(random.randint(20,30))
  1982.  
  1983.     def promptForProperties(self):
  1984.         # IP address needed only for Apache2 and hosts file update
  1985.         if self.installHttpd:
  1986.             self.ip = self.get_ip()
  1987.  
  1988.         detectedHostname = None
  1989.         try:
  1990.             detectedHostname = socket.gethostbyaddr(socket.gethostname())[0]
  1991.         except:
  1992.             try:
  1993.                 detectedHostname = os.popen("/bin/hostname").read().strip()
  1994.             except:
  1995.                 self.logIt("No detected hostname", True)
  1996.                 self.logIt(traceback.format_exc(), True)
  1997.         if detectedHostname:
  1998.             self.hostname = self.getPrompt("Enter hostname", detectedHostname)
  1999.         else:
  2000.             self.hostname = self.getPrompt("Enter hostname")
  2001.  
  2002.         # Get city and state|province code
  2003.         self.city = self.getPrompt("Enter your city or locality")
  2004.         self.state = self.getPrompt("Enter your state or province two letter code")
  2005.  
  2006.         # Get the Country Code
  2007.         long_enough = False
  2008.         while not long_enough:
  2009.             countryCode = self.getPrompt("Enter two letter Country Code")
  2010.             if len(countryCode) != 2:
  2011.                 print "Country code must be two characters"
  2012.             else:
  2013.                 self.countryCode = countryCode
  2014.                 long_enough = True
  2015.  
  2016.         self.orgName = self.getPrompt("Enter Organization Name")
  2017.         self.admin_email = self.getPrompt('Enter email address for support at your organization')
  2018.         self.application_max_ram = self.getPrompt("Enter maximum RAM for applications in MB", '3072')
  2019.         randomPW = self.getPW()
  2020.         self.ldapPass = self.getPrompt("Optional: enter password for oxTrust and LDAP superuser", randomPW)
  2021.  
  2022.         promptForOxAuth = self.getPrompt("Install oxAuth OAuth2 Authorization Server?", "Yes")[0].lower()
  2023.         if promptForOxAuth == 'y':
  2024.             self.installOxAuth = True
  2025.         else:
  2026.             self.installOxAuth = False
  2027.  
  2028.         promptForOxTrust = self.getPrompt("Install oxTrust Admin UI?", "Yes")[0].lower()
  2029.         if promptForOxTrust == 'y':
  2030.             self.installOxTrust = True
  2031.         else:
  2032.             self.installOxTrust = False
  2033.  
  2034.         promptForLDAP = self.getPrompt("Install LDAP Server?", "Yes")[0].lower()
  2035.         if promptForLDAP == 'y':
  2036.             self.installLdap = True
  2037.         else:
  2038.             self.installLdap = False
  2039.  
  2040.         promptForHTTPD = self.getPrompt("Install Apache HTTPD Server", "Yes")[0].lower()
  2041.         if promptForHTTPD == 'y':
  2042.             self.installHttpd = True
  2043.         else:
  2044.             self.installHttpd = False
  2045.  
  2046.         promptForShibIDP = self.getPrompt("Install Shibboleth SAML IDP?", "No")[0].lower()
  2047.         if promptForShibIDP == 'y':
  2048.             self.shibboleth_version = 'v3'
  2049.             self.installSaml = True
  2050.         else:
  2051.             self.installSaml = False
  2052.  
  2053.         promptForAsimba = self.getPrompt("Install Asimba SAML Proxy?", "No")[0].lower()
  2054.         if promptForAsimba == 'y':
  2055.             self.installAsimba = True
  2056.         else:
  2057.             self.installAsimba = False
  2058.  
  2059.         promptForOxAuthRP = self.getPrompt("Install oxAuth RP?", "No")[0].lower()
  2060.         if promptForOxAuthRP == 'y':
  2061.             self.installOxAuthRP = True
  2062.         else:
  2063.             self.installOxAuthRP = False
  2064.  
  2065.         promptForPassport = self.getPrompt("Install Passport?", "No")[0].lower()
  2066.         if promptForPassport == 'y':
  2067.             self.installPassport = True
  2068.         else:
  2069.             self.installPassport = False
  2070.            
  2071.         #if self.allowDeprecatedApplications:
  2072.             # Empty deprecated option
  2073.  
  2074.         promptForJCE = self.getPrompt("Install JCE 1.8?", "Yes")[0].lower()
  2075.         if promptForJCE == 'y':
  2076.             promptForJCELicense = self.getPrompt("You must accept the Oracle Binary Code License Agreement for the Java SE Platform Products to download this software. Accept License Agreement?", "Yes")[0].lower()
  2077.             if promptForJCELicense == 'y':
  2078.                 self.installJce = True
  2079.             else:
  2080.                 self.installJce = False
  2081.         else:
  2082.             self.installJce = False
  2083.  
  2084.     def get_filepaths(self, directory):
  2085.         file_paths = []
  2086.  
  2087.         for root, directories, files in os.walk(directory):
  2088.             for filename in files:
  2089.                 # filepath = os.path.join(root, filename)
  2090.                 file_paths.append(filename)
  2091.  
  2092.         return file_paths
  2093.  
  2094.     def fomatWithDict(self, text, dictionary):
  2095.         text = re.sub(r"%([^\(])", r"%%\1", text)
  2096.         text = re.sub(r"%$", r"%%", text)  # There was a % at the end?
  2097.  
  2098.         return text % dictionary
  2099.  
  2100.     def renderTemplateInOut(self, filePath, templateFolder, outputFolder):
  2101.         self.logIt("Rendering template %s" % filePath)
  2102.         fn = os.path.split(filePath)[-1]
  2103.         f = open(os.path.join(templateFolder, fn))
  2104.         template_text = f.read()
  2105.         f.close()
  2106.         newFn = open(os.path.join(outputFolder, fn), 'w+')
  2107.         newFn.write(self.fomatWithDict(template_text, self.merge_dicts(self.__dict__, self.templateRenderingDict)))
  2108.         newFn.close()
  2109.  
  2110.     def renderTemplate(self, filePath):
  2111.         self.renderTemplateInOut(filePath, self.templateFolder, self.outputFolder)
  2112.  
  2113.     def render_templates(self):
  2114.         self.logIt("Rendering templates")
  2115.         for fullPath in self.ce_templates.keys():
  2116.             try:
  2117.                 self.renderTemplate(fullPath)
  2118.             except:
  2119.                 self.logIt("Error writing template %s" % fullPath, True)
  2120.                 self.logIt(traceback.format_exc(), True)
  2121.  
  2122.     def render_custom_templates(self, fullPath):
  2123.         output_dir = fullPath + '.output'
  2124.  
  2125.         self.logIt("Rendering custom templates")
  2126.         self.logIt("Rendering custom templates from %s to %s" % (fullPath, output_dir))
  2127.  
  2128.         try:
  2129.             self.run([self.cmd_mkdir, '-p', output_dir])
  2130.         except:
  2131.             self.logIt("Error creating output directory %s" % output_dir, True)
  2132.             self.logIt(traceback.format_exc(), True)
  2133.  
  2134.         try:
  2135.             for filename in self.get_filepaths(fullPath):
  2136.                 self.renderTemplateInOut(filename, fullPath, output_dir)
  2137.         except:
  2138.             self.logIt("Error writing template %s" % fullPath, True)
  2139.             self.logIt(traceback.format_exc(), True)
  2140.  
  2141.     def render_configuration_template(self):
  2142.         self.logIt("Rendering configuration templates")
  2143.  
  2144.         fullPath = self.ldif_configuration
  2145.         try:
  2146.             self.renderTemplate(fullPath)
  2147.         except:
  2148.             self.logIt("Error writing template %s" % fullPath, True)
  2149.             self.logIt(traceback.format_exc(), True)
  2150.  
  2151.     def render_templates_folder(self, templatesFolder):
  2152.         self.logIt("Rendering templates folder: %s" % templatesFolder)
  2153.  
  2154.         for templateBase, templateDirectories, templateFiles in os.walk(templatesFolder):
  2155.             for templateFile in templateFiles:
  2156.                 fullPath = '%s/%s' % (templateBase, templateFile)
  2157.                 try:
  2158.                     self.logIt("Rendering test template %s" % fullPath)
  2159.                     # Remove ./template/ and everything left of it from fullPath
  2160.                     fn = re.match(r'(^.+/templates/)(.*$)', fullPath).groups()[1]
  2161.                     f = open(os.path.join(self.templateFolder, fn))
  2162.                     template_text = f.read()
  2163.                     f.close()
  2164.  
  2165.                     fullOutputFile = os.path.join(self.outputFolder, fn)
  2166.                     # Create full path to the output file
  2167.                     fullOutputDir = os.path.dirname(fullOutputFile)
  2168.                     if not os.path.exists(fullOutputDir):
  2169.                         os.makedirs(fullOutputDir)
  2170.  
  2171.                     newFn = open(fullOutputFile, 'w+')
  2172.                     newFn.write(template_text % self.merge_dicts(self.__dict__, self.templateRenderingDict))
  2173.                     newFn.close()
  2174.                 except:
  2175.                     self.logIt("Error writing template %s" % fullPath, True)
  2176.                     self.logIt(traceback.format_exc(), True)
  2177.  
  2178.     def render_test_templates(self):
  2179.         self.logIt("Rendering test templates")
  2180.  
  2181.         testTepmplatesFolder = '%s/test/' % self.templateFolder
  2182.         self.render_templates_folder(testTepmplatesFolder)
  2183.  
  2184.     def render_jetty_templates(self):
  2185.         self.logIt("Rendering jetty templates")
  2186.  
  2187.         jettyTepmplatesFolder = '%s/jetty/' % self.templateFolder
  2188.         self.render_templates_folder(jettyTepmplatesFolder)
  2189.  
  2190.     def render_node_templates(self):
  2191.         self.logIt("Rendering node templates")
  2192.  
  2193.         nodeTepmplatesFolder = '%s/node/' % self.templateFolder
  2194.         self.render_templates_folder(nodeTepmplatesFolder)
  2195.  
  2196.     def prepare_base64_extension_scripts(self):
  2197.         try:
  2198.             if not os.path.exists(self.extensionFolder):
  2199.                 return None
  2200.  
  2201.             for extensionType in os.listdir(self.extensionFolder):
  2202.                 extensionTypeFolder = os.path.join(self.extensionFolder, extensionType)
  2203.                 if not os.path.isdir(extensionTypeFolder):
  2204.                     continue
  2205.  
  2206.                 for scriptFile in os.listdir(extensionTypeFolder):
  2207.                     scriptFilePath = os.path.join(extensionTypeFolder, scriptFile)
  2208.                     base64ScriptFile = self.generate_base64_file(scriptFilePath, 1)
  2209.                    
  2210.                     # Prepare key for dictionary
  2211.                     extensionScriptName = '%s_%s' % (extensionType, os.path.splitext(scriptFile)[0])
  2212.                     extensionScriptName = extensionScriptName.decode('utf-8').lower()
  2213.  
  2214.                     self.templateRenderingDict[extensionScriptName] = base64ScriptFile
  2215.                     self.logIt("Loaded script %s with type %s into %s" % (scriptFile, extensionType, extensionScriptName))
  2216.  
  2217.         except:
  2218.             self.logIt("Error loading scripts from %s" % self.extensionFolder, True)
  2219.             self.logIt(traceback.format_exc(), True)
  2220.  
  2221.     def reindent(self, text, num_spaces):
  2222.         text = string.split(text, '\n')
  2223.         text = [(num_spaces * ' ') + string.lstrip(line) for line in text]
  2224.         text = string.join(text, '\n')
  2225.  
  2226.         return text
  2227.  
  2228.     def generate_base64_file(self, fn, num_spaces):
  2229.         self.logIt('Loading file %s' % fn)
  2230.         plain_file_b64encoded_text = None
  2231.         try:
  2232.             plain_file = open(fn)
  2233.             plain_file_text = plain_file.read()
  2234.             plain_file_b64encoded_text = plain_file_text.encode('base64').strip()
  2235.             plain_file.close()
  2236.         except:
  2237.             self.logIt("Error loading file", True)
  2238.             self.logIt(traceback.format_exc(), True)
  2239.  
  2240.         if num_spaces > 0:
  2241.             plain_file_b64encoded_text = self.reindent(plain_file_b64encoded_text, num_spaces)
  2242.  
  2243.         return plain_file_b64encoded_text
  2244.  
  2245.     def generate_base64_ldap_file(self, fn):
  2246.         return self.generate_base64_file(fn, 1)
  2247.  
  2248.     def generate_base64_configuration(self):
  2249.         self.templateRenderingDict['oxauth_config_base64'] = self.generate_base64_ldap_file(self.oxauth_config_json)
  2250.         self.templateRenderingDict['oxauth_static_conf_base64'] = self.generate_base64_ldap_file(self.oxauth_static_conf_json)
  2251.         self.templateRenderingDict['oxauth_error_base64'] = self.generate_base64_ldap_file(self.oxauth_error_json)
  2252.         self.templateRenderingDict['oxauth_openid_key_base64'] = self.generate_base64_ldap_file(self.oxauth_openid_jwks_fn)
  2253.  
  2254.         self.templateRenderingDict['oxtrust_config_base64'] = self.generate_base64_ldap_file(self.oxtrust_config_json);
  2255.         self.templateRenderingDict['oxtrust_cache_refresh_base64'] = self.generate_base64_ldap_file(self.oxtrust_cache_refresh_json)
  2256.         self.templateRenderingDict['oxtrust_import_person_base64'] = self.generate_base64_ldap_file(self.oxtrust_import_person_json)
  2257.  
  2258.         self.templateRenderingDict['oxidp_config_base64'] = self.generate_base64_ldap_file(self.oxidp_config_json)
  2259.         self.templateRenderingDict['oxasimba_config_base64'] = self.generate_base64_ldap_file(self.oxasimba_config_json)
  2260.  
  2261.     # args = command + args, i.e. ['ls', '-ltr']
  2262.     def run(self, args, cwd=None, env=None, useWait=False):
  2263.         self.logIt('Running: %s' % ' '.join(args))
  2264.         try:
  2265.             p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd, env=env)
  2266.             if useWait:
  2267.                 code = p.wait()
  2268.                 self.logIt('Run: %s with result code: %d' % (' '.join(args), code) )
  2269.             else:
  2270.                 output, err = p.communicate()
  2271.                 if output:
  2272.                     self.logIt(output)
  2273.                 if err:
  2274.                     self.logIt(err, True)
  2275.         except:
  2276.             self.logIt("Error running command : %s" % " ".join(args), True)
  2277.             self.logIt(traceback.format_exc(), True)
  2278.  
  2279.     def save_properties(self):
  2280.         self.logIt('Saving properties to %s' % self.savedProperties)
  2281.  
  2282.         def getString(value):
  2283.             if isinstance(value, str):
  2284.                 return value.strip()
  2285.             elif isinstance(value, bool):
  2286.                 return str(value)
  2287.             else:
  2288.                 return ""
  2289.         try:
  2290.             p = Properties.Properties()
  2291.             keys = self.__dict__.keys()
  2292.             keys.sort()
  2293.             for key in keys:
  2294.                 value = getString(self.__dict__[key])
  2295.                 if value != '':
  2296.                     p[key] = value
  2297.             p.store(open(self.savedProperties, 'w'))
  2298.         except:
  2299.             self.logIt("Error saving properties", True)
  2300.             self.logIt(traceback.format_exc(), True)
  2301.  
  2302.     def createLdapPw(self):
  2303.         try:
  2304.             f = open(self.ldapPassFn, 'w')
  2305.             f.write(self.ldapPass)
  2306.             f.close()
  2307.             self.run([self.cmd_chown, 'ldap:ldap', self.ldapPassFn])
  2308.         except:
  2309.             self.logIt("Error writing temporary LDAP password.")
  2310.             self.logIt(traceback.format_exc(), True)
  2311.  
  2312.     def deleteLdapPw(self):
  2313.         try:
  2314.             os.remove(self.ldapPassFn)
  2315.             os.remove(os.path.join(self.ldapBaseFolder, 'opendj-setup.properties'))
  2316.         except:
  2317.             self.logIt("Error deleting ldap pw. Make sure %s is deleted" % self.ldapPassFn)
  2318.             self.logIt(traceback.format_exc(), True)
  2319.  
  2320.     def install_opendj(self):
  2321.         self.logIt("Running OpenDJ Setup")
  2322.         # Copy opendj-setup.properties so user ldap can find it in /opt/opendj
  2323.         setupPropsFN = os.path.join(self.ldapBaseFolder, 'opendj-setup.properties')
  2324.         shutil.copy("%s/opendj-setup.properties" % self.outputFolder, setupPropsFN)
  2325.         self.set_ownership()
  2326.         try:
  2327.             ldapSetupCommand = '%s/setup' % self.ldapBaseFolder
  2328.             setupCmd = "cd /opt/opendj ; export OPENDJ_JAVA_HOME=" + self.jre_home + " ; " + " ".join([ldapSetupCommand,
  2329.                                       '--no-prompt',
  2330.                                       '--cli',
  2331.                                       '--propertiesFilePath',
  2332.                                       setupPropsFN,
  2333.                                       '--acceptLicense'])
  2334.             self.run(['/bin/su',
  2335.                       'ldap',
  2336.                       '-c',
  2337.                       setupCmd])
  2338.         except:
  2339.             self.logIt("Error running LDAP setup script", True)
  2340.             self.logIt(traceback.format_exc(), True)
  2341.  
  2342.         try:
  2343.             ldapDsJavaPropCommand = "%s/bin/dsjavaproperties" % self.ldapBaseFolder
  2344.             dsjavaCmd = "cd /opt/opendj/bin ; %s" % ldapDsJavaPropCommand
  2345.             self.run(['/bin/su',
  2346.                       'ldap',
  2347.                       '-c',
  2348.                       dsjavaCmd
  2349.             ])
  2350.         except:
  2351.             self.logIt("Error running dsjavaproperties", True)
  2352.             self.logIt(traceback.format_exc(), True)
  2353.  
  2354.         try:
  2355.             stopDsJavaPropCommand = "%s/bin/stop-ds" % self.ldapBaseFolder
  2356.             dsjavaCmd = "cd /opt/opendj/bin ; %s" % stopDsJavaPropCommand
  2357.             self.run(['/bin/su',
  2358.                       'ldap',
  2359.                       '-c',
  2360.                       dsjavaCmd
  2361.             ])
  2362.         except:
  2363.             self.logIt("Error running stop-ds", True)
  2364.             self.logIt(traceback.format_exc(), True)
  2365.  
  2366.     def setup_init_scripts(self):
  2367.         if self.os_initdaemon == 'initd':
  2368.             for init_file in self.init_files:
  2369.                 try:
  2370.                     script_name = os.path.split(init_file)[-1]
  2371.                     self.copyFile(init_file, "/etc/init.d")
  2372.                     self.run([self.cmd_chmod, "755", "/etc/init.d/%s" % script_name])
  2373.                 except:
  2374.                     self.logIt("Error copying script file %s to /etc/init.d" % init_file)
  2375.                     self.logIt(traceback.format_exc(), True)
  2376.  
  2377.         if self.os_type in ['centos', 'fedora']:
  2378.             for service in self.redhat_services:
  2379.                 self.run(["/sbin/chkconfig", service, "on"])
  2380.         elif self.os_type in ['redhat']:
  2381.             for service in self.redhat_services:
  2382.                 self.run(["/sbin/chkconfig", service, "on"])
  2383.         elif self.os_type in ['ubuntu', 'debian']:
  2384.             for service in self.debian_services:
  2385.                 self.run(["/usr/sbin/update-rc.d", service, 'defaults'])
  2386.                 self.run(["/usr/sbin/update-rc.d", service, 'enable'])
  2387.  
  2388.  
  2389.     def start_services(self):
  2390.         # Detect service path and apache service name
  2391.         service_path = '/sbin/service'
  2392.         apache_service_name = 'httpd'
  2393.         if self.os_type in ['centos', 'redhat', 'fedora'] and self.os_initdaemon == 'systemd':
  2394.            service_path = '/usr/bin/systemctl'
  2395.            apache_service_name = 'httpd'
  2396.         elif self.os_type in ['debian', 'ubuntu']:
  2397.            service_path = '/usr/sbin/service'
  2398.            apache_service_name = 'apache2'
  2399.  
  2400.         # Apache HTTPD
  2401.         if self.os_type in ['centos', 'redhat', 'fedora'] and self.os_initdaemon == 'systemd':
  2402.            self.run([service_path, 'enable', apache_service_name])
  2403.            self.run([service_path, 'start', apache_service_name])
  2404.         else:
  2405.            self.run([service_path, apache_service_name, 'start'])
  2406.  
  2407.         # Memcached
  2408.         if self.os_type in ['centos', 'redhat', 'fedora'] and self.os_initdaemon == 'systemd':
  2409.            self.run([service_path, 'start', 'memcached.service'])
  2410.         else:
  2411.            self.run([service_path, 'memcached', 'start'])
  2412.  
  2413.         # Openldap
  2414.         if self.installLdap:
  2415.             # FIXME Tested on ubuntu only
  2416.             if self.os_type in ['centos', 'redhat', 'fedora'] and self.os_initdaemon == 'systemd':
  2417.                self.run([service_path, 'restart', 'rsyslog.service'])
  2418.                self.run([service_path, 'start', 'solserver.service'])
  2419.             else:
  2420.                # Below two lines are specifically for Ubuntu 14.04
  2421.                if self.os_type == 'ubuntu':
  2422.                    self.copyFile(self.rsyslogUbuntuInitFile, "/etc/init.d")
  2423.                    self.removeFile("/etc/init/rsyslog.conf")
  2424.                    rsyslogFn = os.path.split(self.rsyslogUbuntuInitFile)[-1]
  2425.                    self.run([self.cmd_chmod, "755", "/etc/init.d/%s" % rsyslogFn])
  2426.  
  2427.                self.run([service_path, 'rsyslog', 'restart'])
  2428.                self.run([service_path, 'solserver', 'start'])
  2429.  
  2430.         # Jetty services
  2431.         try:
  2432.             # Iterate through all components and start installed
  2433.             for applicationName, applicationConfiguration in self.jetty_app_configuration.iteritems():
  2434.                 if applicationConfiguration['installed']:
  2435.                     if self.os_type in ['centos', 'redhat', 'fedora'] and self.os_initdaemon == 'systemd':
  2436.                        self.run([service_path, 'start', applicationName], None, None, True)
  2437.                     else:
  2438.                        self.run([service_path, applicationName, 'start'], None, None, True)
  2439.         except:
  2440.             self.logIt("Error starting Jetty services")
  2441.             self.logIt(traceback.format_exc(), True)
  2442.  
  2443.     def update_hostname(self):
  2444.         self.logIt("Copying hosts and hostname to final destination")
  2445.  
  2446.         if self.os_initdaemon == 'systemd' and self.os_type in ['centos', 'redhat', 'fedora']:
  2447.             self.run(['/usr/bin/hostnamectl', 'set-hostname', self.hostname])
  2448.         else:
  2449.             if self.os_type in ['debian', 'ubuntu']:
  2450.                 self.copyFile("%s/hostname" % self.outputFolder, self.etc_hostname)
  2451.                 self.run(['/bin/chmod', '-f', '644', self.etc_hostname])
  2452.  
  2453.             if self.os_type in ['centos', 'redhat', 'fedora']:
  2454.                 self.copyFile("%s/network" % self.outputFolder, self.network)
  2455.  
  2456.             self.run(['/bin/hostname', self.hostname])
  2457.  
  2458.         self.copyFile("%s/hosts" % self.outputFolder, self.etc_hosts)
  2459.         self.run(['/bin/chmod', '-R', '644', self.etc_hosts])
  2460.  
  2461.     def install_openldap(self):
  2462.         self.logIt("Installing OpenLDAP from package")
  2463.  
  2464.         # Determine package type
  2465.         packageRpm = True
  2466.         packageExtension = ".rpm"
  2467.         if self.os_type in ['debian', 'ubuntu']:
  2468.             packageRpm = False
  2469.             packageExtension = ".deb"
  2470.  
  2471.         openLdapDistFolder = "%s/%s" % (self.distFolder, "symas")
  2472.  
  2473.         # Find package
  2474.         packageName = None
  2475.         for file in os.listdir(openLdapDistFolder):
  2476.             if file.endswith(packageExtension):
  2477.                 packageName = "%s/%s" % ( openLdapDistFolder, file )
  2478.  
  2479.         if packageName == None:
  2480.             self.logIt('Failed to find OpenLDAP package in folder %s !' % openLdapDistFolder)
  2481.             return
  2482.  
  2483.         self.logIt("Found package '%s' for install" % packageName)
  2484.         if packageRpm:
  2485.            self.run([self.cmd_rpm, '--install', '--verbose', '--hash', packageName])
  2486.         else:
  2487.            self.run([self.cmd_dpkg, '--install', packageName])
  2488.  
  2489.         openldapRunFolder = '/var/symas/run'
  2490.         self.run([self.cmd_chmod, '-R', '775', openldapRunFolder])
  2491.         self.run([self.cmd_chgrp, '-R', 'ldap', openldapRunFolder])
  2492.  
  2493.     def get_openldap_indexes(self):
  2494.         """Function that reads the static/openldap/index.json file and generates
  2495.        slapd.conf compatible index configuration string"""
  2496.         f = open(self.opendlapIndexDef, 'r')
  2497.         jsoninfo = json.loads(f.read())
  2498.         f.close()
  2499.         outString = ""
  2500.         for entry in jsoninfo["indexes"]:
  2501.             outString += "\t".join(["index", entry["attribute"], entry["index"]]) + "\n"
  2502.         return outString
  2503.  
  2504.  
  2505.     def configure_openldap(self):
  2506.         self.logIt("Configuring OpenLDAP")
  2507.         # 1. Render templates
  2508.         self.templateRenderingDict['openldap_accesslog_conf'] = self.readFile(self.accessLogConfFile)
  2509.         self.templateRenderingDict['openldap_gluu_accesslog'] = self.readFile(self.gluuAccessLogConf)
  2510.         if not self.openldapSetupAccessLog:
  2511.             self.templateRenderingDict['openldap_accesslog_conf'] = self.commentOutText(self.templateRenderingDict['openldap_accesslog_conf'])
  2512.             self.templateRenderingDict['openldap_gluu_accesslog'] = self.commentOutText(self.templateRenderingDict['openldap_gluu_accesslog'])
  2513.  
  2514.         # 1.1 convert the indexes
  2515.         self.templateRenderingDict['openldap_indexes'] = self.get_openldap_indexes()
  2516.  
  2517.         self.renderTemplate(self.openldapSlapdConf)
  2518.         self.renderTemplate(self.openldapSymasConf)
  2519.  
  2520.         # 2. Copy the conf files to
  2521.         self.copyFile(self.openldapSlapdConf, self.openldapConfFolder)
  2522.         self.copyFile(self.openldapSymasConf, self.openldapConfFolder)
  2523.  
  2524.         # 3. Copy the schema files into place
  2525.         self.createDirs(self.openldapSchemaFolder)
  2526.         self.copyFile("%s/static/openldap/gluu.schema" % self.install_dir, self.openldapSchemaFolder)
  2527.         self.copyFile("%s/static/openldap/custom.schema" % self.install_dir, self.openldapSchemaFolder)
  2528.  
  2529.         self.run([self.cmd_chown, '-R', 'ldap:ldap', '/opt/gluu/data'])
  2530.         self.run([self.cmd_chmod, '-R', 'a+rX', self.openldapRootSchemaFolder])
  2531.         self.run([self.cmd_chown, '-R', 'ldap:ldap', self.openldapRootSchemaFolder])
  2532.  
  2533.         # 5. Create the PEM file from key and crt
  2534.         with open(self.openldapTLSCACert, 'w') as pem:
  2535.             with open(self.openldapTLSCert, 'r') as crt:
  2536.                 pem.write(crt.read())
  2537.             with open(self.openldapTLSKey, 'r') as key:
  2538.                 pem.write(key.read())
  2539.                
  2540.         with open(self.passportSpTLSCACert, 'w') as pem:
  2541.             with open(self.passportSpTLSCert, 'r') as crt:
  2542.                 pem.write(crt.read())
  2543.             with open(self.passportSpTLSKey, 'r') as key:
  2544.                 pem.write(key.read())
  2545.  
  2546.  
  2547.         # 6. Setup Logging
  2548.         self.run([self.cmd_mkdir, '-m', '775', '-p', self.openldapLogDir])
  2549.         if self.os_type in ['debian', 'ubuntu']:
  2550.             self.run([self.cmd_chown, '-R', 'syslog:adm', self.openldapLogDir])
  2551.         if not os.path.isdir('/etc/rsyslog.d/'):
  2552.             self.run([self.cmd_mkdir, '-p', '/etc/rsyslog.d/'])
  2553.         self.copyFile(self.openldapSyslogConf, '/etc/rsyslog.d/')
  2554.         self.copyFile(self.openldapLogrotate, '/etc/logrotate.d/')
  2555.  
  2556.     def import_ldif_openldap(self):
  2557.         self.logIt("Importing LDIF files into OpenLDAP")
  2558.         cmd = os.path.join(self.openldapBinFolder, 'slapadd')
  2559.         config = os.path.join(self.openldapConfFolder, 'slapd.conf')
  2560.         realInstallDir = os.path.realpath(self.install_dir)
  2561.         for ldif in self.ldif_files:
  2562.             if 'site.ldif' in ldif:
  2563.                 self.run(['/bin/su', 'ldap', '-c', "cd " + realInstallDir + "; " + " ".join([cmd, '-b', 'o=site', '-f', config, '-l', ldif])])
  2564.             else:
  2565.                 self.run(['/bin/su', 'ldap', '-c', "cd " + realInstallDir + "; " + " ".join([cmd, '-b', 'o=gluu', '-f', config, '-l', ldif])])
  2566.  
  2567.     def import_custom_ldif_openldap(self, fullPath):
  2568.         output_dir = fullPath + '.output'
  2569.  
  2570.         self.logIt("Importing Custom LDIF files into OpenLDAP")
  2571.         cmd = os.path.join(self.openldapBinFolder, 'slapadd')
  2572.         config = os.path.join(self.openldapConfFolder, 'slapd.conf')
  2573.         realInstallDir = os.path.realpath(self.install_dir)
  2574.         try:
  2575.             for ldif in self.get_filepaths(fullPath):
  2576.                 custom_ldif = output_dir + '/' + ldif
  2577.                 self.run(['/bin/su', 'ldap', '-c', "cd " + realInstallDir + "; " + " ".join([cmd, '-b', 'o=gluu', '-f', config, '-l', custom_ldif])])
  2578.         except:
  2579.             self.logIt("Error importing custom ldif file %s" % ldif, True)
  2580.             self.logIt(traceback.format_exc(), True)
  2581.  
  2582.     def install_ldap_server(self):
  2583.         self.logIt("Running OpenDJ Setup")
  2584.  
  2585.         installObject.extractOpenDJ()
  2586.         installObject.opendj_version = installObject.determineOpenDJVersion()
  2587.         installObject.createLdapPw()
  2588.         installObject.install_opendj()
  2589.         installObject.deleteLdapPw()
  2590.  
  2591.         self.logIt("Running OpenLDAP Setup")
  2592.         installObject.install_openldap()
  2593.         installObject.configure_openldap()
  2594.         installObject.import_ldif_openldap()
  2595.  
  2596.     def calculate_aplications_memory(self):
  2597.         self.logIt("Calculating memory setting for applications")
  2598.  
  2599.         installedComponents = []
  2600.         allowedApplicationsMemory = {}
  2601.  
  2602.         # Jetty apps
  2603.         if self.installOxAuth:
  2604.             installedComponents.append(self.jetty_app_configuration['oxauth'])
  2605.         if self.installOxTrust:
  2606.             installedComponents.append(self.jetty_app_configuration['identity'])
  2607.         if self.installSaml:
  2608.             installedComponents.append(self.jetty_app_configuration['idp'])
  2609.         if self.installAsimba:
  2610.             installedComponents.append(self.jetty_app_configuration['asimba'])
  2611.         if self.installOxAuthRP:
  2612.             installedComponents.append(self.jetty_app_configuration['oxauth-rp'])
  2613.  
  2614.         # Node apps
  2615.         if self.installPassport:
  2616.             installedComponents.append(self.jetty_app_configuration['passport'])
  2617.  
  2618.         usedRatio = 0.001
  2619.         for installedComponent in installedComponents:
  2620.             usedRatio += installedComponent['memory']['ratio']
  2621.  
  2622.         ratioMultiplier = 1.0 + (1.0 - usedRatio)/usedRatio
  2623.  
  2624.         for installedComponent in installedComponents:
  2625.             allowedRatio = installedComponent['memory']['ratio'] * ratioMultiplier
  2626.             allowedMemory = int(round(allowedRatio * int(self.application_max_ram)))
  2627.  
  2628.             if allowedMemory > installedComponent['memory']['max_allowed_mb']:
  2629.                 allowedMemory = installedComponent['memory']['max_allowed_mb']
  2630.  
  2631.             allowedApplicationsMemory[installedComponent['name']] = allowedMemory
  2632.  
  2633.         # Iterate through all components into order to prepare all keys
  2634.         for applicationName, applicationConfiguration in self.jetty_app_configuration.iteritems():
  2635.             if applicationName in allowedApplicationsMemory:
  2636.                 applicationMemory = allowedApplicationsMemory.get(applicationName)
  2637.             else:
  2638.                 # We uses this dummy value to render template properly of not installed application
  2639.                 applicationMemory = 256
  2640.  
  2641.             self.templateRenderingDict["%s_max_mem" % applicationName] = applicationMemory
  2642.  
  2643.             if 'jvm_heap_ration' in applicationConfiguration['memory']:
  2644.                 jvmHeapRation = applicationConfiguration['memory']['jvm_heap_ration']
  2645.  
  2646.                 minHeapMem = 256
  2647.                 maxHeapMem = int(applicationMemory * jvmHeapRation)
  2648.                 if maxHeapMem < minHeapMem:
  2649.                     minHeapMem = maxHeapMem
  2650.  
  2651.                 self.templateRenderingDict["%s_max_heap_mem" % applicationName] = maxHeapMem
  2652.                 self.templateRenderingDict["%s_min_heap_mem" % applicationName] = minHeapMem
  2653.  
  2654.                 self.templateRenderingDict["%s_max_meta_mem" % applicationName] = applicationMemory - self.templateRenderingDict["%s_max_heap_mem" % applicationName]
  2655.                
  2656.  
  2657.     def merge_dicts(self, *dict_args):
  2658.         result = {}
  2659.         for dictionary in dict_args:
  2660.             result.update(dictionary)
  2661.  
  2662.         return result
  2663.  
  2664.     ##### Below function is temporary and will serve only
  2665.     ##### Untill we're done with systemd units for all services for Ubuntu 16 and CentOS 7
  2666.     def change_rc_links(self):
  2667.         if self.os_type in ['ubuntu', 'debian']:
  2668.             if os.path.isfile('/etc/rc3.d/S03solserver'):
  2669.                 self.logIt("Changing RC Level 3 Links")
  2670.                 self.run(['mv', '/etc/rc3.d/S03solserver', '/etc/rc3.d/S80solserver'])
  2671.             if os.path.isfile('/etc/rc3.d/S01oxauth'):
  2672.                 self.run(['mv', '/etc/rc3.d/S01oxauth', '/etc/rc3.d/S81oxauth'])
  2673.             if os.path.isfile('/etc/rc3.d/S01identity'):
  2674.                 self.run(['mv', '/etc/rc3.d/S01identity', '/etc/rc3.d/S82identity'])
  2675.             if os.path.isfile('/etc/rc3.d/S02apache2'):
  2676.                 self.run(['mv', '/etc/rc3.d/S02apache2', '/etc/rc3.d/S83apache2'])
  2677. ############################   Main Loop   #################################################
  2678.  
  2679. def print_help():
  2680.     print "\nUse setup.py to configure your Gluu Server and to add initial data required for"
  2681.     print "oxAuth and oxTrust to start. If setup.properties is found in this folder, these"
  2682.     print "properties will automatically be used instead of the interactive setup."
  2683.     print "Options:"
  2684.     print ""
  2685.     print "    -a   Install Asimba"
  2686.     print "    -r   Install oxAuth RP"
  2687.     print "    -p   Install Passport"
  2688.     print "    -d   specify the directory where community-edition-setup is located. Defaults to '.'"
  2689.     print "    -f   specify setup.properties file"
  2690.     print "    -h   Help"
  2691.     print "    -n   No interactive prompt before install starts. Run with -f"
  2692.     print "    -N   No apache httpd server"
  2693.     print "    -s   Install the Shibboleth IDP"
  2694.     print "    -u   Update hosts file with IP address / hostname"
  2695.     print "    -w   Get the development head war files"
  2696.     print "    -e   Download JCE 1.8 and install it"
  2697.     print "    --allow_pre_released_applications"
  2698.     print "    --allow_deprecated_applications"
  2699.     print "    --import-ldif=custom-ldif-dir Render ldif templates from custom-ldif-dir and import them in LDAP"
  2700.  
  2701. def getOpts(argv, setupOptions):
  2702.     try:
  2703.         opts, args = getopt.getopt(argv, "adp:f:hNnsuwre", ['allow_pre_released_applications', 'allow_deprecated_applications', 'import-ldif='])
  2704.     except getopt.GetoptError:
  2705.         print_help()
  2706.         sys.exit(2)
  2707.     for opt, arg in opts:
  2708.         if opt == '-a':
  2709.             setupOptions['installAsimba'] = True
  2710.         elif opt == '-d':
  2711.             if os.path.exists(arg):
  2712.                 setupOptions['install_dir'] = arg
  2713.             else:
  2714.                 print 'System folder %s does not exist. Installing in %s' % (arg, os.getcwd())
  2715.         elif opt == '-h':
  2716.             print_help()
  2717.             sys.exit()
  2718.         elif opt == "-f":
  2719.             try:
  2720.                 if os.path.isfile(arg):
  2721.                     setupOptions['setup_properties'] = arg
  2722.                     print "Found setup properties %s\n" % arg
  2723.                 else:
  2724.                     print "\nOoops... %s file not found for setup properties.\n" % arg
  2725.             except:
  2726.                 print "\nOoops... %s file not found\n" % arg
  2727.         elif opt == "-n":
  2728.             setupOptions['noPrompt'] = True
  2729.         elif opt == "-N":
  2730.             setupOptions['installHTTPD'] = False
  2731.         elif opt == "-s":
  2732.             setupOptions['installSaml'] = True
  2733.         elif opt == "-u":
  2734.             pass  # TODO implement this option or remove it from help
  2735.         elif opt == "-w":
  2736.             setupOptions['downloadWars'] = True
  2737.         elif opt == '-r':
  2738.             setupOptions['installOxAuthRP'] = True
  2739.         elif opt == '-p':
  2740.             setupOptions['installPassport'] = True
  2741.         elif opt == "-e":
  2742.             setupOptions['installJce'] = True
  2743.     elif opt == '--allow_pre_released_applications':
  2744.             setupOptions['allowPreReleasedApplications'] = True
  2745.         elif opt == '--allow_deprecated_applications':
  2746.             setupOptions['allowDeprecatedApplications'] = True
  2747.     elif opt == '--import-ldif':
  2748.             if os.path.isdir(arg):
  2749.                 setupOptions['importLDIFDir'] = arg
  2750.                 print "Found setup LDIF import directory %s\n" % (arg)
  2751.             else:
  2752.                 print 'The custom LDIF import directory %s does not exist. Exiting...' % (arg)
  2753.                 sys.exit(2)
  2754.     return setupOptions
  2755.  
  2756. if __name__ == '__main__':
  2757.  
  2758.     setupOptions = {
  2759.         'install_dir': '.',
  2760.         'setup_properties': None,
  2761.         'noPrompt': False,
  2762.         'downloadWars': False,
  2763.         'installOxAuth': True,
  2764.         'installOxTrust': True,
  2765.         'installLDAP': True,
  2766.         'installHTTPD': True,
  2767.         'installSaml': False,
  2768.         'installAsimba': False,
  2769.         'installOxAuthRP': False,
  2770.         'installPassport': False,
  2771.         'allowPreReleasedApplications': False,
  2772.         'allowDeprecatedApplications': False,
  2773.         'installJce': False
  2774.     }
  2775.     if len(sys.argv) > 1:
  2776.         setupOptions = getOpts(sys.argv[1:], setupOptions)
  2777.  
  2778.     installObject = Setup(setupOptions['install_dir'])
  2779.  
  2780.     installObject.downloadWars = setupOptions['downloadWars']
  2781.  
  2782.     installObject.installOxAuth = setupOptions['installOxAuth']
  2783.     installObject.installOxTrust = setupOptions['installOxTrust']
  2784.     installObject.installLdap = setupOptions['installLDAP']
  2785.     installObject.installHttpd = setupOptions['installHTTPD']
  2786.     installObject.installSaml = setupOptions['installSaml']
  2787.     installObject.installAsimba = setupOptions['installAsimba']
  2788.     installObject.installOxAuthRP = setupOptions['installOxAuthRP']
  2789.     installObject.installPassport = setupOptions['installPassport']
  2790.     installObject.allowPreReleasedApplications = setupOptions['allowPreReleasedApplications']
  2791.     installObject.allowDeprecatedApplications = setupOptions['allowDeprecatedApplications']
  2792.     installObject.installJce = setupOptions['installJce']
  2793.  
  2794.     # Get the OS type
  2795.     installObject.os_type = installObject.detect_os_type()
  2796.     # Get the init type
  2797.     installObject.os_initdaemon = installObject.detect_initd()
  2798.     # Get apache version
  2799.     installObject.apache_version = installObject.determineApacheVersionForOS()
  2800.  
  2801.     print "\nInstalling Gluu Server..."
  2802.     print "Detected OS  :  %s" % installObject.os_type
  2803.     print "Detected init:  %s" % installObject.os_initdaemon
  2804.     print "Detected Apache:  %s" % installObject.apache_version
  2805.  
  2806.     print "\nInstalling Gluu Server...\n\nFor more info see:\n  %s  \n  %s\n" % (installObject.log, installObject.logError)
  2807.     print "\n** All clear text passwords contained in %s.\n" % installObject.savedProperties
  2808.     try:
  2809.         os.remove(installObject.log)
  2810.         installObject.logIt('Removed %s' % installObject.log)
  2811.     except:
  2812.         pass
  2813.     try:
  2814.         os.remove(installObject.logError)
  2815.         installObject.logIt('Removed %s' % installObject.logError)
  2816.     except:
  2817.         pass
  2818.  
  2819.     installObject.logIt("Installing Gluu Server", True)
  2820.  
  2821.     if setupOptions['setup_properties']:
  2822.         installObject.logIt('%s Properties found!\n' % setupOptions['setup_properties'])
  2823.         installObject.load_properties(setupOptions['setup_properties'])
  2824.     elif os.path.isfile(installObject.setup_properties_fn):
  2825.         installObject.logIt('%s Properties found!\n' % installObject.setup_properties_fn)
  2826.         installObject.load_properties(installObject.setup_properties_fn)
  2827.     else:
  2828.         installObject.logIt("%s Properties not found. Interactive setup commencing..." % installObject.setup_properties_fn)
  2829.         installObject.promptForProperties()
  2830.  
  2831.     # Validate Properties
  2832.     installObject.check_properties()
  2833.  
  2834. ### Ganesh Working Here...
  2835.     if 'importLDIFDir' in setupOptions.keys():
  2836.         if os.path.isdir(installObject.openldapBaseFolder):
  2837.             installObject.logIt("Gluu server already installed. Setup will render and import templates and exit.", True)
  2838.             installObject.render_custom_templates(setupOptions['importLDIFDir'])
  2839.             installObject.import_custom_ldif_openldap(setupOptions['importLDIFDir'])
  2840.             installObject.logIt("Setup is exiting now after import of ldifs generated.", True)
  2841.             sys.exit(2)
  2842.  
  2843.     # Show to properties for approval
  2844.     print '\n%s\n' % `installObject`
  2845.     proceed = "NO"
  2846.     if not setupOptions['noPrompt']:
  2847.         proceed = raw_input('Proceed with these values [Y|n] ').lower().strip()
  2848.     if (setupOptions['noPrompt'] or not len(proceed) or (len(proceed) and (proceed[0] == 'y'))):
  2849.         try:
  2850.             installObject.configureSystem()
  2851.             installObject.downloadWarFiles()
  2852.             installObject.calculate_aplications_memory()
  2853.             installObject.installJRE()
  2854.             installObject.installJetty()
  2855.             installObject.installJython()
  2856.             installObject.installNode()
  2857.             installObject.make_salt()
  2858.             installObject.make_oxauth_salt()
  2859.             installObject.copy_scripts()
  2860.             installObject.install_gluu_base()
  2861.             installObject.encode_passwords()
  2862.             installObject.encode_test_passwords()
  2863.             installObject.prepare_base64_extension_scripts()
  2864.             installObject.render_templates()
  2865.             installObject.generate_crypto()
  2866.             installObject.generate_oxauth_openid_keys()
  2867.             installObject.generate_base64_configuration()
  2868.             installObject.render_configuration_template()
  2869.             installObject.update_hostname()
  2870.             installObject.set_ulimits()
  2871.             installObject.copy_output()
  2872.             installObject.setup_init_scripts()
  2873.             installObject.render_jetty_templates()
  2874.             installObject.render_node_templates()
  2875.             installObject.install_gluu_components()
  2876.             installObject.render_test_templates()
  2877.             installObject.copy_static()
  2878.             installObject.set_ownership()
  2879.             installObject.set_permissions()
  2880.             installObject.start_services()
  2881.             installObject.change_rc_links()
  2882.             installObject.save_properties()
  2883.             if 'importLDIFDir' in setupOptions.keys():
  2884.                 installObject.render_custom_templates(setupOptions['importLDIFDir'])
  2885.                 installObject.import_custom_ldif_openldap(setupOptions['importLDIFDir'])
  2886.  
  2887.         except:
  2888.             installObject.logIt("***** Error caught in main loop *****", True)
  2889.             installObject.logIt(traceback.format_exc(), True)
  2890.         print "\n\n Gluu Server installation successful! Point your browser to https://%s\n\n" % installObject.hostname
  2891.     else:
  2892.         installObject.save_properties()
  2893.         print "Properties saved to %s. Change filename to %s if you want to re-use" % \
  2894.                          (installObject.savedProperties, installObject.setup_properties_fn)
  2895.  
  2896. # END
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!