AMBARI-6602. Error upgrading from 1.6.0 to 1.6.1 using external Postgres DB. (Alejandro Fernandez via swagle)

ambari-server/src/main/java/org/apache/ambari/server/configuration/Configuration.java

@@ -106,9 +106,10 @@ public class Configuration {
   public static final String CLIENT_API_SSL_CRT_PASS_FILE_NAME_KEY = "client.api.ssl.cert_pass_file";
   public static final String CLIENT_API_SSL_CRT_PASS_KEY = "client.api.ssl.crt_pass";
   public static final String CLIENT_API_SSL_KEY_NAME_KEY = "client.api.ssl.key_name";
-  public static final String SERVER_DB_NAME_KEY = "server.jdbc.database";
+  public static final String SERVER_DB_TYPE_KEY = "server.jdbc.database";       // E.g., oracle|mysql|postgres
+  public static final String SERVER_DB_NAME_KEY = "server.jdbc.database_name";
   public static final String SERVER_DB_NAME_DEFAULT = "ambari";
-  public static final String SERVER_JDBC_SCHEMA_NAME = "server.jdbc.schema";
+  public static final String SERVER_JDBC_POSTGRES_SCHEMA_NAME = "server.jdbc.postgres.schema";
   public static final String POSTGRES_DB_NAME = "postgres";
   public static final String ORACLE_DB_NAME = "oracle";
   public static final String MYSQL_DB_NAME = "mysql";
@@ -1003,8 +1004,8 @@ public class Configuration {
     return properties.getProperty(RESOURCES_DIR_KEY, RESOURCES_DIR_DEFAULT);
   }
 
-  public String getServerJDBCSchemaName() {
-    return properties.getProperty(SERVER_JDBC_SCHEMA_NAME, SERVER_DB_NAME_DEFAULT);
+  public String getServerJDBCPostgresSchemaName() {
+    return properties.getProperty(SERVER_JDBC_POSTGRES_SCHEMA_NAME, "");
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/orm/DBAccessorImpl.java

@@ -30,6 +30,8 @@ import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.orm.helpers.ScriptRunner;
@@ -63,6 +65,8 @@ public class DBAccessorImpl implements DBAccessor {
   private final DbmsHelper dbmsHelper;
   private Configuration configuration;
   private DatabaseMetaData databaseMetaData;
+  private static final String dbURLPatternString = "jdbc:(.*?):.*";
+  private Pattern dbURLPattern = Pattern.compile(dbURLPatternString, Pattern.CASE_INSENSITIVE);
 
   @Inject
   public DBAccessorImpl(Configuration configuration) {
@@ -176,21 +180,30 @@ public class DBAccessorImpl implements DBAccessor {
 
   protected String getDbType() {
     String dbUrl = configuration.getDatabaseUrl();
-    String dbType;
-
-    if (dbUrl.contains(Configuration.POSTGRES_DB_NAME)) {
-      dbType = Configuration.POSTGRES_DB_NAME;
-    } else if (dbUrl.contains(Configuration.ORACLE_DB_NAME)) {
-      dbType = Configuration.ORACLE_DB_NAME;
-    } else if (dbUrl.contains(Configuration.MYSQL_DB_NAME)) {
-      dbType = Configuration.MYSQL_DB_NAME;
-    } else if (dbUrl.contains(Configuration.DERBY_DB_NAME)) {
-      dbType = Configuration.DERBY_DB_NAME;
-    } else {
-      throw new RuntimeException("Unable to determine database type.");
+
+    // dbUrl will have the following format
+    // jdbc:{0}://{1}:{2}/{3},  type, host, port, name
+    // Most importantly, type is one of: postgresql, oracle:thin, mysql
+
+    if (null != dbUrl && !dbUrl.equals("")) {
+      Matcher m = dbURLPattern.matcher(dbUrl.toLowerCase());
+
+      if (m.find() && m.groupCount() == 1) {
+        String type = m.group(1);
+
+        if (type.contains(Configuration.POSTGRES_DB_NAME)) {
+          return Configuration.POSTGRES_DB_NAME;
+        } else if (type.contains(Configuration.ORACLE_DB_NAME)) {
+          return Configuration.ORACLE_DB_NAME;
+        } else if (type.contains(Configuration.MYSQL_DB_NAME)) {
+          return Configuration.MYSQL_DB_NAME;
+        } else if (type.contains(Configuration.DERBY_DB_NAME)) {
+          return Configuration.DERBY_DB_NAME;
+        }
+      }
     }
 
-    return dbType;
+    throw new RuntimeException("Unable to determine database type.");
   }
 
   @Override

ambari-server/src/main/java/org/apache/ambari/server/upgrade/AbstractUpgradeCatalog.java

@@ -164,16 +164,17 @@ public abstract class AbstractUpgradeCatalog implements UpgradeCatalog {
 
   protected void changePostgresSearchPath() throws SQLException {
     String dbUser = configuration.getDatabaseUser();
-    String dbName = configuration.getServerDBName();
+    String schemaName = configuration.getServerJDBCPostgresSchemaName();
 
-    //wrap username with double quotes to accept old username "ambari-server"
-    if (!dbUser.contains("\"")) {
-      dbUser = String.format("\"%s\"", dbUser);
-    }
-
-    dbAccessor.executeQuery(String.format("ALTER SCHEMA %s OWNER TO %s;", dbName, dbUser));
+    if (null != dbUser && !dbUser.equals("") && null != schemaName && !schemaName.equals("")) {
+      // Wrap username with double quotes to accept old username "ambari-server"
+      if (!dbUser.contains("\"")) {
+        dbUser = String.format("\"%s\"", dbUser);
+      }
 
-    dbAccessor.executeQuery(String.format("ALTER ROLE %s SET search_path to '%s';", dbUser, dbName));
+      dbAccessor.executeQuery(String.format("ALTER SCHEMA %s OWNER TO %s;", schemaName, dbUser));
+      dbAccessor.executeQuery(String.format("ALTER ROLE %s SET search_path to '%s';", dbUser, schemaName));
+    }
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/upgrade/UpgradeCatalog150.java

@@ -293,7 +293,7 @@ public class UpgradeCatalog150 extends AbstractUpgradeCatalog {
 
     //Move tables from ambarirca db to ambari db; drop ambarirca; Mysql
     if (dbType.equals(Configuration.MYSQL_DB_NAME)) {
-      String dbName = configuration.getServerJDBCSchemaName();
+      String dbName = configuration.getServerJDBCPostgresSchemaName();
       moveRCATableInMySQL("workflow", dbName);
       moveRCATableInMySQL("job", dbName);
       moveRCATableInMySQL("task", dbName);

ambari-server/src/main/python/ambari-server.py

@@ -268,12 +268,11 @@ POSTGRESQL_CONF_FILE = os.path.join(PG_HBA_DIR, "postgresql.conf")
 
 SERVER_VERSION_FILE_PATH = "server.version.file"
 
-#TODO property used incorrectly in local case, it was meant to be dbms name, not postgres database name,
-# has workaround for now, as we don't need dbms name if persistence_type=local
-JDBC_DATABASE_PROPERTY = "server.jdbc.database"
+JDBC_DATABASE_PROPERTY = "server.jdbc.database"             # E.g., embedded|oracle|mysql|postgres
+JDBC_DATABASE_NAME_PROPERTY = "server.jdbc.database_name"   # E.g., ambari
 JDBC_HOSTNAME_PROPERTY = "server.jdbc.hostname"
 JDBC_PORT_PROPERTY = "server.jdbc.port"
-JDBC_SCHEMA_PROPERTY = "server.jdbc.schema"
+JDBC_POSTGRES_SCHEMA_PROPERTY = "server.jdbc.postgres.schema"   # Only for postgres, defaults to same value as DB name
 
 JDBC_USER_NAME_PROPERTY = "server.jdbc.user.name"
 JDBC_PASSWORD_PROPERTY = "server.jdbc.user.passwd"
@@ -293,11 +292,6 @@ PERSISTENCE_TYPE_PROPERTY = "server.persistence.type"
 JDBC_DRIVER_PROPERTY = "server.jdbc.driver"
 JDBC_URL_PROPERTY = "server.jdbc.url"
 
-JDBC_RCA_DATABASE_PROPERTY = "server.jdbc.database"
-JDBC_RCA_HOSTNAME_PROPERTY = "server.jdbc.hostname"
-JDBC_RCA_PORT_PROPERTY = "server.jdbc.port"
-JDBC_RCA_SCHEMA_PROPERTY = "server.jdbc.schema"
-
 JDBC_RCA_DRIVER_PROPERTY = "server.jdbc.rca.driver"
 JDBC_RCA_URL_PROPERTY = "server.jdbc.rca.url"
 JDBC_RCA_USER_NAME_PROPERTY = "server.jdbc.rca.user.name"
@@ -1128,6 +1122,14 @@ def get_validated_db_name(database_name):
         False
         )
 
+def get_validated_db_schema(postgres_schema):
+    return get_validated_string_input(
+        "Postgres schema (" + postgres_schema + "): ",
+        postgres_schema,
+        "^[a-zA-Z0-9_\-]*$",
+        "Invalid schema name.",
+        False, allowEmpty=True
+    )
 
 def get_validated_service_name(service_name, index):
   return get_validated_string_input(
@@ -1182,6 +1184,7 @@ def load_default_db_properties(args):
   args.database_host = "localhost"
   args.database_port = DATABASE_PORTS[DATABASE_INDEX]
   args.database_name = DEFAULT_DB_NAME
+  args.postgres_schema = DEFAULT_DB_NAME
   args.database_username = "ambari"
   args.database_password = "bigdata"
   args.sid_or_sname = "sname"
@@ -1272,6 +1275,8 @@ def prompt_db_properties(args):
         elif args.dbms in ["mysql", "postgres"]:
           args.database_name = get_validated_db_name(args.database_name)
 
+          if args.dbms in ["postgres", ]:
+              args.postgres_schema = get_validated_db_schema(args.postgres_schema)
         else:
           # other DB types
           pass
@@ -1281,7 +1286,8 @@ def prompt_db_properties(args):
         args.database_port = DATABASE_PORTS[DATABASE_INDEX]
 
         args.database_name = get_validated_db_name(args.database_name)
-        pass
+        if args.dbms in ["postgres", ]:
+            args.postgres_schema = get_validated_db_schema(args.postgres_schema)
 
       # Username is common for Oracle/MySQL/Postgres
       args.database_username = get_validated_string_input(
@@ -1294,11 +1300,12 @@ def prompt_db_properties(args):
       )
       args.database_password = configure_database_password(True)
 
-  print_info_msg('Using database options: {database},{host},{port},{schema},{user},{password}'.format(
+  print_info_msg('Using database options: {database},{host},{port},{name},{schema},{user},{password}'.format(
     database=args.dbms,
     host=args.database_host,
     port=args.database_port,
-    schema=args.database_name,
+    name=args.database_name,
+    schema=args.postgres_schema,
     user=args.database_username,
     password=args.database_password
   ))
@@ -1318,8 +1325,9 @@ def store_remote_properties(args):
   properties.process_pair(JDBC_DATABASE_PROPERTY, args.dbms)
   properties.process_pair(JDBC_HOSTNAME_PROPERTY, args.database_host)
   properties.process_pair(JDBC_PORT_PROPERTY, args.database_port)
-  properties.process_pair(JDBC_SCHEMA_PROPERTY, args.database_name)
-
+  properties.process_pair(JDBC_DATABASE_NAME_PROPERTY, args.database_name)
+  if args.dbms == "postgres":
+    properties.process_pair(JDBC_POSTGRES_SCHEMA_PROPERTY, args.postgres_schema)
   properties.process_pair(JDBC_DRIVER_PROPERTY, DATABASE_DRIVER_NAMES[DATABASE_INDEX])
   # fully qualify the hostname to make sure all the other hosts can connect
   # to the jdbc hostname since its passed onto the agents for RCA
@@ -1477,7 +1485,7 @@ def check_database_name_property():
     print_error_msg("Error getting ambari properties")
     return -1
 
-  dbname = properties[JDBC_DATABASE_PROPERTY]
+  dbname = properties[JDBC_DATABASE_NAME_PROPERTY]
   if dbname is None or dbname == "":
     err = "DB Name property not set in config file.\n" + SETUP_OR_UPGRADE_MSG
     raise FatalException(-1, err)
@@ -1491,7 +1499,7 @@ def configure_database_username_password(args):
 
   username = properties[JDBC_USER_NAME_PROPERTY]
   passwordProp = properties[JDBC_PASSWORD_PROPERTY]
-  dbname = properties[JDBC_DATABASE_PROPERTY]
+  dbname = properties[JDBC_DATABASE_NAME_PROPERTY]
 
   if username and passwordProp and dbname:
     print_info_msg("Database username + password already configured")
@@ -1537,15 +1545,22 @@ def store_local_properties(args):
 
   isSecure = get_is_secure(properties)
 
-  properties.removeOldProp(JDBC_SCHEMA_PROPERTY)
+  properties.removeOldProp(JDBC_DATABASE_PROPERTY)
+  properties.removeOldProp(JDBC_DATABASE_NAME_PROPERTY)
+  properties.removeOldProp(JDBC_POSTGRES_SCHEMA_PROPERTY)
   properties.removeOldProp(JDBC_HOSTNAME_PROPERTY)
   properties.removeOldProp(JDBC_RCA_DRIVER_PROPERTY)
   properties.removeOldProp(JDBC_RCA_URL_PROPERTY)
   properties.removeOldProp(JDBC_PORT_PROPERTY)
   properties.removeOldProp(JDBC_DRIVER_PROPERTY)
   properties.removeOldProp(JDBC_URL_PROPERTY)
+
+  # Store the properties
   properties.process_pair(PERSISTENCE_TYPE_PROPERTY, "local")
-  properties.process_pair(JDBC_DATABASE_PROPERTY, args.database_name)
+  properties.process_pair(JDBC_DATABASE_PROPERTY, args.dbms)
+  properties.process_pair(JDBC_DATABASE_NAME_PROPERTY, args.database_name)
+  if args.dbms == "postgres":
+    properties.process_pair(JDBC_POSTGRES_SCHEMA_PROPERTY, args.postgres_schema)
   properties.process_pair(JDBC_USER_NAME_PROPERTY, args.database_username)
   properties.process_pair(JDBC_PASSWORD_PROPERTY,
       store_password_file(args.database_password, JDBC_PASSWORD_FILENAME))
@@ -1592,23 +1607,22 @@ def parse_properties_file(args):
   args.persistence_type = properties[PERSISTENCE_TYPE_PROPERTY]
   args.jdbc_url = properties[JDBC_URL_PROPERTY]
 
+  args.dbms = properties[JDBC_DATABASE_PROPERTY]
   if not args.persistence_type:
     args.persistence_type = "local"
 
   if args.persistence_type == 'remote':
-    args.dbms = properties[JDBC_DATABASE_PROPERTY]
     args.database_host = properties[JDBC_HOSTNAME_PROPERTY]
     args.database_port = properties[JDBC_PORT_PROPERTY]
-    args.database_name = properties[JDBC_SCHEMA_PROPERTY]
     global DATABASE_INDEX
     try:
       DATABASE_INDEX = DATABASE_NAMES.index(args.dbms)
     except ValueError:
       pass
-  else:
-    #TODO incorrect property used!! leads to bunch of troubles. Workaround for now
-    args.database_name = properties[JDBC_DATABASE_PROPERTY]
 
+  args.database_name = properties[JDBC_DATABASE_NAME_PROPERTY]
+  args.postgres_schema = properties[JDBC_POSTGRES_SCHEMA_PROPERTY] \
+      if JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames() else None
   args.database_username = properties[JDBC_USER_NAME_PROPERTY]
   args.database_password_file = properties[JDBC_PASSWORD_PROPERTY]
   if args.database_password_file:
@@ -2791,9 +2805,9 @@ def upgrade(args):
     if properties == -1:
       print_error_msg("Error getting ambari properties")
       return -1
-    print_warning_msg(JDBC_DATABASE_PROPERTY + " property isn't set in " +
+    print_warning_msg(JDBC_DATABASE_NAME_PROPERTY + " property isn't set in " +
     AMBARI_PROPERTIES_FILE + ". Setting it to default value - " + DEFAULT_DB_NAME)
-    properties.process_pair(JDBC_DATABASE_PROPERTY, DEFAULT_DB_NAME)
+    properties.process_pair(JDBC_DATABASE_NAME_PROPERTY, DEFAULT_DB_NAME)
     conf_file = find_properties_file()
     try:
       properties.store(open(conf_file, "w"))
@@ -4158,8 +4172,10 @@ def main():
   parser.add_option('--database', default=None, help="Database to use embedded|oracle|mysql|postgres", dest="dbms")
   parser.add_option('--databasehost', default=None, help="Hostname of database server", dest="database_host")
   parser.add_option('--databaseport', default=None, help="Database port", dest="database_port")
-  parser.add_option('--databasename', default=None, help="Database/Schema/Service name or ServiceID",
+  parser.add_option('--databasename', default=None, help="Database/Service name or ServiceID",
                     dest="database_name")
+  parser.add_option('--postgresschema', default=None, help="Postgres database schema name",
+                    dest="postgres_schema")
   parser.add_option('--databaseusername', default=None, help="Database user login", dest="database_username")
   parser.add_option('--databasepassword', default=None, help="Database user password", dest="database_password")
   parser.add_option('--sidorsname', default="sname", help="Oracle database identifier type, Service ID/Service "

ambari-server/src/test/java/org/apache/ambari/server/configuration/ConfigurationTest.java

@@ -210,7 +210,7 @@ public class ConfigurationTest {
   @Test
   public void testGetLocalDatabaseUrl() {
     Properties ambariProperties = new Properties();
-    ambariProperties.setProperty("server.jdbc.database", "ambaritestdatabase");
+    ambariProperties.setProperty("server.jdbc.database_name", "ambaritestdatabase");
     Configuration conf = new Configuration(ambariProperties);
     Assert.assertEquals(conf.getLocalDatabaseUrl(), Configuration.JDBC_LOCAL_URL.concat("ambaritestdatabase"));
   }

ambari-server/src/test/python/TestAmbariServer.py

@@ -20,9 +20,7 @@ import StringIO
 import re
 from unittest import TestCase
 import sys
-from mock.mock import patch
-from mock.mock import MagicMock
-from mock.mock import create_autospec
+from mock.mock import patch, MagicMock, create_autospec
 import os, errno, tempfile
 import signal
 import stat
@@ -2165,7 +2163,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
   def test_prompt_db_properties_postgre_adv(self, gyni_mock, gvsi_mock, rp_mock, smk_mock):
     ambari_server.PROMPT_DATABASE_OPTIONS = True
     gyni_mock.return_value = True
-    list_of_return_values = ["ambari-server", "ambari", "1"]
+    list_of_return_values = ["ambari-server", "ambari", "ambari", "1"]
 
     def side_effect(*args, **kwargs):
       return list_of_return_values.pop()
@@ -2184,6 +2182,88 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
     self.assertEqual(args.database_username, "ambari-server")
     self.assertEqual(args.sid_or_sname, "sname")
 
+  @patch.object(ambari_server, "setup_master_key")
+  @patch.object(ambari_server, "read_password")
+  @patch.object(ambari_server, "get_validated_string_input")
+  @patch.object(ambari_server, "get_YN_input")
+  def test_prompt_db_properties_for_each_database_type(self, gyni_mock, gvsi_mock, rp_mock, smk_mock):
+    """
+    :return: Validates that installation for each database type correctly stores the database type, database name,
+    and optionally the postgres schema name.
+    """
+    ambari_server.PROMPT_DATABASE_OPTIONS = True
+    gyni_mock.return_value = True
+    rp_mock.return_value = "password"
+    smk_mock.return_value = (None, False, True)
+
+    # Values to use while installing several database types
+    hostname = "localhost"
+    db_name = "db_ambari"
+    postgres_schema = "sc_ambari"
+    port = "1234"
+    oracle_service = "1"
+    oracle_service_name = "ambari"
+    user_name = "ambari"
+
+    # Input values
+    postgres_embedded_values = ["1", db_name, postgres_schema, hostname]
+    oracle_values = ["2", hostname, port, oracle_service, oracle_service_name, user_name]
+    mysql_values = ["3", hostname, port, db_name, user_name]
+    postgres_external_values = ["4", hostname, port, db_name, postgres_schema, user_name]
+
+    list_of_return_values = postgres_embedded_values + oracle_values + mysql_values + postgres_external_values
+    list_of_return_values = list_of_return_values[::-1]       # Reverse the list since the input will be popped
+
+    def side_effect(*args, **kwargs):
+      return list_of_return_values.pop()
+    gvsi_mock.side_effect = side_effect
+
+    if ambari_server.AMBARI_CONF_VAR in os.environ:
+      del os.environ[ambari_server.AMBARI_CONF_VAR]
+
+    tempdir = tempfile.gettempdir()
+    os.environ[ambari_server.AMBARI_CONF_VAR] = tempdir
+
+    for i in range(1, 5):
+        # Use the expected path of the ambari.properties file to delete it if it exists, and then create a new one
+        # during each use case.
+        prop_file = os.path.join(tempdir, "ambari.properties")
+        if os.path.exists(prop_file):
+          os.remove(prop_file)
+        with open(prop_file, "w") as f:
+          f.write("server.jdbc.database_name=oldDBName")
+        f.close()
+        ambari_server.AMBARI_PROPERTIES_FILE = prop_file
+
+        args = MagicMock()
+        ambari_server.load_default_db_properties(args)
+        ambari_server.prompt_db_properties(args)
+
+        if i == 1:
+          ambari_server.store_local_properties(args)          # Embedded postgres is the only one that saves local properties
+        else:
+          ambari_server.store_remote_properties(args)
+
+        properties = ambari_server.get_ambari_properties()
+        if i == 1:
+          # Postgres Embedded
+          self.assertEqual(properties[ambari_server.JDBC_DATABASE_PROPERTY], "postgres")
+          self.assertEqual(properties[ambari_server.JDBC_DATABASE_NAME_PROPERTY], db_name)
+          self.assertEqual(properties[ambari_server.JDBC_POSTGRES_SCHEMA_PROPERTY], postgres_schema)
+        elif i == 2:
+          # Oracle
+          self.assertEqual(properties[ambari_server.JDBC_DATABASE_PROPERTY], "oracle")
+          self.assertFalse(ambari_server.JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames())
+        elif i == 3:
+          # MySQL
+          self.assertEqual(properties[ambari_server.JDBC_DATABASE_PROPERTY], "mysql")
+          self.assertFalse(ambari_server.JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames())
+        elif i == 4:
+          # Postgres External
+          self.assertEqual(properties[ambari_server.JDBC_DATABASE_PROPERTY], "postgres")
+          self.assertEqual(properties[ambari_server.JDBC_DATABASE_NAME_PROPERTY], db_name)
+          self.assertEqual(properties[ambari_server.JDBC_POSTGRES_SCHEMA_PROPERTY], postgres_schema)
+
   @patch.object(os.path, "exists")
   def test_validate_jdk(self, exists_mock):
     exists_mock.side_effect = [False]
@@ -3446,14 +3526,14 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
     properties = ["server.jdbc.user.name=ambari-server\n",
                   "server.jdbc.user.passwd=/etc/ambari-server/conf/password.dat\n",
                   "java.home=/usr/jdk64/jdk1.6.0_31\n",
-                  "server.jdbc.database=ambari\n",
+                  "server.jdbc.database_name=ambari\n",
                   "ambari-server.user=ambari\n",
                   "agent.fqdn.service.url=URL\n"]
 
     NEW_PROPERTY = 'some_new_property=some_value\n'
     JDK_NAME_PROPERTY = 'jdk.name=jdk-6u31-linux-x64.bin\n'
     JCE_NAME_PROPERTY = 'jce.name=jce_policy-6.zip\n'
-    CHANGED_VALUE_PROPERTY = 'server.jdbc.database=should_not_overwrite_value\n'
+    CHANGED_VALUE_PROPERTY = 'server.jdbc.database_name=should_not_overwrite_value\n'
 
     get_conf_dir_mock.return_value = '/etc/ambari-server/conf'
 
@@ -3651,6 +3731,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
     args.database_host = "localhost"
     args.database_port = "1234"
     args.database_name = "ambari"
+    args.postgres_schema = "ambari"
     args.sid_or_sname = "foo"
     args.database_username = "foo"
     args.database_password = "foo"
@@ -4041,7 +4122,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
 
     configs = {ambari_server.JDBC_USER_NAME_PROPERTY: "fakeuser",
                ambari_server.JDBC_PASSWORD_PROPERTY: "${alias=somealias}",
-               ambari_server.JDBC_DATABASE_PROPERTY: "fakedbname",
+               ambari_server.JDBC_DATABASE_NAME_PROPERTY: "fakedbname",
                ambari_server.SECURITY_KEY_IS_PERSISTED: "True"}
 
     get_ambari_properties_method.return_value = configs
@@ -4740,7 +4821,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
   @patch.object(ambari_server, "get_ambari_properties")
   def test_check_database_name_property(self, get_ambari_properties_mock):
     # negative case
-    get_ambari_properties_mock.return_value = {ambari_server.JDBC_DATABASE_PROPERTY: ""}
+    get_ambari_properties_mock.return_value = {ambari_server.JDBC_DATABASE_NAME_PROPERTY: ""}
     try:
       result = ambari_server.check_database_name_property()
       self.fail("Should fail with exception")
@@ -4750,7 +4831,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
     # positive case
     dbname = "ambari"
     get_ambari_properties_mock.reset_mock()
-    get_ambari_properties_mock.return_value = {ambari_server.JDBC_DATABASE_PROPERTY: dbname}
+    get_ambari_properties_mock.return_value = {ambari_server.JDBC_DATABASE_NAME_PROPERTY: dbname}
     try:
       result = ambari_server.check_database_name_property()
     except FatalException:
@@ -4802,7 +4883,9 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
     store_password_file_mock.return_value = "password"
 
     new_db = "newDBName"
+    args.dbms = "postgres"
     args.database_name = new_db
+    args.postgres_schema = new_db
     args.database_username = "user"
     args.database_password = "password"
     args.jdbc_driver= None
@@ -4811,7 +4894,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
     tempdir = tempfile.gettempdir()
     prop_file = os.path.join(tempdir, "ambari.properties")
     with open(prop_file, "w") as f:
-      f.write("server.jdbc.database=oldDBName")
+      f.write("server.jdbc.database_name=oldDBName")
     f.close()
 
     os.environ[ambari_server.AMBARI_CONF_VAR] = tempdir
@@ -4823,8 +4906,8 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
 
     properties = ambari_server.get_ambari_properties()
 
-    self.assertTrue(ambari_server.JDBC_DATABASE_PROPERTY in properties.keys())
-    value = properties[ambari_server.JDBC_DATABASE_PROPERTY]
+    self.assertTrue(ambari_server.JDBC_DATABASE_NAME_PROPERTY in properties.keys())
+    value = properties[ambari_server.JDBC_DATABASE_NAME_PROPERTY]
     self.assertEqual(value, new_db)
 
     del os.environ[ambari_server.AMBARI_CONF_VAR]

ambari-server/src/test/python/TestOSCheck.py

@@ -187,7 +187,7 @@ class TestOSCheck(TestCase):
   def test_update_ambari_properties_os(self, get_conf_dir_mock):
 
     properties = ["server.jdbc.user.name=ambari-server\n",
-                  "server.jdbc.database=ambari\n",
+                  "server.jdbc.database_name=ambari\n",
                   "ambari-server.user=root\n",
                   "server.jdbc.user.name=ambari-server\n",
                   "jdk.name=jdk-6u31-linux-x64.bin\n",

ambari-server/src/test/python/ambari.properties

@@ -16,4 +16,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-server.jdbc.database=oldDBName
+server.jdbc.database_name=oldDBName

ambari-web/app/utils/ajax/ajax.js

@@ -352,7 +352,7 @@ var urls = {
     'mock': '/data/clusters/tags_and_groups.json'
   },
   'config.ambari.database.info': {
-    'real': '/services/AMBARI/components/AMBARI_SERVER?fields=hostComponents/RootServiceHostComponents/properties/server.jdbc.database,hostComponents/RootServiceHostComponents/properties/server.jdbc.url',
+    'real': '/services/AMBARI/components/AMBARI_SERVER?fields=hostComponents/RootServiceHostComponents/properties/server.jdbc.database_name,hostComponents/RootServiceHostComponents/properties/server.jdbc.url',
     'mock': ''
   },
   'config_groups.all_fields': {