|
|
|
|
@ -111,9 +111,20 @@ def check_dependencies():
|
|
|
|
|
if (host_platform == 'windows'):
|
|
|
|
|
checksResult.append(check_nodejs())
|
|
|
|
|
|
|
|
|
|
if (config.option("sql-type") == 'mysql' and host_platform == 'windows'):
|
|
|
|
|
print('\n=== Database Check ===')
|
|
|
|
|
sql_type = config.option("sql-type")
|
|
|
|
|
print('SQL type: ' + sql_type)
|
|
|
|
|
print('Host platform: ' + host_platform)
|
|
|
|
|
print('DB host: ' + config.option("db-host"))
|
|
|
|
|
print('DB port: ' + config.option("db-port"))
|
|
|
|
|
print('DB name: ' + config.option("db-name"))
|
|
|
|
|
print('DB user: ' + config.option("db-user"))
|
|
|
|
|
|
|
|
|
|
if (sql_type == 'mysql' and host_platform == 'windows'):
|
|
|
|
|
print('\nCalling check_mysqlServer()...')
|
|
|
|
|
checksResult.append(check_mysqlServer())
|
|
|
|
|
else:
|
|
|
|
|
print('\nCalling check_postgreSQL()...')
|
|
|
|
|
checksResult.append(check_postgreSQL())
|
|
|
|
|
|
|
|
|
|
server_addons = []
|
|
|
|
|
@ -300,9 +311,88 @@ def check_rabbitmq():
|
|
|
|
|
print('RabbitMQ is installed')
|
|
|
|
|
return dependence
|
|
|
|
|
elif (host_platform == 'linux'):
|
|
|
|
|
result = base.run_command('service rabbitmq-server status')['stdout']
|
|
|
|
|
# Try service command first
|
|
|
|
|
command_result = base.run_command('service rabbitmq-server status')
|
|
|
|
|
result = command_result['stdout']
|
|
|
|
|
|
|
|
|
|
# Log command results
|
|
|
|
|
print('Checking RabbitMQ with service command...')
|
|
|
|
|
print('Command: service rabbitmq-server status')
|
|
|
|
|
print('stdout: ' + (result if result else '[EMPTY]'))
|
|
|
|
|
if command_result['stderr']:
|
|
|
|
|
print('stderr: ' + command_result['stderr'])
|
|
|
|
|
print('Return code: ' + str(command_result['returncode']))
|
|
|
|
|
|
|
|
|
|
# If service command failed or returned empty, try systemctl
|
|
|
|
|
if (result == '' or command_result['returncode'] != 0):
|
|
|
|
|
print('\nTrying systemctl command...')
|
|
|
|
|
systemctl_result = base.run_command('systemctl status rabbitmq-server')
|
|
|
|
|
print('Command: systemctl status rabbitmq-server')
|
|
|
|
|
print('stdout: ' + (systemctl_result['stdout'] if systemctl_result['stdout'] else '[EMPTY]'))
|
|
|
|
|
if systemctl_result['stderr']:
|
|
|
|
|
print('stderr: ' + systemctl_result['stderr'])
|
|
|
|
|
print('Return code: ' + str(systemctl_result['returncode']))
|
|
|
|
|
|
|
|
|
|
# Update result if systemctl worked
|
|
|
|
|
if systemctl_result['stdout']:
|
|
|
|
|
result = systemctl_result['stdout']
|
|
|
|
|
command_result = systemctl_result
|
|
|
|
|
|
|
|
|
|
# If still no result, try direct process check
|
|
|
|
|
if (result == ''):
|
|
|
|
|
print('\nTrying direct process check...')
|
|
|
|
|
ps_result = base.run_command('ps aux | grep -i rabbitmq | grep -v grep')
|
|
|
|
|
print('Command: ps aux | grep -i rabbitmq | grep -v grep')
|
|
|
|
|
print('stdout: ' + (ps_result['stdout'] if ps_result['stdout'] else '[EMPTY]'))
|
|
|
|
|
print('Return code: ' + str(ps_result['returncode']))
|
|
|
|
|
|
|
|
|
|
# Check if rabbitmq process is running
|
|
|
|
|
if ps_result['stdout']:
|
|
|
|
|
result = ps_result['stdout']
|
|
|
|
|
print('RabbitMQ process found: ' + result[:100] + '...' if len(result) > 100 else result)
|
|
|
|
|
|
|
|
|
|
# Additional diagnostic checks
|
|
|
|
|
if (result == ''):
|
|
|
|
|
print('\nPerforming additional diagnostic checks...')
|
|
|
|
|
|
|
|
|
|
# Check current user
|
|
|
|
|
whoami_result = base.run_command('whoami')
|
|
|
|
|
print('Current user: ' + whoami_result['stdout'])
|
|
|
|
|
|
|
|
|
|
# Check for RabbitMQ binaries
|
|
|
|
|
which_result = base.run_command('which rabbitmqctl')
|
|
|
|
|
if which_result['stdout']:
|
|
|
|
|
print('RabbitMQ binary found at: ' + which_result['stdout'])
|
|
|
|
|
|
|
|
|
|
# Try rabbitmqctl status
|
|
|
|
|
rabbitmqctl_result = base.run_command('rabbitmqctl status')
|
|
|
|
|
print('\nTrying rabbitmqctl status...')
|
|
|
|
|
print('stdout: ' + (rabbitmqctl_result['stdout'][:200] + '...' if len(rabbitmqctl_result['stdout']) > 200 else rabbitmqctl_result['stdout']))
|
|
|
|
|
if rabbitmqctl_result['stderr']:
|
|
|
|
|
print('stderr: ' + rabbitmqctl_result['stderr'])
|
|
|
|
|
else:
|
|
|
|
|
print('RabbitMQ binary (rabbitmqctl) not found in PATH')
|
|
|
|
|
|
|
|
|
|
# Check for permission issues
|
|
|
|
|
if (command_result['returncode'] == 126):
|
|
|
|
|
print('\nPermission denied error (code 126).')
|
|
|
|
|
print('You may need to run this script with elevated privileges (sudo).')
|
|
|
|
|
elif (command_result['returncode'] == 127):
|
|
|
|
|
print('\nCommand not found error (code 127).')
|
|
|
|
|
print('The service command may not be available or RabbitMQ may not be installed.')
|
|
|
|
|
elif (command_result['returncode'] == 1):
|
|
|
|
|
print('\nService command failed (code 1).')
|
|
|
|
|
print('This could mean RabbitMQ service is not installed or not running.')
|
|
|
|
|
|
|
|
|
|
# Check common RabbitMQ installation paths
|
|
|
|
|
print('\nChecking common RabbitMQ paths...')
|
|
|
|
|
common_paths = ['/usr/lib/rabbitmq', '/opt/rabbitmq', '/etc/rabbitmq', '/var/lib/rabbitmq']
|
|
|
|
|
for path in common_paths:
|
|
|
|
|
if base.is_dir(path):
|
|
|
|
|
print('Found RabbitMQ directory: ' + path)
|
|
|
|
|
|
|
|
|
|
if (result != ''):
|
|
|
|
|
print('Installed RabbitMQ is valid')
|
|
|
|
|
print('\nInstalled RabbitMQ is valid')
|
|
|
|
|
return dependence
|
|
|
|
|
|
|
|
|
|
print('RabbitMQ not found')
|
|
|
|
|
@ -512,34 +602,61 @@ def check_mysqlServer():
|
|
|
|
|
base.print_info('Check MySQL Server')
|
|
|
|
|
dependence = CDependencies()
|
|
|
|
|
mysqlLoginSrt = get_mysqlLoginString()
|
|
|
|
|
print('MySQL login string: ' + mysqlLoginSrt)
|
|
|
|
|
connectionString = mysqlLoginSrt + ' -e "SHOW GLOBAL VARIABLES LIKE ' + r"'PORT';" + '"'
|
|
|
|
|
print('Connection string: ' + connectionString)
|
|
|
|
|
|
|
|
|
|
if (host_platform != 'windows'):
|
|
|
|
|
print('\nTesting MySQL connection...')
|
|
|
|
|
result = os.system(mysqlLoginSrt + ' -e "exit"')
|
|
|
|
|
print('Connection test result code: ' + str(result))
|
|
|
|
|
|
|
|
|
|
if (result == 0):
|
|
|
|
|
connectionResult = base.run_command(connectionString)['stdout']
|
|
|
|
|
if (connectionResult.find('port') != -1 and connectionResult.find(config.option("db-port")) != -1):
|
|
|
|
|
connectionResult = base.run_command(connectionString)
|
|
|
|
|
print('Port check stdout: ' + connectionResult['stdout'])
|
|
|
|
|
if connectionResult['stderr']:
|
|
|
|
|
print('Port check stderr: ' + connectionResult['stderr'])
|
|
|
|
|
|
|
|
|
|
expected_port = config.option("db-port")
|
|
|
|
|
print('Expected port: ' + expected_port)
|
|
|
|
|
|
|
|
|
|
if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
|
|
|
|
|
print('MySQL configuration is valid')
|
|
|
|
|
dependence.sqlPath = 'mysql'
|
|
|
|
|
return dependence
|
|
|
|
|
else:
|
|
|
|
|
print('Port not found or does not match. Found: ' + connectionResult['stdout'])
|
|
|
|
|
else:
|
|
|
|
|
print('MySQL connection failed with code: ' + str(result))
|
|
|
|
|
print('Valid MySQL Server not found')
|
|
|
|
|
dependence.append_install('MySQLServer')
|
|
|
|
|
dependence.append_uninstall('mysql-server')
|
|
|
|
|
return dependence
|
|
|
|
|
|
|
|
|
|
arrInfo = get_mysqlServersInfo()
|
|
|
|
|
print('\nFound MySQL installations: ' + str(len(arrInfo)))
|
|
|
|
|
for info in arrInfo:
|
|
|
|
|
print('\nChecking MySQL at: ' + info['Location'])
|
|
|
|
|
if (base.is_dir(info['Location']) == False):
|
|
|
|
|
print('Directory does not exist, skipping...')
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
|
|
mysql_full_name = 'MySQL Server ' + info['Version'] + ' '
|
|
|
|
|
mysql_bin_path = get_mysql_path_to_bin(info['Location'])
|
|
|
|
|
print('MySQL bin path: ' + mysql_bin_path)
|
|
|
|
|
|
|
|
|
|
connectionResult = base.run_command_in_dir(get_mysql_path_to_bin(info['Location']), connectionString)['stdout']
|
|
|
|
|
if (connectionResult.find('port') != -1 and connectionResult.find(config.option("db-port")) != -1):
|
|
|
|
|
connectionResult = base.run_command_in_dir(mysql_bin_path, connectionString)
|
|
|
|
|
print('Connection result stdout: ' + connectionResult['stdout'])
|
|
|
|
|
if connectionResult['stderr']:
|
|
|
|
|
print('Connection result stderr: ' + connectionResult['stderr'])
|
|
|
|
|
print('Return code: ' + str(connectionResult['returncode']))
|
|
|
|
|
|
|
|
|
|
expected_port = config.option("db-port")
|
|
|
|
|
if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
|
|
|
|
|
print(mysql_full_name + 'configuration is valid')
|
|
|
|
|
dependence.sqlPath = info['Location']
|
|
|
|
|
return dependence
|
|
|
|
|
print(mysql_full_name + 'configuration is not valid:' + connectionResult)
|
|
|
|
|
print(mysql_full_name + 'configuration is not valid. Expected port: ' + expected_port)
|
|
|
|
|
# if path exists, then further removal and installation fails(according to startup statistics). it is better to fix issue manually.
|
|
|
|
|
return dependence
|
|
|
|
|
|
|
|
|
|
@ -632,8 +749,9 @@ def get_postrgre_path_to_bin(postgrePath = ''):
|
|
|
|
|
return postgrePath
|
|
|
|
|
def get_postgreLoginSrting(userName):
|
|
|
|
|
if (host_platform == 'windows'):
|
|
|
|
|
return 'psql -U' + userName + ' '
|
|
|
|
|
return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U' + userName + ' -hlocalhost '
|
|
|
|
|
# Note: PGPASSWORD should be set as environment variable on Windows
|
|
|
|
|
return 'psql -U ' + userName + ' -h localhost '
|
|
|
|
|
return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U ' + userName + ' -h localhost '
|
|
|
|
|
def get_postgreSQLInfoByFlag(flag):
|
|
|
|
|
arrInfo = []
|
|
|
|
|
|
|
|
|
|
@ -663,13 +781,25 @@ def check_postgreSQL():
|
|
|
|
|
dependence = CDependencies()
|
|
|
|
|
|
|
|
|
|
postgreLoginSrt = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
|
|
|
|
|
print('PostgreSQL login string: ' + postgreLoginSrt)
|
|
|
|
|
connectionString = postgreLoginSrt + ' -c "SELECT setting FROM pg_settings WHERE name = ' + "'port'" + ';"'
|
|
|
|
|
print('Connection string: ' + connectionString)
|
|
|
|
|
|
|
|
|
|
if (host_platform == 'linux'):
|
|
|
|
|
print('\nTesting PostgreSQL connection...')
|
|
|
|
|
result = os.system(postgreLoginSrt + ' -c "\q"')
|
|
|
|
|
connectionResult = base.run_command(connectionString)['stdout']
|
|
|
|
|
print('Connection test result code: ' + str(result))
|
|
|
|
|
|
|
|
|
|
connectionResult = base.run_command(connectionString)
|
|
|
|
|
print('Port check stdout: ' + connectionResult['stdout'])
|
|
|
|
|
if connectionResult['stderr']:
|
|
|
|
|
print('Port check stderr: ' + connectionResult['stderr'])
|
|
|
|
|
print('Port check return code: ' + str(connectionResult['returncode']))
|
|
|
|
|
|
|
|
|
|
expected_port = config.option("db-port")
|
|
|
|
|
print('Expected port: ' + expected_port)
|
|
|
|
|
|
|
|
|
|
if (result != 0 or connectionResult.find(config.option("db-port")) == -1):
|
|
|
|
|
if (result != 0 or connectionResult['stdout'].find(expected_port) == -1):
|
|
|
|
|
print('Valid PostgreSQL not found!')
|
|
|
|
|
dependence.append_install('PostgreSQL')
|
|
|
|
|
dependence.append_uninstall('PostgreSQL')
|
|
|
|
|
@ -679,19 +809,33 @@ def check_postgreSQL():
|
|
|
|
|
return dependence
|
|
|
|
|
|
|
|
|
|
arrInfo = get_postgreSQLInfo()
|
|
|
|
|
base.set_env('PGPASSWORD', config.option("db-pass"))
|
|
|
|
|
print('\nFound PostgreSQL installations: ' + str(len(arrInfo)))
|
|
|
|
|
db_pass = config.option("db-pass")
|
|
|
|
|
print('Setting PGPASSWORD environment variable')
|
|
|
|
|
base.set_env('PGPASSWORD', db_pass)
|
|
|
|
|
|
|
|
|
|
for info in arrInfo:
|
|
|
|
|
print('\nChecking PostgreSQL at: ' + info['Location'])
|
|
|
|
|
if (base.is_dir(info['Location']) == False):
|
|
|
|
|
print('Directory does not exist, skipping...')
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
|
|
postgre_full_name = 'PostgreSQL ' + info['Version'][:2] + ' '
|
|
|
|
|
connectionResult = base.run_command_in_dir(get_postrgre_path_to_bin(info['Location']), connectionString)['stdout']
|
|
|
|
|
|
|
|
|
|
if (connectionResult.find(config.option("db-port")) != -1):
|
|
|
|
|
postgre_bin_path = get_postrgre_path_to_bin(info['Location'])
|
|
|
|
|
print('PostgreSQL bin path: ' + postgre_bin_path)
|
|
|
|
|
|
|
|
|
|
connectionResult = base.run_command_in_dir(postgre_bin_path, connectionString)
|
|
|
|
|
print('Connection result stdout: ' + connectionResult['stdout'])
|
|
|
|
|
if connectionResult['stderr']:
|
|
|
|
|
print('Connection result stderr: ' + connectionResult['stderr'])
|
|
|
|
|
print('Return code: ' + str(connectionResult['returncode']))
|
|
|
|
|
|
|
|
|
|
expected_port = config.option("db-port")
|
|
|
|
|
if (connectionResult['stdout'].find(expected_port) != -1):
|
|
|
|
|
print(postgre_full_name + 'configuration is valid')
|
|
|
|
|
dependence.sqlPath = info['Location']
|
|
|
|
|
return dependence
|
|
|
|
|
print(postgre_full_name + 'configuration is not valid')
|
|
|
|
|
print(postgre_full_name + 'configuration is not valid. Expected port: ' + expected_port)
|
|
|
|
|
|
|
|
|
|
print('Valid PostgreSQL not found')
|
|
|
|
|
|
|
|
|
|
@ -704,61 +848,196 @@ def check_postgreSQL():
|
|
|
|
|
return dependence
|
|
|
|
|
def check_postgreConfig(postgrePath = ''):
|
|
|
|
|
result = True
|
|
|
|
|
base.print_info('Checking PostgreSQL configuration')
|
|
|
|
|
|
|
|
|
|
if (host_platform == 'windows'):
|
|
|
|
|
print('Setting PGPASSWORD for Windows')
|
|
|
|
|
base.set_env('PGPASSWORD', config.option("db-pass"))
|
|
|
|
|
|
|
|
|
|
rootUser = install_params['PostgreSQL']['root']
|
|
|
|
|
dbUser = config.option("db-user")
|
|
|
|
|
dbName = config.option("db-name")
|
|
|
|
|
dbPass = config.option("db-pass")
|
|
|
|
|
|
|
|
|
|
print('Configuration:')
|
|
|
|
|
print(' Root user: ' + rootUser)
|
|
|
|
|
print(' DB user: ' + dbUser)
|
|
|
|
|
print(' DB name: ' + dbName)
|
|
|
|
|
print(' PostgreSQL path: ' + postgrePath)
|
|
|
|
|
|
|
|
|
|
postgre_path_to_bin = get_postrgre_path_to_bin(postgrePath)
|
|
|
|
|
print(' Bin path: ' + postgre_path_to_bin)
|
|
|
|
|
|
|
|
|
|
postgreLoginRoot = get_postgreLoginSrting(rootUser)
|
|
|
|
|
postgreLoginDbUser = get_postgreLoginSrting(dbUser)
|
|
|
|
|
print(' Root login string: ' + postgreLoginRoot)
|
|
|
|
|
print(' User login string: ' + postgreLoginDbUser)
|
|
|
|
|
|
|
|
|
|
creatdb_path = base.get_script_dir() + "/../../server/schema/postgresql/createdb.sql"
|
|
|
|
|
print(' CreateDB script path: ' + creatdb_path)
|
|
|
|
|
if base.is_file(creatdb_path):
|
|
|
|
|
print(' CreateDB script exists: YES')
|
|
|
|
|
else:
|
|
|
|
|
print(' CreateDB script exists: NO - THIS IS A PROBLEM!')
|
|
|
|
|
|
|
|
|
|
if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "\du ' + dbUser + '"')['stdout'].find(dbUser) != -1):
|
|
|
|
|
print('User ' + dbUser + ' is exist')
|
|
|
|
|
if (os.system(postgreLoginDbUser + '-c "\q"') != 0):
|
|
|
|
|
print('\nChecking if user exists...')
|
|
|
|
|
check_user_cmd = postgreLoginRoot + ' -c "\du ' + dbUser + '"'
|
|
|
|
|
user_check_result = base.run_command_in_dir(postgre_path_to_bin, check_user_cmd)
|
|
|
|
|
print('User check command: ' + check_user_cmd)
|
|
|
|
|
print('User check stdout: ' + user_check_result['stdout'])
|
|
|
|
|
if user_check_result['stderr']:
|
|
|
|
|
print('User check stderr: ' + user_check_result['stderr'])
|
|
|
|
|
|
|
|
|
|
if (user_check_result['stdout'].find(dbUser) != -1):
|
|
|
|
|
print('User ' + dbUser + ' exists')
|
|
|
|
|
print('\nTesting user password...')
|
|
|
|
|
password_test_result = os.system(postgreLoginDbUser + '-c "\q"')
|
|
|
|
|
print('Password test result code: ' + str(password_test_result))
|
|
|
|
|
|
|
|
|
|
if (password_test_result != 0):
|
|
|
|
|
print('Invalid user password!')
|
|
|
|
|
base.print_info('Changing password...')
|
|
|
|
|
result = change_userPass(dbUser, dbPass, postgre_path_to_bin) and result
|
|
|
|
|
print('Password change result: ' + str(result))
|
|
|
|
|
else:
|
|
|
|
|
print('User ' + dbUser + ' not exist!')
|
|
|
|
|
base.print_info('Creating ' + dbName + ' user...')
|
|
|
|
|
result = create_postgreUser(dbUser, dbPass, postgre_path_to_bin) and result
|
|
|
|
|
|
|
|
|
|
if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"')['stdout'].find(config.option("db-name")) == -1):
|
|
|
|
|
print('\nChecking if database exists...')
|
|
|
|
|
db_check_cmd = postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"'
|
|
|
|
|
db_check_result = base.run_command_in_dir(postgre_path_to_bin, db_check_cmd)
|
|
|
|
|
print('Database check command: ' + db_check_cmd)
|
|
|
|
|
print('Database check stdout: ' + db_check_result['stdout'])
|
|
|
|
|
if db_check_result['stderr']:
|
|
|
|
|
print('Database check stderr: ' + db_check_result['stderr'])
|
|
|
|
|
|
|
|
|
|
if (db_check_result['stdout'].find(config.option("db-name")) == -1):
|
|
|
|
|
print('Database ' + dbName + ' not found')
|
|
|
|
|
base.print_info('Creating ' + dbName + ' database...')
|
|
|
|
|
result = create_postgreDb(dbName, postgre_path_to_bin) and configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
|
|
|
|
|
create_result = create_postgreDb(dbName, postgre_path_to_bin)
|
|
|
|
|
print('Database creation result: ' + str(create_result))
|
|
|
|
|
|
|
|
|
|
if create_result:
|
|
|
|
|
# Give user rights to database and schema
|
|
|
|
|
print('\nGranting database privileges to user ' + dbUser + '...')
|
|
|
|
|
db_grant_cmd = postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"'
|
|
|
|
|
db_grant_result = base.run_command_in_dir(postgre_path_to_bin, db_grant_cmd)
|
|
|
|
|
print('Database grant result: ' + str(db_grant_result['returncode']))
|
|
|
|
|
|
|
|
|
|
print('Granting schema privileges to user ' + dbUser + '...')
|
|
|
|
|
schema_cmd = postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"'
|
|
|
|
|
schema_result = base.run_command_in_dir(postgre_path_to_bin, schema_cmd)
|
|
|
|
|
print('Schema grant result: ' + str(schema_result['returncode']))
|
|
|
|
|
|
|
|
|
|
print('\nConfiguring database with createdb.sql...')
|
|
|
|
|
configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
|
|
|
|
|
print('Database configuration result: ' + str(configure_result))
|
|
|
|
|
result = create_result and configure_result
|
|
|
|
|
else:
|
|
|
|
|
result = False
|
|
|
|
|
else:
|
|
|
|
|
if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT pg_size_pretty(pg_database_size(' + "'" + dbName + "'" + '));"')['stdout'].find('7559 kB') != -1):
|
|
|
|
|
print('Database ' + dbName + ' not configured')
|
|
|
|
|
base.print_info('Configuring ' + dbName + ' database...')
|
|
|
|
|
result = configureDb(dbName, creatdb_path, postgre_path_to_bin) and result
|
|
|
|
|
print('Database ' + dbName + ' is valid')
|
|
|
|
|
print('Database ' + dbName + ' exists')
|
|
|
|
|
# Simple check: if 0 tables, configure database
|
|
|
|
|
print('Checking tables in database...')
|
|
|
|
|
table_count_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT count(*) FROM information_schema.tables WHERE table_schema = \'public\';"')
|
|
|
|
|
print('Table count result: ' + table_count_result['stdout'].strip())
|
|
|
|
|
|
|
|
|
|
if table_count_result['stdout'].find(' 0') != -1:
|
|
|
|
|
print('Database ' + dbName + ' has no tables - configuring...')
|
|
|
|
|
else:
|
|
|
|
|
print('Database ' + dbName + ' has tables - checking ownership...')
|
|
|
|
|
# Check if tables belong to postgres instead of onlyoffice user
|
|
|
|
|
owner_check = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "\dt"')
|
|
|
|
|
if owner_check['stdout'].find('postgres') != -1 and owner_check['stdout'].find(dbUser) == -1:
|
|
|
|
|
print('Tables belong to postgres, not ' + dbUser + ' - need to recreate')
|
|
|
|
|
print('Dropping existing tables...')
|
|
|
|
|
drop_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"')
|
|
|
|
|
print('Schema recreation result: ' + str(drop_result['returncode']))
|
|
|
|
|
print('Will proceed to recreate tables with correct owner...')
|
|
|
|
|
else:
|
|
|
|
|
print('Database ' + dbUser + ' already has correct tables - skipping configuration')
|
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "\l+ ' + dbName + '"')['stdout'].find(dbUser +'=CTc/' + rootUser) == -1):
|
|
|
|
|
print('User ' + dbUser + ' has no database privileges!')
|
|
|
|
|
base.print_info('Setting database privileges for user ' + dbUser + '...')
|
|
|
|
|
result = set_dbPrivilegesForUser(dbUser, dbName, postgre_path_to_bin) and result
|
|
|
|
|
print('User ' + dbUser + ' has database privileges')
|
|
|
|
|
# Configure database (either empty or after recreation)
|
|
|
|
|
print('Granting database privileges to user ' + dbUser + '...')
|
|
|
|
|
db_grant_cmd = postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"'
|
|
|
|
|
db_grant_result = base.run_command_in_dir(postgre_path_to_bin, db_grant_cmd)
|
|
|
|
|
print('Database grant result: ' + str(db_grant_result['returncode']))
|
|
|
|
|
|
|
|
|
|
print('Granting schema privileges to user ' + dbUser + '...')
|
|
|
|
|
schema_cmd = postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"'
|
|
|
|
|
schema_result = base.run_command_in_dir(postgre_path_to_bin, schema_cmd)
|
|
|
|
|
print('Schema grant result: ' + str(schema_result['returncode']))
|
|
|
|
|
|
|
|
|
|
base.print_info('Configuring ' + dbName + ' database...')
|
|
|
|
|
configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
|
|
|
|
|
print('Configuration completed: ' + ('SUCCESS' if configure_result else 'FAILED'))
|
|
|
|
|
result = configure_result and result
|
|
|
|
|
|
|
|
|
|
# User privileges are set above when configuring database
|
|
|
|
|
|
|
|
|
|
print('\n=== PostgreSQL Configuration Summary ===')
|
|
|
|
|
print('Database: ' + dbName + ' - ' + ('READY' if result else 'FAILED'))
|
|
|
|
|
print('User: ' + dbUser + ' - configured')
|
|
|
|
|
|
|
|
|
|
return result
|
|
|
|
|
def create_postgreDb(dbName, postgre_path_to_bin = ''):
|
|
|
|
|
print('\nCreating database: ' + dbName)
|
|
|
|
|
postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
|
|
|
|
|
if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"') != 0):
|
|
|
|
|
create_cmd = postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"'
|
|
|
|
|
print('Create database command: ' + create_cmd)
|
|
|
|
|
|
|
|
|
|
result = base.run_command_in_dir(postgre_path_to_bin, create_cmd)
|
|
|
|
|
print('Create database return code: ' + str(result['returncode']))
|
|
|
|
|
if result['stdout']:
|
|
|
|
|
print('Create database stdout: ' + result['stdout'])
|
|
|
|
|
if result['stderr']:
|
|
|
|
|
print('Create database stderr: ' + result['stderr'])
|
|
|
|
|
|
|
|
|
|
if (result['returncode'] != 0):
|
|
|
|
|
print('Database creation FAILED!')
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
print('Database created successfully')
|
|
|
|
|
return True
|
|
|
|
|
def set_dbPrivilegesForUser(userName, dbName, postgre_path_to_bin = ''):
|
|
|
|
|
print('\nSetting database privileges for user: ' + userName)
|
|
|
|
|
postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
|
|
|
|
|
if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"') != 0):
|
|
|
|
|
grant_cmd = postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"'
|
|
|
|
|
print('Grant command: ' + grant_cmd)
|
|
|
|
|
|
|
|
|
|
result = base.run_command_in_dir(postgre_path_to_bin, grant_cmd)
|
|
|
|
|
print('Grant return code: ' + str(result['returncode']))
|
|
|
|
|
if result['stdout']:
|
|
|
|
|
print('Grant stdout: ' + result['stdout'])
|
|
|
|
|
if result['stderr']:
|
|
|
|
|
print('Grant stderr: ' + result['stderr'])
|
|
|
|
|
|
|
|
|
|
if (result['returncode'] != 0):
|
|
|
|
|
print('Grant privileges FAILED!')
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
print('Privileges granted successfully')
|
|
|
|
|
return True
|
|
|
|
|
def create_postgreUser(userName, userPass, postgre_path_to_bin = ''):
|
|
|
|
|
print('\nCreating user: ' + userName)
|
|
|
|
|
postgreLoginRoot = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
|
|
|
|
|
if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"') != 0):
|
|
|
|
|
create_cmd = postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"'
|
|
|
|
|
print('Create user command: ' + create_cmd[:50] + '... [password hidden]')
|
|
|
|
|
|
|
|
|
|
result = base.run_command_in_dir(postgre_path_to_bin, create_cmd)
|
|
|
|
|
print('Create user return code: ' + str(result['returncode']))
|
|
|
|
|
if result['stdout']:
|
|
|
|
|
print('Create user stdout: ' + result['stdout'])
|
|
|
|
|
if result['stderr']:
|
|
|
|
|
print('Create user stderr: ' + result['stderr'])
|
|
|
|
|
|
|
|
|
|
if (result['returncode'] != 0):
|
|
|
|
|
print('User creation FAILED!')
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
print('User created successfully')
|
|
|
|
|
return True
|
|
|
|
|
def change_userPass(userName, userPass, postgre_path_to_bin = ''):
|
|
|
|
|
postgreLoginRoot = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
|
|
|
|
|
@ -766,14 +1045,68 @@ def change_userPass(userName, userPass, postgre_path_to_bin = ''):
|
|
|
|
|
return False
|
|
|
|
|
return True
|
|
|
|
|
def configureDb(userName, dbName, scriptPath, postgre_path_to_bin = ''):
|
|
|
|
|
print('Execution ' + scriptPath)
|
|
|
|
|
postgreLoginSrt = get_postgreLoginSrting(userName)
|
|
|
|
|
|
|
|
|
|
code = base.exec_command_in_dir(postgre_path_to_bin, postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"')
|
|
|
|
|
if (code != 0):
|
|
|
|
|
print('Execution failed!')
|
|
|
|
|
print('\n=== Configuring Database ===')
|
|
|
|
|
print('Script path: ' + scriptPath)
|
|
|
|
|
print('User: ' + userName)
|
|
|
|
|
print('Database: ' + dbName)
|
|
|
|
|
print('Bin path: ' + postgre_path_to_bin)
|
|
|
|
|
|
|
|
|
|
# Check if script exists
|
|
|
|
|
if not base.is_file(scriptPath):
|
|
|
|
|
print('ERROR: Script file does not exist: ' + scriptPath)
|
|
|
|
|
return False
|
|
|
|
|
print('Execution completed')
|
|
|
|
|
|
|
|
|
|
print('Script file size: ' + str(os.path.getsize(scriptPath)) + ' bytes')
|
|
|
|
|
|
|
|
|
|
postgreLoginSrt = get_postgreLoginSrting(userName)
|
|
|
|
|
print('Login string: ' + postgreLoginSrt)
|
|
|
|
|
|
|
|
|
|
full_command = postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"'
|
|
|
|
|
print('Full command: ' + full_command)
|
|
|
|
|
|
|
|
|
|
print('\nExecuting createdb.sql script...')
|
|
|
|
|
|
|
|
|
|
# Use run_command_in_dir instead of exec_command_in_dir to capture output
|
|
|
|
|
result = base.run_command_in_dir(postgre_path_to_bin, full_command)
|
|
|
|
|
code = result['returncode']
|
|
|
|
|
|
|
|
|
|
print('Execution return code: ' + str(code))
|
|
|
|
|
if result['stdout']:
|
|
|
|
|
print('Script output:\n' + result['stdout'])
|
|
|
|
|
if result['stderr']:
|
|
|
|
|
print('Script errors:\n' + result['stderr'])
|
|
|
|
|
|
|
|
|
|
if (code != 0):
|
|
|
|
|
print('Execution FAILED! Return code: ' + str(code))
|
|
|
|
|
|
|
|
|
|
# Try to get more info about the failure
|
|
|
|
|
print('\nTrying to connect and check database...')
|
|
|
|
|
test_cmd = postgreLoginSrt + ' -d ' + dbName + ' -c "SELECT version();"'
|
|
|
|
|
test_result = base.run_command_in_dir(postgre_path_to_bin, test_cmd)
|
|
|
|
|
print('Connection test stdout: ' + test_result['stdout'])
|
|
|
|
|
if test_result['stderr']:
|
|
|
|
|
print('Connection test stderr: ' + test_result['stderr'])
|
|
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
print('Execution completed successfully!')
|
|
|
|
|
|
|
|
|
|
# Verify tables were created
|
|
|
|
|
print('\nVerifying table creation...')
|
|
|
|
|
verify_cmd = postgreLoginSrt + ' -d ' + dbName + ' -c "\dt;"'
|
|
|
|
|
verify_result = base.run_command_in_dir(postgre_path_to_bin, verify_cmd)
|
|
|
|
|
|
|
|
|
|
# Count lines with table names (skip header)
|
|
|
|
|
table_lines = [line for line in verify_result['stdout'].split('\n') if '|' in line and 'table' in line.lower()]
|
|
|
|
|
table_count = len(table_lines)
|
|
|
|
|
|
|
|
|
|
if table_count > 0:
|
|
|
|
|
print('SUCCESS: Created ' + str(table_count) + ' tables')
|
|
|
|
|
print('Database is ready for use!')
|
|
|
|
|
else:
|
|
|
|
|
print('WARNING: No tables found after script execution')
|
|
|
|
|
print(verify_result['stdout'])
|
|
|
|
|
|
|
|
|
|
return True
|
|
|
|
|
def uninstall_postgresql():
|
|
|
|
|
code = os.system('sudo DEBIAN_FRONTEND=noninteractive apt-get purge --auto-remove postgresql* -y')
|
|
|
|
|
|
