| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. See accompanying LICENSE file. |
| # |
| import os |
| import sys |
| import errno |
| import logging |
| import zipfile |
| import ConfigParser |
| import StringIO |
| import subprocess |
| import fileinput |
| #import MySQLdb |
| import zipfile |
| import re |
| import shutil |
| import commands |
| from datetime import date |
| import getpass |
| import glob |
| import pprint |
| from subprocess import Popen,PIPE |
| |
| conf_dict={} |
| |
| |
| """ |
| ################################################ |
| Helper routines |
| ################################################ |
| """ |
| |
| def log(msg,type): |
| if type == 'info': |
| logging.info(" %s",msg) |
| if type == 'error': |
| logging.error(" %s",msg) |
| if type == 'debug': |
| logging.debug(" %s",msg) |
| if type == 'warning': |
| logging.warning(" %s",msg) |
| if type == 'exception': |
| logging.exception(" %s",msg) |
| |
| def password_validation(password, userType): |
| if password: |
| if re.search("[\\\`'\"]",password): |
| log("[E] "+userType+" user password contains one of the unsupported special characters like \" ' \ `","error") |
| sys.exit(1) |
| else: |
| log("[I] "+userType+" user password validated","info") |
| else: |
| log("[E] Blank password is not allowed,please enter valid password.","error") |
| sys.exit(1) |
| |
| def resolve_sym_link(path): |
| path = os.path.realpath(path) |
| base_dir = os.path.dirname(os.path.dirname(path)) |
| return path, base_dir |
| |
| #prog = ["mysql", "-u", "ve", "--execute", 'insert into foo values ("snargle", 2)'] |
| |
| def getstatusoutput(cmd): |
| """Return (status, output) of executing cmd in a shell.""" |
| """This new implementation should work on all platforms.""" |
| """pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, shell=True, universal_newlines=True) |
| "output, err = pipe.communicate() |
| "sts = pipe.returncode |
| """ |
| ret = subprocess.call(cmd, shell=True) |
| print "------------------" |
| print " cmd: " + str(cmd) |
| #print " output: " + output |
| print " ret: " + str(ret) |
| print "------------------" |
| return ret, ret |
| #if sts is None: |
| # log("sts is None!!!! Manually setting to -1. PLEASE CHECK!!!!!!!!!!!!!!","info") |
| # sts = -1 |
| #return sts, output |
| |
| |
| def copy_files(source_dir,dest_dir): |
| for dir_path, dir_names, file_names in os.walk(source_dir): |
| for file_name in file_names: |
| target_dir = dir_path.replace(source_dir, dest_dir, 1) |
| if not os.path.exists(target_dir): |
| os.mkdir(target_dir) |
| src_file = os.path.join(dir_path, file_name) |
| dest_file = os.path.join(target_dir, file_name) |
| log("copying src: " + src_file + " dest: " + dest_file, "debug") |
| shutil.copyfile(src_file, dest_file) |
| |
| |
| |
| def ModConfig(File, Variable, Setting): |
| """ |
| Modify Config file variable with new setting |
| """ |
| VarFound = False |
| AlreadySet = False |
| V=str(Variable) |
| S=str(Setting) |
| # use quotes if setting has spaces # |
| if ' ' in S: |
| S = '"%s"' % S |
| |
| for line in fileinput.input(File, inplace = 1): |
| # process lines that look like config settings # |
| if not line.lstrip(' ').startswith('#') and '=' in line: |
| _infile_var = str(line.split('=')[0].rstrip(' ')) |
| _infile_set = str(line.split('=')[1].lstrip(' ').rstrip()) |
| # only change the first matching occurrence # |
| if VarFound == False and _infile_var.rstrip(' ') == V: |
| VarFound = True |
| # don't change it if it is already set # |
| if _infile_set.lstrip(' ') == S: |
| AlreadySet = True |
| else: |
| line = "%s = %s\n" % (V, S) |
| |
| sys.stdout.write(line) |
| |
| |
| # Append the variable if it wasn't found # |
| if not VarFound: |
| log( "Variable '%s' not found. Adding it to %s" % (V, File), "debug") |
| with open(File, "a") as f: |
| f.write("%s = %s\n" % (V, S)) |
| elif AlreadySet == True: |
| log( "Variable '%s' unchanged" % (V) , "debug") |
| else: |
| log( "Variable '%s' modified to '%s'" % (V, S) , "debug") |
| |
| return |
| |
| |
| def mkdir_p(path): |
| try: |
| os.makedirs(path) |
| except OSError as exc: |
| if exc.errno == errno.EEXIST and os.path.isdir(path): |
| pass |
| else: |
| raise |
| |
| def get_java_env(): |
| JAVA_HOME = os.getenv('JAVA_HOME') |
| if JAVA_HOME: |
| return os.path.join(JAVA_HOME, 'bin', 'java') |
| else: |
| log('java and jar commands are not available. Please configure JAVA_HOME','exception') |
| os.sys.exit(1) |
| |
| def get_class_path(paths): |
| separator = ';' if sys.platform == 'win32' else ':'; |
| return separator.join(paths) |
| |
| def get_jdk_options(): |
| global conf_dict |
| return [os.getenv('RANGER_PROPERTIES', ''),"-Dlogdir="+os.getenv("RANGER_LOG_DIR"), |
| ' -Dcatalina.base=' + conf_dict['EWS_ROOT'] ] |
| |
| |
| """ |
| ################################################ |
| Ranger Policy Manager routines |
| ################################################ |
| """ |
| |
| def get_ranger_classpath(): |
| global conf_dict |
| EWS_ROOT = conf_dict['EWS_ROOT'] |
| WEBAPP_ROOT = conf_dict['WEBAPP_ROOT'] |
| |
| cp = [ os.path.join(WEBAPP_ROOT, "WEB-INF", "classes", "conf"), os.path.join(EWS_ROOT,"lib","*"), EWS_ROOT, os.path.join(os.getenv('JAVA_HOME'), 'lib', '*')] |
| class_path = get_class_path(cp) |
| return class_path |
| |
| def populate_config_dict_from_env(): |
| global config_dict |
| conf_dict['RANGER_ADMIN_DB_HOST'] = os.getenv("RANGER_ADMIN_DB_HOST") |
| conf_dict['RANGER_AUDIT_DB_HOST'] = os.getenv("RANGER_AUDIT_DB_HOST") |
| #conf_dict['MYSQL_BIN'] = 'mysql.exe' #os.getenv("MYSQL_BIN") |
| conf_dict['RANGER_DB_FLAVOR'] = os.getenv("RANGER_DB_FLAVOR") |
| conf_dict['RANGER_AUDIT_DB_FLAVOR'] = os.getenv("RANGER_DB_FLAVOR") |
| conf_dict['RANGER_ADMIN_DB_USERNAME'] = os.getenv("RANGER_ADMIN_DB_USERNAME") |
| conf_dict['RANGER_ADMIN_DB_PASSWORD'] = os.getenv("RANGER_ADMIN_DB_PASSWORD") |
| conf_dict['RANGER_ADMIN_DB_NAME'] = os.getenv("RANGER_ADMIN_DB_DBNAME") |
| conf_dict['RANGER_AUDIT_DB_USERNAME'] = os.getenv("RANGER_AUDIT_DB_USERNAME") |
| conf_dict['RANGER_AUDIT_DB_PASSWORD'] = os.getenv("RANGER_AUDIT_DB_PASSWORD") |
| conf_dict['RANGER_AUDIT_DB_NAME'] = os.getenv("RANGER_AUDIT_DB_DBNAME") |
| conf_dict['db_root_user'] = os.getenv("RANGER_DB_ROOT_USER") |
| conf_dict['db_root_password'] = os.getenv("RANGER_ADMIN_DB_ROOT_PASSWORD") |
| conf_dict['RANGER_ADMIN_DB_ROOT_PASSWORD'] = os.getenv("RANGER_ADMIN_DB_ROOT_PASSWORD") |
| conf_dict['RANGER_AUDIT_DB_ROOT_PASSWORD'] = os.getenv("RANGER_AUDIT_DB_ROOT_PASSWORD") |
| conf_dict['RANGER_ADMIN_HOME'] = os.getenv("RANGER_ADMIN_HOME") |
| conf_dict['RANGER_AUTHENTICATION_METHOD'] = os.getenv("RANGER_AUTHENTICATION_METHOD") |
| # LDAP Settings |
| conf_dict['RANGER_LDAP_URL'] = os.getenv("RANGER_LDAP_URL") |
| conf_dict['RANGER_LDAP_USERDNPATTERN'] = os.getenv("RANGER_LDAP_USERDNPATTERN") |
| conf_dict['RANGER_LDAP_GROUPSEARCHBASE'] = os.getenv("RANGER_LDAP_GROUPSEARCHBASE") |
| conf_dict['RANGER_LDAP_GROUPSEARCHFILTER'] = os.getenv("RANGER_LDAP_GROUPSEARCHFILTER") |
| conf_dict['RANGER_ldap_GROUPROLEATTRIBUTE'] = os.getenv("RANGER_ldap_GROUPROLEATTRIBUTE") |
| |
| # AD Settings |
| conf_dict['RANGER_LDAP_AD_DOMAIN'] = os.getenv("RANGER_LDAP_AD_DOMAIN") |
| conf_dict['RANGER_LDAP_AD_URL'] = os.getenv("RANGER_LDAP_AD_URL") |
| |
| def populate_config_dict_from_file(): |
| global config_dict |
| RANGER_ADMIN_HOME = os.getenv("RANGER_ADMIN_HOME") |
| read_config_file = open(os.path.join(RANGER_ADMIN_HOME,'bin','install_config.properties')) |
| library_path = os.path.join(RANGER_ADMIN_HOME,"cred","lib","*") |
| for each_line in read_config_file.read().split('\n') : |
| if len(each_line) == 0 : continue |
| # print 'each_line = ' + each_line |
| key , value = each_line.strip().split("=",1) |
| key = key.strip() |
| if 'PASSWORD' in key: |
| jceks_file_path = os.path.join(os.getenv('RANGER_HOME'), 'jceks','ranger_db.jceks') |
| statuscode,value = call_keystore(library_path,key,'',jceks_file_path,'get') |
| if statuscode == 1: |
| value = '' |
| value = value.strip() |
| conf_dict[key] = value |
| #if os.getenv("MYSQL_BIN") is not None: |
| # conf_dict['MYSQL_BIN'] = os.getenv("MYSQL_BIN") |
| #else: |
| # os.sys.exit('Please set MYSQL_BIN variable in environment settings.') |
| |
| |
| def init_variables(switch): |
| global conf_dict |
| |
| if switch == 'service' : |
| populate_config_dict_from_env() |
| else: |
| populate_config_dict_from_file() |
| #INSTALL_DIR = os.path.join(conf_dict['RANGER_ADMIN_HOME'] , "app") |
| INSTALL_DIR = conf_dict['RANGER_ADMIN_HOME'] |
| EWS_ROOT = os.path.join(INSTALL_DIR , "ews") |
| WEBAPP_ROOT = os.path.join(INSTALL_DIR , "ews" , "webapp") |
| |
| #if switch == "service": |
| # war_file_path = os.path.join(conf_dict['RANGER_ADMIN_HOME'] , "war", "security-admin-web-*.war") |
| # war_file_list = glob.glob(war_file_path) |
| # conf_dict['war_file'] = war_file_list[0] |
| |
| conf_dict['EWS_ROOT'] = EWS_ROOT |
| conf_dict['WEBAPP_ROOT']= WEBAPP_ROOT |
| conf_dict['INSTALL_DIR']= INSTALL_DIR |
| conf_dict['JAVA_BIN']= os.path.join(os.getenv("JAVA_HOME"),'bin','java.exe') |
| conf_dict['DB_FLAVOR'] = os.getenv("RANGER_DB_FLAVOR") |
| conf_dict['RANGER_DB_FLAVOR'] = os.getenv("RANGER_DB_FLAVOR") |
| conf_dict['RANGER_AUDIT_DB_FLAVOR'] = os.getenv("RANGER_DB_FLAVOR") |
| dir = os.path.join(os.getenv("RANGER_HOME"),"connector-jar") |
| ews_dir = os.path.join(os.getenv("RANGER_ADMIN_HOME"),"ews","webapp","WEB-INF","lib") |
| log(ews_dir,"info") |
| if not os.path.exists(dir): |
| os.makedirs(dir) |
| layout_dir = os.path.dirname(os.getenv("HDP_LAYOUT")) |
| files = os.listdir(layout_dir) |
| if files: |
| for filename in files: |
| #log (filename,"info") |
| if os.getenv("RANGER_DB_FLAVOR") == "MYSQL" or os.getenv("RANGER_AUDIT_DB_FLAVOR") == "MYSQL": |
| f = re.match("^mysql-connector-java.*?.jar",filename) |
| elif os.getenv("RANGER_DB_FLAVOR") == "ORACLE" or os.getenv("RANGER_AUDIT_DB_FLAVOR") == "ORACLE": |
| f = re.match("^ojdbc.*?.jar",filename) |
| elif os.getenv("RANGER_DB_FLAVOR") == "POSTGRES" or os.getenv("RANGER_AUDIT_DB_FLAVOR") == "POSTGRES": |
| f = re.match("^postgresql-connector-jdbc.*?.jar",filename) |
| elif os.getenv("RANGER_DB_FLAVOR") == "MSSQL" or os.getenv("RANGER_AUDIT_DB_FLAVOR") == "MSSQL": |
| f = re.match("^sqljdbc.*?.jar",filename) |
| if f: |
| src = os.path.join(layout_dir,filename) |
| shutil.copy2(src, dir) |
| shutil.copy2(src, ews_dir) |
| conf_dict['SQL_CONNECTOR_JAR'] = os.path.join(dir,filename) |
| |
| |
| conf_dict['db_host']=os.getenv("RANGER_ADMIN_DB_HOST") + ":" + os.getenv("RANGER_ADMIN_DB_PORT") |
| conf_dict['db_name']=os.getenv("RANGER_ADMIN_DB_DBNAME") |
| conf_dict['db_user']=os.getenv("RANGER_ADMIN_DB_USERNAME") |
| conf_dict['db_password']=os.getenv("RANGER_ADMIN_DB_PASSWORD") |
| conf_dict['audit_db_name']=os.getenv("RANGER_AUDIT_DB_DBNAME") |
| conf_dict['audit_db_user']=os.getenv("RANGER_AUDIT_DB_USERNAME") |
| conf_dict['audit_db_password']=os.getenv("RANGER_AUDIT_DB_PASSWORD") |
| conf_dict['RANGER_ADMIN_DB_PORT']=os.getenv("RANGER_ADMIN_DB_PORT") |
| conf_dict['RANGER_AUDIT_DB_PORT']=os.getenv("RANGER_AUDIT_DB_PORT") |
| db_dir = os.path.join(conf_dict['RANGER_ADMIN_HOME'] , "db") |
| conf_dict['mysql_core_file']=os.path.join(db_dir,'mysql','xa_core_db.sql') |
| conf_dict['mysql_audit_file']=os.path.join(db_dir,'mysql','xa_audit_db.sql') |
| conf_dict['oracle_core_file']=os.path.join(db_dir,'oracle','xa_core_db_oracle.sql') |
| conf_dict['oracle_audit_file']=os.path.join(db_dir,'oracle','xa_audit_db_oracle.sql') |
| conf_dict['postgres_core_file']=os.path.join(db_dir,'postgres','xa_core_db_postgres.sql') |
| conf_dict['postgres_audit_file']=os.path.join(db_dir,'postgres','xa_audit_db_postgres.sql') |
| conf_dict['sqlserver_core_file']=os.path.join(db_dir,'sqlserver','xa_core_db_sqlserver.sql') |
| conf_dict['sqlserver_audit_file']=os.path.join(db_dir,'sqlserver','xa_audit_db_sqlserver.sql') |
| conf_dict['sqlanywhere_core_file']= os.path.join(db_dir,'sqlanywhere','xa_core_db_sqlanywhere.sql') |
| conf_dict['sqlanywhere_audit_file']= os.path.join(db_dir, 'sqlanywhere','xa_audit_db_sqlanywhere.sql') |
| #conf_dict['db_core_file'] = os.path.join(db_dir, "xa_core_db.sql") |
| #conf_dict['db_create_user_file'] = os.path.join(db_dir, "create_dev_user.sql") |
| #conf_dict['db_audit_file'] = os.path.join(db_dir, "xa_audit_db.sql") |
| #conf_dict['db_asset_file'] = os.path.join(db_dir, "reset_asset.sql") |
| |
| #log("config is : " , "debug") |
| #for x in conf_dict: |
| # log(x + " : " + conf_dict[x], "debug") |
| |
| #TODO fix the base_dir part |
| def setup_install_files(): |
| global conf_dict |
| |
| EWS_ROOT = conf_dict['EWS_ROOT'] |
| INSTALL_DIR = conf_dict['INSTALL_DIR'] |
| WEBAPP_ROOT = conf_dict['WEBAPP_ROOT'] |
| |
| EWS_LIB_DIR = os.path.join(EWS_ROOT,"lib") |
| #EWS_LOG_DIR = os.path.join(EWS_ROOT,"logs") |
| RANGER_ADMIN_HOME = os.getenv("RANGER_ADMIN_HOME") |
| |
| log("Setting up installation files and directory", "debug") |
| |
| if not os.path.isdir(INSTALL_DIR): |
| log("creating Install dir : " + INSTALL_DIR, "debug") |
| os.makedirs(INSTALL_DIR) |
| |
| if not os.path.isdir(EWS_ROOT): |
| log("creating EWS dir : " + EWS_ROOT, "debug") |
| os.makedirs(EWS_ROOT) |
| |
| if not os.path.isdir(WEBAPP_ROOT): |
| log("creating WEBAPP dir : " + WEBAPP_ROOT, "debug") |
| os.makedirs(WEBAPP_ROOT) |
| |
| if not os.path.isdir(os.path.join(WEBAPP_ROOT,"WEB-INF","classes","conf")): |
| log("creating conf dir : " + WEBAPP_ROOT, "debug") |
| os.makedirs(os.path.join(WEBAPP_ROOT,"WEB-INF","classes","conf")) |
| |
| if not os.path.isdir(EWS_LIB_DIR): |
| log("creating EWS_LIB_DIR dir : " + EWS_LIB_DIR, "debug") |
| os.makedirs(EWS_LIB_DIR) |
| |
| #if not os.path.isdir(EWS_LOG_DIR): |
| # log("creating EWS_LOG_DIR dir : " + EWS_LOG_DIR, "debug") |
| # os.makedirs(EWS_LOG_DIR) |
| |
| #log("copying libraries ", "debug") |
| #copy_files(os.path.join(RANGER_ADMIN_HOME,"ews","lib"), EWS_LIB_DIR) |
| |
| #log("copying xapolicymgr.properties file", "debug") |
| #shutil.copyfile(os.path.join(RANGER_ADMIN_HOME,"ews","xapolicymgr.properties"), os.path.join(EWS_ROOT,"xapolicymgr.properties")) |
| |
| log("copying conf.dist/ to conf/", "debug") |
| copy_files(os.path.join(WEBAPP_ROOT,"WEB-INF","classes","conf.dist"), os.path.join(WEBAPP_ROOT,"WEB-INF","classes","conf")) |
| log(" Setting up installation files and directory DONE", "info"); |
| pass |
| |
| |
| def write_config_to_file(): |
| global conf_dict |
| RANGER_ADMIN_HOME = os.getenv("RANGER_ADMIN_HOME") |
| library_path = os.path.join(RANGER_ADMIN_HOME, 'cred', 'lib','*') |
| jceks_file_path = os.path.join(os.getenv("RANGER_HOME"), "jceks") |
| if not os.path.isdir(jceks_file_path): |
| mkdir_p(jceks_file_path) |
| jceks_file_path = os.path.join(jceks_file_path,'ranger_db.jceks') |
| |
| file_path = os.path.dirname(os.path.realpath(__file__)) |
| write_conf_to_file = os.path.join(file_path, "install_config.properties") |
| open(write_conf_to_file,'wb') |
| for key,value in conf_dict.items(): |
| if 'PASSWORD' in key : |
| #call_keystore(library_path,key,value,jceks_file_path,'create') |
| value='' |
| ModConfig(write_conf_to_file , key,value) |
| |
| |
| def init_logfiles(): |
| FORMAT = '%(asctime)-15s %(message)s' |
| logging.basicConfig(format=FORMAT, level=logging.DEBUG) |
| |
| |
| def sanity_check_configure_files(): |
| global conf_dict |
| |
| log("Checking MYSQL executable and db files!!", 'debug') |
| db_core_file = conf_dict['db_core_file'] |
| db_create_user_file = conf_dict['db_create_user_file'] |
| db_audit_file = conf_dict['db_audit_file'] |
| db_asset_file = conf_dict['db_asset_file'] |
| |
| #if os.path.isfile(MYSQL_BIN): |
| # log("MYSQL Client bin : " + MYSQL_BIN + " file found", 'info') |
| #else: |
| # os.sys.exit('MYSQL_BIN: ' + MYSQL_BIN + ' file does not exist') |
| |
| if os.path.isfile(db_core_file): |
| log("DB core file " + db_core_file + " file found", 'info') |
| else: |
| log('db_core_file: ' + db_core_file + ' file does not exist','exception') |
| os.sys.exit(1) |
| |
| if os.path.isfile(db_create_user_file): |
| log("DB create user file " + db_create_user_file + " file found", 'info') |
| else: |
| log('db_create_user_file: ' + db_create_user_file + ' file does not exist','exception') |
| os.sys.exit(1) |
| |
| if os.path.isfile(db_audit_file): |
| log("DB audit file " + db_audit_file + " file found", 'info') |
| else: |
| log('db_audit_file: ' + db_audit_file + ' file does not exist','exception') |
| os.sys.exit(1) |
| |
| if os.path.isfile(db_asset_file): |
| log("DB asset file " + db_asset_file + " file found", 'info') |
| else: |
| log('db_asset_file: ' + db_asset_file + ' file does not exist','exception') |
| os.sys.exit(1) |
| |
| def get_mysql_cmd(user, password, host): |
| global conf_dict |
| MYSQL_BIN = conf_dict["MYSQL_BIN"] |
| |
| cmdArr = [ MYSQL_BIN ,'-B' ,'--user=%s' %user, '--password=%s' %password, '--host=%s' %host , '--skip-column-names'] |
| return cmdArr |
| |
| def create_mysql_user(db_name, db_user, db_password, db_host, db_root_password): |
| global conf_dict |
| cmdArr = [] |
| |
| MYSQL_BIN = conf_dict["MYSQL_BIN"] |
| hosts_arr =["%", "localhost"] |
| #check_mysql_password() |
| ### From properties file |
| log("\nCreating MySQL user "+db_user+" (using root priviledges)\n", 'debug') |
| for host in hosts_arr: |
| cmdArr = get_mysql_cmd('root', db_root_password, db_host) |
| #subprocess.call(["mysql", "-u", username, "-p%s" % password, "-e", "SELECT @@hostname"] |
| |
| cmdArr.extend(["-e", "select count(*) from mysql.user where user='%s' and host='%s'" %(db_user, host)]) |
| output = subprocess.check_output(cmdArr) |
| if output.strip("\n\r") is "1": |
| log( "\nMYSQL User already exists!\n", "debug") |
| else: |
| cmdArr = get_mysql_cmd('root', db_root_password, db_host) |
| if db_password == "": |
| #cmdStr = '"' + MYSQL_BIN + '"' + ' -B -u root --password='+db_root_password+' -h '+db_host+' -e \'create user "'+db_user+'"@"'+db_host+'";\'' |
| cmdArr.extend(["-e", "create user %s@%s" %(db_user, host)]) |
| else: |
| cmdArr.extend(["-e", "create user '%s'@'%s' identified by '%s' " %(db_user, host, db_password)]) |
| #cmdStr = '"' + MYSQL_BIN + '"' + ' -B -u root --password='+db_root_password+' -h '+db_host+' -e \'create user "'+db_user+'"@"'+db_host+'" identified by "'+db_password+'";\'' |
| ret = subprocess.check_call(cmdArr) |
| if ret == 0: |
| #mysqlquery="GRANT ALL ON "+db_name+".* TO \'"+db_user+"'@'"+db_host+"' ;\ |
| #grant all privileges on "+db_name+".* to '"+db_user+"'@'"+db_host+"' with grant option;\ |
| #FLUSH PRIVILEGES;" |
| cmdArr = get_mysql_cmd('root', db_root_password, db_host) |
| cmdArr.extend(["-e", "GRANT ALL ON *.* TO '%s'@'%s'; grant all privileges on *.* to '%s'@'%s' with grant option; FLUSH PRIVILEGES" %(db_user,host,db_user,host)]) |
| ret = subprocess.check_call(cmdArr) |
| if ret == 0: |
| log("\nCreating MySQL user '" + db_user + "' (using root priviledges for % hosts ) DONE\n", "info") |
| else: |
| log("\nCreating MySQL user '" + db_user + "' (using root priviledges) FAILED\n", "info") |
| sys.exit(1) |
| |
| def check_mysql_password (): |
| global conf_dict |
| db_root_password = conf_dict["RANGER_ADMIN_DB_ROOT_PASSWORD"] |
| MYSQL_HOST = conf_dict['MYSQL_HOST'] |
| MYSQL_BIN = conf_dict['MYSQL_BIN'] |
| |
| log("Checking MYSQL root password : **** ","debug") |
| |
| cmdStr = "\""+MYSQL_BIN+"\""+" -u root --password="+db_root_password+" -h "+MYSQL_HOST+" -s -e \"select version();\"" |
| status, output = getstatusoutput(cmdStr) |
| print "Status: " + str(status) |
| print "output: " + str(output) |
| |
| if status == 0: |
| log("Checking MYSQL root password DONE", "info") |
| else: |
| log("COMMAND: mysql -u root --password=..... -h " + MYSQL_HOST + " : FAILED with error message:\n*********************************\n" + output + "\n*********************************\n", "exception") |
| sys.exit(1) |
| |
| |
| #def check_mysql_user_password(): |
| # global conf_dict |
| # db_user = conf_dict["RANGER_ADMIN_DB_USERNAME"] |
| # db_password = conf_dict["RANGER_ADMIN_DB_PASSWORD"] |
| # db_root_password = conf_dict["RANGER_ADMIN_DB_ROOT_PASSWORD"] |
| # MYSQL_HOST = conf_dict['MYSQL_HOST'] |
| # |
| # db = MySQLdb.connect(host=MYSQL_HOST, user=db_user, passwd=db_password) |
| # if db: |
| # log("Checking MYSQL "+ db_user +" password DONE", "info") |
| # else: |
| # log("COMMAND: mysql -u " + db_user + " --password=..... -h " + MYSQL_HOST + " : FAILED with error message:\n*********************************\n" + {msg} + "\n*********************************\n", "exception") |
| # |
| #def check_mysql_audit_user_password(): |
| # global conf_dict |
| # audit_db = conf_dict["RANGER_AUDIT_DB_NAME"] |
| # audit_db_user = conf_dict["RANGER_AUDIT_DB_USERNAME"] |
| # audit_db_password = conf_dict["RANGER_AUDIT_DB_PASSWORD"] |
| # MYSQL_HOST = conf_dict['MYSQL_HOST'] |
| # |
| # try: |
| # db = MySQLdb.connect(host=MYSQL_HOST, user=audit_db_user, passwd=audit_db_password, db=audit_db) |
| # except MySQLdb.Error, e: |
| # exceptnMsg = "Error %d: %s" % (e.args[0], e.args[1]) |
| # log("COMMAND: mysql -u " + audit_db_user + " --password=..... -h " + MYSQL_HOST + " : FAILED with error message:\n*********************************\n" + exceptnMsg + "\n*********************************\n", "exception") |
| # sys.exit (1) |
| # if db: |
| # log("Checking Ranger Audit Table owner password DONE", "info") |
| |
| #def exec_sql_file(cursor, sql_file): |
| # log( "[INFO] Executing SQL script file: " + sql_file, "debug") |
| # statement = "" |
| # for line in open(sql_file): |
| # if re.match(r'--', line): # ignore sql comment lines |
| # continue |
| # if not re.search(r'[^-;]+;', line): # keep appending lines that don't end in ';' |
| # statement = statement + line |
| # else: # when you get a line ending in ';' then exec statement and reset for next statement |
| # statement = statement + line |
| # #print "\n\n[DEBUG] Executing SQL statement:\n%s" % (statement) |
| # try: |
| # cursor.execute(statement) |
| # print cursor |
| # except MySQLdb.Error, e: |
| # log( "[WARN] MySQLError during execute statement \n\tArgs: " + str(e.args), "debug") |
| # statement = "" |
| |
| def upgrade_db(): |
| global config_dict |
| |
| db_user = conf_dict["RANGER_ADMIN_DB_USERNAME"] |
| db_password = conf_dict["RANGER_ADMIN_DB_PASSWORD"] |
| db_root_password = conf_dict["RANGER_ADMIN_DB_ROOT_PASSWORD"] |
| db_name = conf_dict["RANGER_ADMIN_DB_NAME"] |
| MYSQL_BIN = conf_dict['MYSQL_BIN'] |
| MYSQL_HOST = conf_dict['RANGER_ADMIN_DB_HOST'] |
| |
| log("\nCreating Baseline DB upgrade ... \n", "debug") |
| DBVERSION_CATALOG_CREATION = os.path.join(conf_dict['RANGER_DB_DIR'], 'create_dbversion_catalog.sql') |
| PATCHES_PATH = os.path.join(conf_dict['RANGER_DB_DIR'], 'patches') |
| if os.path.isfile(DBVERSION_CATALOG_CREATION): |
| #import sql file |
| proc = subprocess.Popen([MYSQL_BIN, "--user=%s" % db_user, "--host=%s" %MYSQL_HOST, "--password=%s" % db_password, db_name], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE) |
| out, err = proc.communicate(file(DBVERSION_CATALOG_CREATION).read()) |
| log("\nBaseline DB upgraded successfully\n", "info") |
| |
| #first get all patches and then apply each patch |
| files = os.listdir(PATCHES_PATH) |
| # files: coming from os.listdir() sorted alphabetically, thus not numerically |
| sorted_files = sorted(files, key=lambda x: str(x.split('.')[0])) |
| for filename in sorted_files: |
| currentPatch = PATCHES_PATH + "/"+filename |
| if os.path.isfile(currentPatch): |
| #apply_patches(cursor,currentPatch) |
| proc = subprocess.Popen([MYSQL_BIN, "--user=%s" % db_user, "--host=%s" %MYSQL_HOST, "--password=%s" % db_password, db_name], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE) |
| out, err = proc.communicate(file(currentPatch).read()) |
| log( "\nPatch applied: " + currentPatch +"\n", "debug") |
| |
| |
| def verify_db (db_user, db_password, db_name, db_host): |
| global conf_dict |
| MYSQL_BIN = conf_dict['MYSQL_BIN'] |
| |
| log("\nVerifying Database: " + db_name+"\n","debug") |
| |
| cmdArr = get_mysql_cmd(db_user, db_password, db_host) |
| cmdArr.extend(["-e", "show databases like '%s'" %(db_name)]) |
| output = subprocess.check_output(cmdArr) |
| if output.strip('\r\n') == db_name: |
| return True |
| else: |
| return False |
| |
| def import_db (): |
| |
| global conf_dict |
| |
| db_user = conf_dict["RANGER_ADMIN_DB_USERNAME"] |
| db_password = conf_dict["RANGER_ADMIN_DB_PASSWORD"] |
| db_root_password = conf_dict["RANGER_ADMIN_DB_ROOT_PASSWORD"] |
| db_name = conf_dict['RANGER_ADMIN_DB_NAME'] |
| MYSQL_HOST = conf_dict['RANGER_ADMIN_DB_HOST'] |
| |
| db_core_file = conf_dict['db_core_file'] |
| db_asset_file = conf_dict['db_asset_file'] |
| MYSQL_BIN = conf_dict['MYSQL_BIN'] |
| log ("\nImporting to Database: " + db_name,"debug"); |
| |
| if verify_db(db_user, db_password, db_name, MYSQL_HOST): |
| log("\nDatabase "+db_name + " already exists. Ignoring import_db\n","info") |
| else: |
| log("\nDatabase does not exist. Creating databse : \n" + db_name,"info") |
| |
| cmdArr = get_mysql_cmd('root', db_root_password, MYSQL_HOST) |
| cmdArr.extend(["-e", "create database %s" %(db_name)]) |
| ret = subprocess.check_call(cmdArr) |
| if ret != 0: |
| log("\nDatabase creation failed!!\n","exception") |
| sys.exit(1) |
| |
| ##execute each line from sql file to import DB |
| if os.path.isfile(db_core_file): |
| log("Importing database : " + db_name + " from file: " + db_core_file,"info") |
| proc = subprocess.Popen([MYSQL_BIN, "--user=%s" % db_user, "--host=%s" %MYSQL_HOST, "--password=%s" % db_password, db_name], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE) |
| out, err = proc.communicate(file(db_core_file).read()) |
| if (proc.returncode == 0): |
| log("\nAdmin db file Imported successfully\n","info") |
| else: |
| log("\nAdmin db file Import failed!\n","info") |
| sys.exit(1) |
| else: |
| log("\nImport sql file not found\n","exception") |
| sys.exit(1) |
| |
| if os.path.isfile(db_asset_file): |
| proc = subprocess.Popen([MYSQL_BIN, "--user=%s" % db_user, "--host=%s" %MYSQL_HOST, "--password=%s" % db_password, db_name], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE) |
| out, err = proc.communicate(file(db_asset_file).read()) |
| if (proc.returncode == 0): |
| log("\nAsset file Imported successfully\n","info") |
| else: |
| log("\nAsset file Import filed!\n","info") |
| sys.exit(1) |
| else: |
| log("\nImport asset sql file not found\n","exception") |
| sys.exit(1) |
| |
| #def extract_war(): |
| # global conf_dict |
| # war_file = conf_dict['war_file'] |
| # WEBAPP_ROOT = conf_dict['WEBAPP_ROOT'] |
| # |
| # if os.path.isfile(war_file): |
| # log("Extract War file " + war_file + " to " + WEBAPP_ROOT,"info") |
| # else: |
| # log(war_file + " file not found!","exception") |
| # |
| # if os.path.isdir(WEBAPP_ROOT): |
| # with zipfile.ZipFile(war_file, "r") as z: |
| # z.extractall(WEBAPP_ROOT) |
| # log("Extract War file " + war_file + " to " + WEBAPP_ROOT + " DONE! ","info") |
| # if os.path.isfile ( os.path.join(WEBAPP_ROOT, "WEB-INF", "log4j.xml.prod")) : |
| # shutil.copyfile(os.path.join(WEBAPP_ROOT, "WEB-INF", "log4j.xml.prod"), os.path.join(WEBAPP_ROOT, "WEB-INF", "log4j.xml")) |
| |
| # def copy_mysql_connector(): |
| # log("Copying MYSQL Connector to "+app_home+"/WEB-INF/lib ","info") |
| # shutil.copyfile(MYSQL_CONNECTOR_JAR, app_home+"/WEB-INF/lib/"+MYSQL_CONNECTOR_JAR) |
| # if os.path.isfile(app_home+"/WEB-INF/lib/"+MYSQL_CONNECTOR_JAR): |
| # log("Copying MYSQL Connector to app_home/WEB-INF/lib DONE","info"); |
| # else: |
| # log("Copying MYSQL Connector to "+app_home+"/WEB-INF/lib failed","exception") |
| |
| |
| #Update Properties to File |
| #1 -> propertyName 2 -> newPropertyValue 3 -> fileName |
| def updatePropertyToFile(propertyName, newPropertyValue, fileName): |
| replaceStr = propertyName +"="+ newPropertyValue |
| log("replaceStr: " + replaceStr, "debug") |
| successMsg = "property : " + propertyName + " not found!" |
| for line in fileinput.input(fileName, inplace = 1): # Does a list of files, and writes redirects STDOUT to the file in question |
| if line.replace(propertyName, replaceStr): |
| successMsg = "File " + fileName + " Updated successfully : "+ propertyName |
| log(successMsg, "info") |
| pass |
| |
| def update_xapolicymgr_properties(): |
| global conf_dict |
| WEBAPP_ROOT = conf_dict['WEBAPP_ROOT'] |
| xapolicymgr_properties = os.path.join(WEBAPP_ROOT, "WEB-INF", "classes", "conf", "ranger_webserver.properties") |
| log("xapolicymgr_properties: " + xapolicymgr_properties, "debug") |
| ModConfig(xapolicymgr_properties,"xa.webapp.dir", WEBAPP_ROOT.replace('\\','/' )) |
| |
| def updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file): |
| ret = subprocess.call(['python', '%s\update_property.py' %os.getenv("RANGER_ADMIN_HOME"), propertyName ,newPropertyValue ,to_file]) |
| if ret == 0: |
| log("Updated property for :"+to_file,"info") |
| else: |
| log("Update property failed for :"+to_file,"info") |
| sys.exit(1) |
| |
| def update_properties(): |
| global conf_dict |
| sys_conf_dict={} |
| |
| RANGER_DB_FLAVOR = conf_dict["RANGER_DB_FLAVOR"] |
| RANGER_AUDIT_DB_FLAVOR = conf_dict["RANGER_DB_FLAVOR"] |
| MYSQL_HOST = conf_dict["RANGER_ADMIN_DB_HOST"] |
| WEBAPP_ROOT = conf_dict["WEBAPP_ROOT"] |
| db_user = conf_dict["RANGER_ADMIN_DB_USERNAME"] |
| db_password = conf_dict["RANGER_ADMIN_DB_PASSWORD"] |
| db_name = conf_dict["RANGER_ADMIN_DB_NAME"] |
| RANGER_ADMIN_DB_PORT = conf_dict["RANGER_ADMIN_DB_PORT"] |
| RANGER_AUDIT_DB_PORT = conf_dict["RANGER_AUDIT_DB_PORT"] |
| |
| audit_db_user = conf_dict["RANGER_AUDIT_DB_USERNAME"] |
| audit_db_password = conf_dict["RANGER_AUDIT_DB_PASSWORD"] |
| audit_db_name = conf_dict["RANGER_AUDIT_DB_NAME"] |
| |
| to_file_ranger = os.path.join(WEBAPP_ROOT, "WEB-INF", "classes", "conf", "ranger-admin-site.xml") |
| newPropertyValue='' |
| to_file_default = os.path.join(WEBAPP_ROOT, "WEB-INF", "classes", "conf", "ranger-admin-default-site.xml") |
| if os.path.isfile(to_file_ranger): |
| log("to_file_ranger: " + to_file_ranger + " file found", "info") |
| else: |
| log("to_file_ranger: " + to_file_ranger + " does not exists", "warning") |
| if os.path.isfile(to_file_default): |
| log("to_file_default: " + to_file_default + " file found", "info") |
| else: |
| log("to_file_default: " + to_file_default + " does not exists", "warning") |
| |
| log("SQL_HOST is : " + MYSQL_HOST,"debug") |
| if RANGER_DB_FLAVOR == "MYSQL": |
| propertyName="ranger.jpa.jdbc.url" |
| newPropertyValue="jdbc:log4jdbc:mysql://%s:%s/%s" %(MYSQL_HOST ,RANGER_ADMIN_DB_PORT, db_name) |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.user" |
| newPropertyValue=db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.user" |
| newPropertyValue=audit_db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.url" |
| newPropertyValue="jdbc:log4jdbc:mysql://%s:%s/%s" %(MYSQL_HOST, RANGER_AUDIT_DB_PORT, audit_db_name) |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.MySQLPlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.audit.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.MySQLPlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.jdbc.driver" |
| newPropertyValue="net.sf.log4jdbc.DriverSpy" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.driver" |
| newPropertyValue="net.sf.log4jdbc.DriverSpy" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| elif RANGER_DB_FLAVOR == "ORACLE": |
| propertyName="ranger.jpa.jdbc.url" |
| #if MYSQL_HOST.count(":") == 2: |
| if MYSQL_HOST.count(":") == 2 or MYSQL_HOST.count(":") == 0: |
| #jdbc:oracle:thin:@[HOST][:PORT]:SID or #jdbc:oracle:thin:@GL |
| cstring="jdbc:oracle:thin:@%s" %(MYSQL_HOST) |
| else: |
| #jdbc:oracle:thin:@//[HOST][:PORT]/SERVICE |
| cstring="jdbc:oracle:thin:@//%s" %(MYSQL_HOST) |
| |
| newPropertyValue=cstring |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.user" |
| newPropertyValue=db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.user" |
| newPropertyValue=audit_db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.url" |
| newPropertyValue=cstring |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.OraclePlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.audit.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.OraclePlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.jdbc.driver" |
| newPropertyValue="oracle.jdbc.OracleDriver" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.driver" |
| newPropertyValue="oracle.jdbc.OracleDriver" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| elif RANGER_DB_FLAVOR == "POSTGRES": |
| propertyName="ranger.jpa.jdbc.url" |
| newPropertyValue="jdbc:postgresql://%s:%s/%s" %(MYSQL_HOST, RANGER_ADMIN_DB_PORT, db_name) |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.user" |
| newPropertyValue=db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.user" |
| newPropertyValue=audit_db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.url" |
| newPropertyValue="jdbc:postgresql://%s:%s/%s" %(MYSQL_HOST, RANGER_AUDIT_DB_PORT, audit_db_name) |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.PostgreSQLPlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.audit.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.PostgreSQLPlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.jdbc.driver" |
| newPropertyValue="org.postgresql.Driver" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.driver" |
| newPropertyValue="org.postgresql.Driver" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| |
| elif RANGER_DB_FLAVOR == "MSSQL": |
| propertyName="ranger.jpa.jdbc.url" |
| newPropertyValue="jdbc:sqlserver://%s:%s;databaseName=%s" %(MYSQL_HOST, RANGER_ADMIN_DB_PORT, db_name) |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.user" |
| newPropertyValue=db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.user" |
| newPropertyValue=audit_db_user |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.url" |
| newPropertyValue="jdbc:sqlserver://%s:%s;databaseName=%s" % (MYSQL_HOST, RANGER_AUDIT_DB_PORT, audit_db_name) |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.SQLServerPlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.audit.jdbc.dialect" |
| newPropertyValue="org.eclipse.persistence.platform.database.SQLServerPlatform" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.jdbc.driver" |
| newPropertyValue="com.microsoft.sqlserver.jdbc.SQLServerDriver" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.driver" |
| newPropertyValue="com.microsoft.sqlserver.jdbc.SQLServerDriver" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| if (os.path.isfile(os.getenv("RANGER_ADMIN_CRED_KEYSTORE_FILE"))): |
| propertyName="ranger.credential.provider.path" |
| newPropertyValue=os.getenv("RANGER_ADMIN_CRED_KEYSTORE_FILE") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.jdbc.credential.alias" |
| newPropertyValue="ranger.jpa.jdbc.password" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.credential.provider.path" |
| newPropertyValue=os.getenv("RANGER_ADMIN_CRED_KEYSTORE_FILE") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.jdbc.password" |
| newPropertyValue="_" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.credential.alias" |
| newPropertyValue="ranger.jpa.audit.jdbc.password" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_default) |
| |
| propertyName="ranger.jpa.audit.jdbc.password" |
| newPropertyValue="_" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| else: |
| propertyName="ranger.jpa.jdbc.password" |
| newPropertyValue=os.getenv("RANGER_ADMIN_DB_PASSWORD") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.jpa.audit.jdbc.password" |
| newPropertyValue=os.getenv("RANGER_AUDIT_DB_PASSWORD") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| if os.getenv("RANGER_AUTHENTICATION_METHOD") == "LDAP": |
| |
| password_validation(os.getenv("RANGER_LDAP_BIND_PASSWORD"), "LDAP_BIND") |
| |
| propertyName="ranger.authentication.method" |
| newPropertyValue=os.getenv("RANGER_AUTHENTICATION_METHOD") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.url" |
| newPropertyValue=os.getenv("RANGER_LDAP_URL") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.user.dnpattern" |
| newPropertyValue=os.getenv("RANGER_LDAP_USERDNPATTERN") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.group.searchbase" |
| newPropertyValue=os.getenv("RANGER_LDAP_GROUPSEARCHBASE") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.group.searchfilter" |
| newPropertyValue=os.getenv("RANGER_LDAP_GROUPSEARCHFILTER") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.group.roleattribute" |
| newPropertyValue=os.getenv("RANGER_LDAP_GROUPROLEATTRIBUTE") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.base.dn" |
| newPropertyValue=os.getenv("RANGER_LDAP_BASE_DN") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.bind.dn" |
| newPropertyValue=os.getenv("RANGER_LDAP_BIND_DN") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.bind.password" |
| newPropertyValue="_" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.referral" |
| newPropertyValue=os.getenv("RANGER_LDAP_REFERRAL") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.user.searchfilter" |
| newPropertyValue=os.getenv("RANGER_LDAP_USERSEARCHFILTER") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| elif os.getenv("RANGER_AUTHENTICATION_METHOD") == "ACTIVE_DIRECTORY": |
| |
| password_validation(os.getenv("RANGER_LDAP_AD_BIND_PASSWORD"), "AD_BIND") |
| |
| propertyName="ranger.authentication.method" |
| newPropertyValue=os.getenv("RANGER_AUTHENTICATION_METHOD") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.domain" |
| newPropertyValue=os.getenv("RANGER_LDAP_AD_DOMAIN") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.url" |
| newPropertyValue=os.getenv("RANGER_LDAP_AD_URL") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.base.dn" |
| newPropertyValue=os.getenv("RANGER_LDAP_AD_BASE_DN") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.bind.dn" |
| newPropertyValue=os.getenv("RANGER_LDAP_AD_BIND_DN") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.bind.password" |
| newPropertyValue="_" |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.referral" |
| newPropertyValue=os.getenv("RANGER_LDAP_AD_REFERRAL") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| propertyName="ranger.ldap.ad.user.searchfilter" |
| newPropertyValue=os.getenv("RANGER_LDAP_AD_USERSEARCHFILTER") |
| updatePropertyToFilePy(propertyName ,newPropertyValue ,to_file_ranger) |
| |
| def setup_authentication(authentication_method, xmlPath): |
| if authentication_method == "UNIX": |
| # log("Setting up UNIX authentication for : " + xmlPath,"debug") |
| # appContextPath = xmlPath + "/META-INF/security-applicationContext.xml" |
| # beanSettingPath = xmlPath + "/META-INF/contextXML/unix_bean_settings.xml" |
| # secSettingPath = xmlPath + "/META-INF/contextXML/unix_security_settings.xml" |
| # ## Logic is to find UNIX_BEAN_SETTINGS_START,UNIX_SEC_SETTINGS_START from appContext xml file and append |
| # ## the xml properties from unix bean settings file |
| # if os.path.isfile(appContextPath) and os.path.isfile(unixSettingPath): |
| # beanStrToBeAppended = open(beanSettingPath).read() |
| # secStrToBeAppended = open(secSettingPath).read() |
| # fileObj = open(appContextPath) |
| # for line in fileObj.read().split(';\n'): |
| # beanLineToAppend = line.match("UNIX_BEAN_SETTINGS_START") |
| # beanLineToAppend.apend(beanStrToBeAppended) |
| # secLineToAppend = line.match("UNIX_SEC_SETTINGS_START") |
| # secLineToAppend.append(secStrToBeAppended) |
| # |
| # fileObj.close() |
| # sys.exit(0); |
| pass |
| elif authentication_method == "LDAP": |
| log("Setting up authentication for : " + xmlPath,"debug") |
| |
| log("Setting up "+authentication_method+" authentication for : " + xmlPath,"debug") |
| |
| appContextPath = os.path.join(xmlPath, "WEB-INF", "classes", "conf", "security-applicationContext.xml") |
| beanSettingPath = os.path.join(xmlPath, "META-INF","contextXML","ldap_bean_settings.xml") |
| secSettingPath = os.path.join(xmlPath , "META-INF","contextXML","ldap_security_settings.xml") |
| ## Logic is to find LDAP_BEAN_SETTINGS_START,LDAP_SEC_SETTINGS_START from appContext xml file and append |
| ## the xml properties from unix bean settings file |
| if os.path.isfile(appContextPath) and os.path.isfile(beanSettingPath): |
| beanStrToBeAppended = open(beanSettingPath).read() |
| secStrToBeAppended = open(secSettingPath).read() |
| fileObj = open(appContextPath) |
| data = '' |
| for line in fileObj.read().split('\n'): |
| if ("LDAP_BEAN_SETTINGS_START") in line: |
| line = line + '\n' + beanStrToBeAppended |
| if ("LDAP_SEC_SETTINGS_START") in line: |
| line = line + '\n' + secStrToBeAppended |
| if data == '': |
| data = line |
| else: |
| data = data + '\n' + line |
| fileObj.close() |
| |
| fileObj = open(appContextPath,'w') |
| fileObj.writelines(data) |
| fileObj.close() |
| |
| elif authentication_method == "ACTIVE_DIRECTORY": |
| log("Setting up "+authentication_method+" authentication for : " + xmlPath,"debug") |
| appContextPath = os.path.join(xmlPath, "WEB-INF", "classes", "conf", "security-applicationContext.xml") |
| beanSettingPath = os.path.join(xmlPath , "META-INF","contextXML","ad_bean_settings.xml") |
| secSettingPath = os.path.join(xmlPath , "META-INF","contextXML","ad_security_settings.xml") |
| |
| ## Logic is to find AD_BEAN_SETTINGS_START,AD_SEC_SETTINGS_START from appContext xml file and append |
| ## the xml properties from unix bean settings file |
| if os.path.isfile(appContextPath) and os.path.isfile(beanSettingPath): |
| beanStrToBeAppended = open(beanSettingPath).read() |
| secStrToBeAppended = open(secSettingPath).read() |
| fileObj = open(appContextPath) |
| data = '' |
| for line in fileObj.read().split('\n'): |
| if ("AD_BEAN_SETTINGS_START") in line : |
| line = line + '\n'+ beanStrToBeAppended |
| if ("AD_SEC_SETTINGS_START") in line: |
| line = line + '\n' + secStrToBeAppended |
| if data == '': |
| data = line |
| else: |
| data = data + '\n' + line |
| fileObj.close() |
| |
| fileObj = open(appContextPath,'w') |
| fileObj.writelines(data) |
| fileObj.close() |
| |
| elif authentication_method == "NONE": |
| log("Authentication Method: "+authentication_method+" authentication for : " + xmlPath,"debug") |
| #pass |
| # |
| def do_authentication_setup(): |
| global conf_dict |
| webappRoot = conf_dict['WEBAPP_ROOT'] |
| sys_conf_dict={} |
| # ##Written new function to perform authentication setup for all cases |
| authentication_method = conf_dict['RANGER_AUTHENTICATION_METHOD'] |
| log("Starting setup based on user authentication method = " + authentication_method,"debug") |
| setup_authentication(authentication_method, webappRoot) |
| # ldap_file= os.path.join(webappRoot ,"WEB-INF","resources","xa_ldap.properties") |
| ldap_file= os.path.join(webappRoot, "WEB-INF", "classes", "conf", "xa_ldap.properties") |
| if os.path.isfile(ldap_file): |
| log(ldap_file + " file found", "info") |
| else: |
| log(ldap_file + " does not exists", "warning") |
| """ |
| config = StringIO.StringIO() |
| config.write('[LDAP_AD_CONF]\n') |
| config.write(open(ldap_file).read()) |
| config.seek(0, os.SEEK_SET) |
| ##Now parse using configparser |
| cObj = ConfigParser.ConfigParser() |
| cObj.optionxform = str |
| cObj.readfp(config) |
| options = cObj.options('LDAP_AD_CONF') |
| for option in options: |
| value = cObj.get('LDAP_AD_CONF', option) |
| sys_conf_dict[option] = value |
| cObj.set("LDAP_AD_CONF",option, value) |
| log("LDAP file : "+ ldap_file + " file found", "info") |
| """ |
| if authentication_method == "LDAP": |
| log("Loading LDAP attributes and properties", "debug"); |
| newPropertyValue='' |
| ########## |
| propertyName="xa_ldap_url" |
| newPropertyValue=conf_dict['RANGER_LDAP_URL'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="xa_ldap_userDNpattern" |
| newPropertyValue=conf_dict['RANGER_LDAP_USERDNPATTERN'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="xa_ldap_groupSearchBase" |
| newPropertyValue=conf_dict['RANGER_LDAP_GROUPSEARCHBASE'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="xa_ldap_groupSearchFilter" |
| newPropertyValue=conf_dict['RANGER_LDAP_GROUPSEARCHFILTER'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="xa_ldap_groupRoleAttribute" |
| newPropertyValue=conf_dict['RANGER_ldap_GROUPROLEATTRIBUTE'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="authentication_method" |
| newPropertyValue=authentication_method |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| else: |
| log( "LDAP file: "+ ldap_file +" does not exists","exception") |
| if authentication_method == "ACTIVE_DIRECTORY": |
| log("[I] Loading ACTIVE DIRECTORY attributes and properties", "debug") |
| newPropertyValue='' |
| ldap_file= os.path.join(webappRoot, "WEB-INF", "classes", "conf", "xa_ldap.properties") |
| if os.path.isfile(ldap_file): |
| log("LDAP file : "+ ldap_file + " file found", "info") |
| propertyName="xa_ldap_ad_url" |
| newPropertyValue=conf_dict['RANGER_LDAP_AD_URL'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="xa_ldap_ad_domain" |
| newPropertyValue=conf_dict['RANGER_LDAP_AD_DOMAIN'] |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| ########### |
| propertyName="authentication_method" |
| newPropertyValue=authentication_method |
| # cObj.set('LDAP_AD_CONF',propertyName,newPropertyValue) |
| ModConfig(ldap_file,propertyName,newPropertyValue) |
| else: |
| log(ldap_file + " does not exists", "exception") |
| |
| # with open(ldap_file, 'wb') as configfile: |
| # cObj.write(configfile) |
| # |
| # #if authentication_method == "UNIX": |
| # ## I think it is not needed for Windows |
| # ##do_unixauth_setup |
| # log("Finished setup based on user authentication method=authentication_method", "info") |
| #pass |
| |
| def setup_audit_user_db(): |
| global conf_dict |
| |
| MYSQL_BIN = conf_dict['MYSQL_BIN'] |
| MYSQL_HOST = conf_dict['RANGER_AUDIT_DB_HOST'] |
| |
| db_root_password = conf_dict["RANGER_AUDIT_DB_ROOT_PASSWORD"] |
| audit_db_user = conf_dict["RANGER_AUDIT_DB_USERNAME"] |
| audit_db_password = conf_dict["RANGER_AUDIT_DB_PASSWORD"] |
| audit_db_name = conf_dict['RANGER_AUDIT_DB_NAME'] |
| db_audit_file = conf_dict['db_audit_file'] |
| |
| #check_mysql_audit_user_password() |
| log("\n--------- Creating mysql audit user --------- \n","info") |
| create_mysql_user(audit_db_name, audit_db_user, audit_db_password, MYSQL_HOST, db_root_password) |
| log("\n--------- Creating mysql audit user DONE----- \n","info") |
| |
| log("\n--------- Importing Audit Database ---------\n","info") |
| # Verify if audit db is present |
| if verify_db(audit_db_user, audit_db_password, audit_db_name, MYSQL_HOST): |
| log("\nDatabase "+audit_db_name + " already exists. Ignoring import_db\n","info") |
| else: |
| log("\nCreating Database " + audit_db_name, "info") |
| # Create audit db is not present |
| cmdArr = get_mysql_cmd('root', db_root_password, MYSQL_HOST) |
| cmdArr.extend(["-e", "create database %s" %(audit_db_name)]) |
| ret = subprocess.check_call(cmdArr) |
| if ret != 0: |
| log("Database creation failed!!","error") |
| sys.exit(1) |
| else: |
| log("Creating database "+audit_db_name+" succeeded", "info") |
| # Check if audit table exists |
| AUDIT_TABLE="xa_access_audit" |
| log("Verifying table "+AUDIT_TABLE+" in audit database "+audit_db_name, "debug") |
| |
| cmdArr = get_mysql_cmd(audit_db_user, audit_db_password, MYSQL_HOST) |
| cmdArr.extend([audit_db_name, "-e", "show tables like '%s'" %(AUDIT_TABLE)]) |
| output = subprocess.check_output(cmdArr) |
| if output.strip('\r\n') != AUDIT_TABLE: |
| # Import audit table |
| log("\nImporting Audit Database file: " + db_audit_file,"debug") |
| if os.path.isfile(db_audit_file): |
| proc = subprocess.Popen([MYSQL_BIN, "--user=%s" % audit_db_user, "--host=%s" %MYSQL_HOST, "--password=%s" % audit_db_password, audit_db_name], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE) |
| out, err = proc.communicate(file(db_audit_file).read()) |
| if (proc.returncode == 0): |
| log("\nAudit file Imported successfully\n","info") |
| else: |
| log("\nAudit file Import failed!\n","info") |
| sys.exit(1) |
| else: |
| log("\nAudit file not found!\n","info") |
| |
| else: |
| log("\nTable "+AUDIT_TABLE+" already exists in audit database "+audit_db_name +"\n","info") |
| |
| log("\n--------- Importing Audit Database DONE-----\n","info") |
| |
| |
| def setup_admin_db_user(): |
| global conf_dict |
| |
| MYSQL_HOST = conf_dict['RANGER_ADMIN_DB_HOST'] |
| |
| db_user = conf_dict["RANGER_ADMIN_DB_USERNAME"] |
| db_password = conf_dict["RANGER_ADMIN_DB_PASSWORD"] |
| db_root_password = conf_dict["RANGER_ADMIN_DB_ROOT_PASSWORD"] |
| db_name = conf_dict['RANGER_ADMIN_DB_NAME'] |
| |
| log("--------- Creating mysql user --------- ","info") |
| create_mysql_user(db_name, db_user, db_password, MYSQL_HOST, db_root_password) |
| #log("--------- Creating mysql user DONE----- ","info") |
| |
| #log("--------- Importing Admin Database --------- ","info") |
| import_db() |
| #log("--------- Importing Admin Database DONE----- ","info") |
| #log("--------- Applying patches --------------- ","info") |
| upgrade_db() |
| #log("--------- Applying patches DONE----------- ","info") |
| |
| |
| ## Ranger Functions Ends here -------------------- |
| |
| |
| def call_keystore(libpath,aliasKey,aliasValue , filepath,getorcreate): |
| finalLibPath = libpath.replace('\\','/').replace('//','/') |
| finalFilePath = 'jceks://file/'+filepath.replace('\\','/').replace('//','/') |
| if getorcreate == 'create': |
| commandtorun = ['java', '-cp', finalLibPath, 'org.apache.ranger.credentialapi.buildks' ,'create', aliasKey, '-value', aliasValue, '-provider',finalFilePath] |
| p = Popen(commandtorun,stdin=PIPE, stdout=PIPE, stderr=PIPE) |
| output, error = p.communicate() |
| statuscode = p.returncode |
| return statuscode |
| elif getorcreate == 'get': |
| commandtorun = ['java', '-cp', finalLibPath, 'org.apache.ranger.credentialapi.buildks' ,'get', aliasKey, '-provider',finalFilePath] |
| p = Popen(commandtorun,stdin=PIPE, stdout=PIPE, stderr=PIPE) |
| output, error = p.communicate() |
| statuscode = p.returncode |
| return statuscode, output |
| else: |
| print 'proper command not received for input need get or create' |
| |
| |
| # Entry point to script using --service |
| def run_setup(cmd): |
| init_logfiles() |
| log("--------- Running Ranger PolicyManager Install Script ---------","debug") |
| #parse_config_file() |
| init_variables("service") |
| setup_install_files() |
| write_config_to_file() |
| #extract_war() |
| update_properties() |
| #do_authentication_setup() |
| return |
| |
| # Entry point to script using --configure |
| def configure(): |
| init_logfiles() |
| log("--------- Running Ranger PolicyManager Configure Script --------- ","info") |
| #parse_config_file() |
| init_variables("configure") |
| sanity_check_configure_files() |
| #log(" --------- Importing DB --------- ","info") |
| # copy_mysql_connector() |
| #log(" --------- Creatin Audit DB --------- ","info") |
| setup_admin_db_user() |
| setup_audit_user_db() |
