@@ -32,18 +32,18 @@ func CreateMySQLReplicationHelpers(c kclient.PodInterface, masterDeployment, sla

 	o.Expect(err).NotTo(o.HaveOccurred())

 	// Create MySQL helper for master

-	master := exutil.NewMysql(c, masterPod, "")

+	master := exutil.NewMysql(masterPod, "")

 	// Create MySQL helpers for slaves

 	slaves := make([]exutil.Database, len(slavePods))

 	for i := range slavePods {

-		slave := exutil.NewMysql(c, slavePods[i], masterPod)

+		slave := exutil.NewMysql(slavePods[i], masterPod)

 		slaves[i] = slave

 	}

 	helperNames, err := exutil.WaitForPods(c, exutil.ParseLabelsOrDie(fmt.Sprintf("deployment=%s", helperDeployment)), exutil.CheckPodIsRunningFn, 1, 60*time.Second)

 	o.Expect(err).NotTo(o.HaveOccurred())

-	helper := exutil.NewMysql(c, helperNames[0], masterPod)

+	helper := exutil.NewMysql(helperNames[0], masterPod)

 	return master, slaves, helper

 }

new file mode 100644

@@ -0,0 +1,160 @@

+package images

+

+import (

+	"fmt"

+	"time"

+

+	g "github.com/onsi/ginkgo"

+	o "github.com/onsi/gomega"

+

+	exutil "github.com/openshift/origin/test/extended/util"

+	testutil "github.com/openshift/origin/test/util"

+	kclient "k8s.io/kubernetes/pkg/client/unversioned"

+)

+

+var (

+	postgreSQLReplicationTemplate = "https://raw.githubusercontent.com/openshift/postgresql/master/examples/replica/postgresql_replica.json"

+	postgreSQLEphemeralTemplate   = exutil.FixturePath("..", "..", "examples", "db-templates", "postgresql-ephemeral-template.json")

+	postgreSQLHelperName          = "postgresql-helper"

+	postgreSQLImages              = []string{

+		"openshift/postgresql-92-centos7",

+		"centos/postgresql-94-centos7",

+		// TODO: Uncomment once upstream images are fixed

+		// "registry.access.redhat.com/openshift3/postgresql-92-rhel7",

+		// "registry.access.redhat.com/rhscl/postgresql-94-rhel7",

+	}

+)

+

+var _ = g.Describe("images: postgresql: replication", func() {

+	defer g.GinkgoRecover()

+

+	for i, image := range postgreSQLImages {

+		oc := exutil.NewCLI(fmt.Sprintf("postgresql-replication-%d", i), exutil.KubeConfigPath())

+		testFn := PostgreSQLReplicationTestFactory(oc, image)

+		g.It(fmt.Sprintf("postgresql replication works for %s", image), testFn)

+	}

+})

+

+// CreatePostgreSQLReplicationHelpers creates a set of PostgreSQL helpers for master,

+// slave an en extra helper that is used for remote login test.

+func CreatePostgreSQLReplicationHelpers(c kclient.PodInterface, masterDeployment, slaveDeployment, helperDeployment string, slaveCount int) (exutil.Database, []exutil.Database, exutil.Database) {

+	podNames, err := exutil.WaitForPods(c, exutil.ParseLabelsOrDie(fmt.Sprintf("deployment=%s", masterDeployment)), exutil.CheckPodIsRunningFn, 1, 2*time.Minute)

+	o.Expect(err).NotTo(o.HaveOccurred())

+	masterPod := podNames[0]

+

+	slavePods, err := exutil.WaitForPods(c, exutil.ParseLabelsOrDie(fmt.Sprintf("deployment=%s", slaveDeployment)), exutil.CheckPodIsRunningFn, slaveCount, 3*time.Minute)

+	o.Expect(err).NotTo(o.HaveOccurred())

+

+	// Create PostgreSQL helper for master

+	master := exutil.NewPostgreSQL(masterPod, "")

+

+	// Create PostgreSQL helpers for slaves

+	slaves := make([]exutil.Database, len(slavePods))

+	for i := range slavePods {

+		slave := exutil.NewPostgreSQL(slavePods[i], masterPod)

+		slaves[i] = slave

+	}

+

+	helperNames, err := exutil.WaitForPods(c, exutil.ParseLabelsOrDie(fmt.Sprintf("deployment=%s", helperDeployment)), exutil.CheckPodIsRunningFn, 1, 60*time.Second)

+	o.Expect(err).NotTo(o.HaveOccurred())

+	helper := exutil.NewPostgreSQL(helperNames[0], masterPod)

+

+	return master, slaves, helper

+}

+

+func PostgreSQLReplicationTestFactory(oc *exutil.CLI, image string) func() {

+	return func() {

+		oc.SetOutputDir(exutil.TestContext.OutputDir)

+		defer cleanup(oc)

+

+		_, err := exutil.SetupHostPathVolumes(oc.AdminKubeREST().PersistentVolumes(), oc.Namespace(), "512Mi", 1)

+		o.Expect(err).NotTo(o.HaveOccurred())

+

+		err = testutil.WaitForPolicyUpdate(oc.REST(), oc.Namespace(), "create", "templates", true)

+		o.Expect(err).NotTo(o.HaveOccurred())

+

+		err = oc.Run("new-app").Args("-f", postgreSQLReplicationTemplate, "-p", fmt.Sprintf("POSTGRESQL_IMAGE=%s", image)).Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+

+		err = oc.Run("new-app").Args("-f", postgreSQLEphemeralTemplate, "-p", fmt.Sprintf("DATABASE_SERVICE_NAME=%s", postgreSQLHelperName)).Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+		err = oc.KubeFramework().WaitForAnEndpoint(postgreSQLHelperName)

+		o.Expect(err).NotTo(o.HaveOccurred())

+

+		tableCounter := 0

+		assertReplicationIsWorking := func(masterDeployment, slaveDeployment string, slaveCount int) (exutil.Database, []exutil.Database, exutil.Database) {

+			tableCounter++

+			table := fmt.Sprintf("table_%0.2d", tableCounter)

+

+			master, slaves, helper := CreatePostgreSQLReplicationHelpers(oc.KubeREST().Pods(oc.Namespace()), masterDeployment, slaveDeployment, fmt.Sprintf("%s-1", postgreSQLHelperName), slaveCount)

+			o.Expect(exutil.WaitUntilAllHelpersAreUp(oc, []exutil.Database{master, helper})).NotTo(o.HaveOccurred())

+			o.Expect(exutil.WaitUntilAllHelpersAreUp(oc, slaves)).NotTo(o.HaveOccurred())

+

+			// Test if we can query as admin

+			oc.KubeFramework().WaitForAnEndpoint("postgresql-master")

+			err := helper.TestRemoteLogin(oc, "postgresql-master")

+			o.Expect(err).NotTo(o.HaveOccurred())

+

+			// Create a new table with random name

+			_, err = master.Query(oc, fmt.Sprintf("CREATE TABLE %s (col1 VARCHAR(20), col2 VARCHAR(20));", table))

+			o.Expect(err).NotTo(o.HaveOccurred())

+

+			// Write new data to the table through master

+			_, err = master.Query(oc, fmt.Sprintf("INSERT INTO %s (col1, col2) VALUES ('val1', 'val2');", table))

+			o.Expect(err).NotTo(o.HaveOccurred())

+

+			// Make sure data is present on master

+			err = exutil.WaitForQueryOutput(oc, master, 10*time.Second, false,

+				fmt.Sprintf("SELECT * FROM %s;", table),

+				"col1 | val1\ncol2 | val2")

+			o.Expect(err).NotTo(o.HaveOccurred())

+

+			// Make sure data was replicated to all slaves

+			for _, slave := range slaves {

+				err = exutil.WaitForQueryOutput(oc, slave, 90*time.Second, false,

+					fmt.Sprintf("SELECT * FROM %s;", table),

+					"col1 | val1\ncol2 | val2")

+				o.Expect(err).NotTo(o.HaveOccurred())

+			}

+

+			return master, slaves, helper

+		}

+

+		g.By("after initial deployment")

+		master, _, _ := assertReplicationIsWorking("postgresql-master-1", "postgresql-slave-1", 1)

+

+		g.By("after master is restarted by changing the Deployment Config")

+		err = oc.Run("env").Args("dc", "postgresql-master", "POSTGRESQL_ADMIN_PASSWORD=newpass").Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+		o.Expect(err).NotTo(o.HaveOccurred())

+		err = exutil.WaitUntilPodIsGone(oc.KubeREST().Pods(oc.Namespace()), master.GetPodName(), 60*time.Second)

+		master, _, _ = assertReplicationIsWorking("postgresql-master-2", "postgresql-slave-1", 1)

+

+		g.By("after master is restarted by deleting the pod")

+		err = oc.Run("delete").Args("pod", "-l", "deployment=postgresql-master-2").Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+		err = exutil.WaitUntilPodIsGone(oc.KubeREST().Pods(oc.Namespace()), master.GetPodName(), 60*time.Second)

+		o.Expect(err).NotTo(o.HaveOccurred())

+		_, slaves, _ := assertReplicationIsWorking("postgresql-master-2", "postgresql-slave-1", 1)

+

+		g.By("after slave is restarted by deleting the pod")

+		err = oc.Run("delete").Args("pod", "-l", "deployment=postgresql-slave-1").Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+		err = exutil.WaitUntilPodIsGone(oc.KubeREST().Pods(oc.Namespace()), slaves[0].GetPodName(), 60*time.Second)

+		o.Expect(err).NotTo(o.HaveOccurred())

+		assertReplicationIsWorking("postgresql-master-2", "postgresql-slave-1", 1)

+

+		pods, err := oc.KubeREST().Pods(oc.Namespace()).List(exutil.ParseLabelsOrDie("deployment=postgresql-slave-1"), nil)

+		o.Expect(err).NotTo(o.HaveOccurred())

+		o.Expect(len(pods.Items)).To(o.Equal(1))

+

+		g.By("after slave is scaled to 0 and then back to 4 replicas")

+		err = oc.Run("scale").Args("dc", "postgresql-slave", "--replicas=0").Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+		err = exutil.WaitUntilPodIsGone(oc.KubeREST().Pods(oc.Namespace()), pods.Items[0].Name, 60*time.Second)

+		o.Expect(err).NotTo(o.HaveOccurred())

+		err = oc.Run("scale").Args("dc", "postgresql-slave", "--replicas=4").Execute()

+		o.Expect(err).NotTo(o.HaveOccurred())

+		assertReplicationIsWorking("postgresql-master-2", "postgresql-slave-1", 4)

+	}

+}

@@ -34,6 +34,12 @@ type MySQL struct {

 	MasterPodName string

 }

+// PostgreSQL is a PostgreSQL helper for executing commands

+type PostgreSQL struct {

+	PodName       string

+	MasterPodName string

+}

+

 // PodConfig holds configuration for a pod

 type PodConfig struct {

 	Container string

@@ -42,7 +48,7 @@ type PodConfig struct {

 // NewMysql queries OpenShift for a pod with given name, saving environment

 // variables like username and password for easier use.

-func NewMysql(c kclient.PodInterface, podName, masterPodName string) Database {

+func NewMysql(podName, masterPodName string) Database {

 	if masterPodName == "" {

 		masterPodName = podName

 	}

@@ -52,10 +58,26 @@ func NewMysql(c kclient.PodInterface, podName, masterPodName string) Database {

 	}

 }

+// NewPostgreSQL queries OpenShift for a pod with given name, saving environment

+// variables like username and password for easier use.

+func NewPostgreSQL(podName, masterPodName string) Database {

+	if masterPodName == "" {

+		masterPodName = podName

+	}

+	return &PostgreSQL{

+		PodName:       podName,

+		MasterPodName: masterPodName,

+	}

+}

+

 func (m MySQL) GetPodName() string {

 	return m.PodName

 }

+func (m PostgreSQL) GetPodName() string {

+	return m.PodName

+}

+

 func GetPodConfig(c kclient.PodInterface, podName string) (conf *PodConfig, err error) {

 	pod, err := c.Get(podName)

 	if err != nil {

@@ -118,14 +140,82 @@ func (m MySQL) TestRemoteLogin(oc *CLI, hostAddress string) error {

 	if err != nil {

 		return err

 	}

-	confi, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.MasterPodName)

+	masterConf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.MasterPodName)

 	if err != nil {

 		return err

 	}

-	_, err = oc.Run("exec").Args(m.PodName, "-c", conf.Container, "--", "bash", "-c",

+	err = oc.Run("exec").Args(m.PodName, "-c", conf.Container, "--", "bash", "-c",

 		fmt.Sprintf("mysql -h %s -u%s -p%s -e \"SELECT 1;\" %s",

-			hostAddress, confi.Env["MYSQL_USER"], confi.Env["MYSQL_PASSWORD"],

-			confi.Env["MYSQL_DATABASE"])).Output()

+			hostAddress, masterConf.Env["MYSQL_USER"], masterConf.Env["MYSQL_PASSWORD"],

+			masterConf.Env["MYSQL_DATABASE"])).Execute()

+	return err

+}

+

+// IsReady pings the PostgreSQL server

+func (m PostgreSQL) IsReady(oc *CLI) (bool, error) {

+	conf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.PodName)

+	if err != nil {

+		return false, err

+	}

+	out, err := oc.Run("exec").Args(m.PodName, "-c", conf.Container, "--", "bash", "-c",

+		"psql postgresql://postgres@127.0.0.1 -x -c \"SELECT 1;\"").Output()

+	if err != nil {

+		switch err.(type) {

+		case *exec.ExitError:

+			return false, nil

+		default:

+			return false, err

+		}

+	}

+	return out == "-[ RECORD 1 ]\n?column? | 1", nil

+}

+

+// Query executes an SQL query as an ordinary user and returns the result.

+func (m PostgreSQL) Query(oc *CLI, query string) (string, error) {

+	conf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.PodName)

+	if err != nil {

+		return "", err

+	}

+	masterConf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.MasterPodName)

+	if err != nil {

+		return "", err

+	}

+	return oc.Run("exec").Args(m.PodName, "-c", conf.Container, "--", "bash", "-c",

+		fmt.Sprintf("psql postgres://%s:%s@127.0.0.1/%s -x -c \"%s\"",

+			masterConf.Env["POSTGRESQL_USER"], masterConf.Env["POSTGRESQL_PASSWORD"],

+			masterConf.Env["POSTGRESQL_DATABASE"], query)).Output()

+}

+

+// QueryPrivileged executes an SQL query as a root user and returns the result.

+func (m PostgreSQL) QueryPrivileged(oc *CLI, query string) (string, error) {

+	conf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.PodName)

+	if err != nil {

+		return "", err

+	}

+	masterConf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.MasterPodName)

+	if err != nil {

+		return "", err

+	}

+	return oc.Run("exec").Args(m.PodName, "-c", conf.Container, "--", "bash", "-c",

+		fmt.Sprintf("psql postgres://postgres:%s@127.0.0.1/%s -x -c \"%s\"",

+			masterConf.Env["POSTGRESQL_ADMIN_PASSWORD"],

+			masterConf.Env["POSTGRESQL_DATABASE"], query)).Output()

+}

+

+// TestRemoteLogin will test whether we can login through to a remote database.

+func (m PostgreSQL) TestRemoteLogin(oc *CLI, hostAddress string) error {

+	conf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.PodName)

+	if err != nil {

+		return err

+	}

+	masterConf, err := GetPodConfig(oc.KubeREST().Pods(oc.Namespace()), m.MasterPodName)

+	if err != nil {

+		return err

+	}

+	err = oc.Run("exec").Args(m.PodName, "-c", conf.Container, "--", "bash", "-c",

+		fmt.Sprintf("psql postgres://%s:%s@%s/%s -x -c \"SELECT 1;\"",

+			masterConf.Env["POSTGRESQL_USER"], masterConf.Env["POSTGRESQL_PASSWORD"],

+			hostAddress, masterConf.Env["POSTGRESQL_DATABASE"])).Execute()

 	return err

 }