src/test/feature/cloudtest/test_cloud.cpp - hawq - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  */

 #include <fstream>

 #include "lib/command.h"
 #include "lib/sql_util_parallel.h"
 #include "lib/xml_parser.h"
 #include "test_cloud.h"

 #define CREATE_ROLE "CREATE ROLE"
 #define ALTER_ROLE "ALTER ROLE"
 #define DROP_ROLE "DROP ROLE"

 using hawq::test::Command;

 TEST_F(TestCloud, Permissions) {
   ASSERT_TRUE(testLogin(getUserName(), HAWQ_PASSWORD))
       << "Connect Error: Can't login as " + getUserName();
   execSql("drop role if exists lava;");
   execSql("drop role if exists user1;");
   execSql("drop role if exists user2;");
   execSql(getHost2(), "drop role if exists user2;");

   std::string result;
   result = execSql("create role lava password \'lava00000000\';");
   const std::string lava_pwd("lava00000000");
   ASSERT_TRUE(checkOut(result, CREATE_ROLE))
       << "create role lava failure: " + result;
   EXPECT_FALSE(testLogin("lava", lava_pwd))
       << "Error: lava can login before grant login permission";

   result = execSql("alter role lava login;");
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "grant lava login permission failure: " + result;
   ASSERT_TRUE(testLogin("lava", lava_pwd))
       << "Error: lava can't login after grant login permission";

   result = execSql("alter role lava Superuser;");
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "grant lava Superuser permision failure: " + result;
   result = execSql("alter role lava Createrole;");
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "grant lava Createrole permision failure: " + result;
   result = execSql("lava", lava_pwd,
                    "create role user1 login password \'user100000000\';");
   ASSERT_TRUE((checkOut(result, CREATE_ROLE)))
       << "lava create user1 failure: " + result;
   ASSERT_TRUE(testLogin("user1", "user100000000")) << "login as user1 failure";

   result = execSql("lava", lava_pwd,
                    "alter role user1 password \'newPwd00000000\';");
   const std::string user_newPwd = "newPwd00000000";
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "lava reset user1's password failure";
   EXPECT_FALSE(testLogin("user1", "user100000000"))
       << "user1 can login after reset password";
   EXPECT_TRUE(testLogin("user1", user_newPwd))
       << "user1 user new password can't login after reset password";

   result = execSql("user1", user_newPwd,
                    "create role user2 password \'user200000000\'");
   EXPECT_FALSE(checkOut(result, CREATE_ROLE))
       << "user1 can create user2 before get creatrole permissions: " + result;
   result = execSql("lava", lava_pwd, "alter role user1 createrole;");
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "lava grant user1 createrole permissions failure: " + result;
   result = execSql("user1", user_newPwd,
                    "create role user2 password \'user200000000\'");
   ASSERT_TRUE(checkOut(result, CREATE_ROLE))
       << "user1 can't create user2 after get creatrole permissions: " + result;

   result = execSql("lava", lava_pwd, "alter role user1 nocreaterole;");
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "lava can't revoke createrole from user1:" << result;
   result = execSql("user1", user_newPwd, "drop role user2;");
   ASSERT_FALSE(checkOut(result, DROP_ROLE))
       << "user can drop user2 after revoked createrole permissions: " + result;

   result = execSql("lava", lava_pwd, "drop role user2;");
   ASSERT_TRUE(checkOut(result, DROP_ROLE)) << "lava can't drop user2";

   result = execSql(getHost2(), "create role user2 password \'user200000000\';");
   ASSERT_TRUE(checkOut(result, CREATE_ROLE))
       << "lavaIntern can't create user2 in cluster2: " + result;

   result = execSql("lava", lava_pwd, "alter role user2 login;");
   ASSERT_TRUE(checkOut(result, ALTER_ROLE))
       << "lava can't grant login permission in cluster1 to user2: " + result;

   ASSERT_TRUE(testLogin("user2", "user200000000"))
       << "login as user2 in cluster1 failure";
   result = execSql(getHost2(), "drop role user2;");
   ASSERT_TRUE(checkOut(result, DROP_ROLE))
       << "drop user2 failure in cluster2: " + result;
   ASSERT_FALSE(testLogin("user2", "user200000000"))
       << "user2 can login in cluster1 after drop user2 in cluster1";
 }

 TEST_F(TestCloud, Normal) {
   Command::getCommandStatus("mkdir -p " + getTestRootPath() +
                             "/cloudtest/out/normal");
   configConnection();
   execSQLfile("cloudtest/sql/normal/before_normal.sql",
               "cloudtest/out/normal/before_normal.out");
   execSQLfileandCheck("cloudtest/sql/normal/all.sql",
                       "cloudtest/out/normal/all.out");
 }

 #define PROCESS_NUM 10
 #define ITERATION_NUM 1
 TEST_F(TestCloud, Parallel) {
   std::string result;
   Command::getCommandStatus("mkdir -p " + getTestRootPath() +
                             "/cloudtest/out/parallel");
   Command::getCommandStatus("rm -rf " + getTestRootPath() +
                             "/cloudtest/out/parallel/round*");
   configConnection();
   execSQLfile("cloudtest/sql/parallel/before_parallel.sql",
               "cloudtest/out/parallel/before_parallel.out");
   for (int i = 0; i < ITERATION_NUM; i++) {
     std::string outpath =
         "cloudtest/out/parallel/round" + std::to_string(i) + "/";
     Command::getCommandStatus("mkdir -p " + getTestRootPath() + "/" + outpath);
     runParallelSQLFile("cloudtest/sql/parallel/parallel.sql",
                        outpath + "parallel.out", PROCESS_NUM);
   }

   std::string outputFile;
   for (int i = 0; i < ITERATION_NUM; ++i)
     for (int j = 0; j < PROCESS_NUM; ++j) {
       outputFile = "cloudtest/out/parallel/round" + std::to_string(i) + "/" +
                    "parallel_process_" + std::to_string(j) + ".out";
       bool result = hawq::test::SQLUtility::checkPatternInFile(
           outputFile, ": ERROR:|FATAL|PANIC");
       EXPECT_TRUE(result) << outputFile << " find : ERROR:|FATAL|PANIC";
     }
 }

 TestCloud::TestCloud()
     : testRootPath(hawq::test::SQLUtility::getTestRootPath()), usexml(false) {
   setConfigXml("cloudtest/test_cloud.xml");
 }

 bool TestCloud::setConfigXml(const std::string &xmlfile) {
   if (xmlfile.empty()) {
     std::cout << "xml file should not be empty when you call setConfigXml";
     return false;
   } else {
     std::string xmlabsfile = testRootPath + "/" + xmlfile;
     if (!std::ifstream(xmlabsfile)) {
       std::cout << xmlabsfile << " doesn't exist";
       return false;
     }
     try {
       std::unique_ptr<hawq::test::XmlConfig> xmlconf;
       xmlconf.reset(new hawq::test::XmlConfig(xmlabsfile));
       xmlconf->parse();
       hostName = xmlconf->getString("cloud_host");
       cluster2host = xmlconf->getString("cloud_host2");
       port = xmlconf->getString("cloud_port", "5432");
       databaseName = xmlconf->getString("cloud_database", "postgres");
       userName = xmlconf->getString("cloud_user");
       usexml = true;
       xmlconf.release();
       return true;
     } catch (...) {
       std::cout << "Parse Xml file" << xmlabsfile << "error";
       return false;
     }
   }
 }

 void TestCloud::configConnection() {
   conn.reset(new hawq::test::PSQL(databaseName, hostName, port, userName,
                                   HAWQ_PASSWORD));
 }

 std::string TestCloud::getTestRootPath() const { return this->testRootPath; }

 void TestCloud::execSQLfile(const std::string &sqlFile,
                             const std::string &outFile) {
   std::string sqlFileAbsPath = testRootPath + "/" + sqlFile;
   std::string outFileAbsPath = testRootPath + "/" + outFile;
   conn->setOutputFile(outFileAbsPath);
   EXPECT_EQ(0, conn->runSQLFile(sqlFileAbsPath, "").getLastStatus());
   conn->resetOutput();
 }

 void TestCloud::execSQLfileandCheck(const std::string &sqlFile,
                                     const std::string &outFile) {
   execSQLfile(sqlFile, outFile);
   bool result = hawq::test::SQLUtility::checkPatternInFile(
       outFile, ": ERROR:|FATAL|PANIC");
   EXPECT_TRUE(result) << outFile << " find ERROR|FATAL|PANIC";
 }

 bool TestCloud::testLogin(const std::string &host, const std::string &portStr,
                           const std::string &database, const std::string &user,
                           const std::string &pwd) const {
   std::string loginCmd = "psql -h " + host + " -p " + portStr + " -d " +
                          database + " -U " + user + " --c '\\q'";
   std::string result = Command::getCommandOutput("export PGPASSWORD=\'" + pwd +
                                                  "\' && " + loginCmd);
   return result.empty();
 }

 bool TestCloud::testLogin(const std::string &user,
                           const std::string &pwd) const {
   return testLogin(hostName, port, databaseName, user, pwd);
 }

 bool TestCloud::testLogin(const std::string &pwd) const {
   return testLogin(hostName, port, databaseName, userName, pwd);
 }

 std::string TestCloud::execSql(const std::string &host,
                                const std::string &sql) {
   return execSql(host, port, databaseName, userName, HAWQ_PASSWORD, sql);
 }

 std::string TestCloud::execSql(const std::string &sql) {
   return execSql(userName, HAWQ_PASSWORD, sql);
 }

 std::string TestCloud::execSql(const std::string &user, const std::string &pwd,
                                const std::string &sql) {
   return execSql(hostName, port, databaseName, user, pwd, sql);
 }

 std::string TestCloud::execSql(const std::string &host,
                                const std::string &portStr,
                                const std::string &database,
                                const std::string &user, const std::string &pwd,
                                const std::string &sql) {
   std::string sqlCmd = "echo \"" + sql + "\" | psql -h " + host + " -p " +
                        portStr + " -d " + database + " -U " + user;
   std::string result = Command::getCommandOutput("export PGPASSWORD=\'" + pwd +
                                                  "\' && " + sqlCmd);
   return result;
 }

 bool TestCloud::checkOut(const std::string &out, const std::string &pattern) {
   return (out.find("ERROR:") != std::string::npos)
              ? false
              : (out.find(pattern) != std::string::npos);
 }

 void TestCloud::runParallelSQLFile(const std::string sqlFile,
                                    const std::string outputFile, int processnum,
                                    const std::string ansFile) {
   hawq::test::SQLUtility sqlUtil(this->databaseName, this->hostName, this->port,
                                  this->userName);
   sqlUtil.runParallelSQLFile(sqlFile, outputFile, processnum, ansFile);
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.
	*/

	#include <fstream>

	#include "lib/command.h"
	#include "lib/sql_util_parallel.h"
	#include "lib/xml_parser.h"
	#include "test_cloud.h"

	#define CREATE_ROLE "CREATE ROLE"
	#define ALTER_ROLE "ALTER ROLE"
	#define DROP_ROLE "DROP ROLE"

	using hawq::test::Command;

	TEST_F(TestCloud, Permissions) {
	ASSERT_TRUE(testLogin(getUserName(), HAWQ_PASSWORD))
	<< "Connect Error: Can't login as " + getUserName();
	execSql("drop role if exists lava;");
	execSql("drop role if exists user1;");
	execSql("drop role if exists user2;");
	execSql(getHost2(), "drop role if exists user2;");

	std::string result;
	result = execSql("create role lava password \'lava00000000\';");
	const std::string lava_pwd("lava00000000");
	ASSERT_TRUE(checkOut(result, CREATE_ROLE))
	<< "create role lava failure: " + result;
	EXPECT_FALSE(testLogin("lava", lava_pwd))
	<< "Error: lava can login before grant login permission";

	result = execSql("alter role lava login;");
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "grant lava login permission failure: " + result;
	ASSERT_TRUE(testLogin("lava", lava_pwd))
	<< "Error: lava can't login after grant login permission";

	result = execSql("alter role lava Superuser;");
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "grant lava Superuser permision failure: " + result;
	result = execSql("alter role lava Createrole;");
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "grant lava Createrole permision failure: " + result;
	result = execSql("lava", lava_pwd,
	"create role user1 login password \'user100000000\';");
	ASSERT_TRUE((checkOut(result, CREATE_ROLE)))
	<< "lava create user1 failure: " + result;
	ASSERT_TRUE(testLogin("user1", "user100000000")) << "login as user1 failure";

	result = execSql("lava", lava_pwd,
	"alter role user1 password \'newPwd00000000\';");
	const std::string user_newPwd = "newPwd00000000";
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "lava reset user1's password failure";
	EXPECT_FALSE(testLogin("user1", "user100000000"))
	<< "user1 can login after reset password";
	EXPECT_TRUE(testLogin("user1", user_newPwd))
	<< "user1 user new password can't login after reset password";

	result = execSql("user1", user_newPwd,
	"create role user2 password \'user200000000\'");
	EXPECT_FALSE(checkOut(result, CREATE_ROLE))
	<< "user1 can create user2 before get creatrole permissions: " + result;
	result = execSql("lava", lava_pwd, "alter role user1 createrole;");
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "lava grant user1 createrole permissions failure: " + result;
	result = execSql("user1", user_newPwd,
	"create role user2 password \'user200000000\'");
	ASSERT_TRUE(checkOut(result, CREATE_ROLE))
	<< "user1 can't create user2 after get creatrole permissions: " + result;

	result = execSql("lava", lava_pwd, "alter role user1 nocreaterole;");
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "lava can't revoke createrole from user1:" << result;
	result = execSql("user1", user_newPwd, "drop role user2;");
	ASSERT_FALSE(checkOut(result, DROP_ROLE))
	<< "user can drop user2 after revoked createrole permissions: " + result;

	result = execSql("lava", lava_pwd, "drop role user2;");
	ASSERT_TRUE(checkOut(result, DROP_ROLE)) << "lava can't drop user2";

	result = execSql(getHost2(), "create role user2 password \'user200000000\';");
	ASSERT_TRUE(checkOut(result, CREATE_ROLE))
	<< "lavaIntern can't create user2 in cluster2: " + result;

	result = execSql("lava", lava_pwd, "alter role user2 login;");
	ASSERT_TRUE(checkOut(result, ALTER_ROLE))
	<< "lava can't grant login permission in cluster1 to user2: " + result;

	ASSERT_TRUE(testLogin("user2", "user200000000"))
	<< "login as user2 in cluster1 failure";
	result = execSql(getHost2(), "drop role user2;");
	ASSERT_TRUE(checkOut(result, DROP_ROLE))
	<< "drop user2 failure in cluster2: " + result;
	ASSERT_FALSE(testLogin("user2", "user200000000"))
	<< "user2 can login in cluster1 after drop user2 in cluster1";
	}

	TEST_F(TestCloud, Normal) {
	Command::getCommandStatus("mkdir -p " + getTestRootPath() +
	"/cloudtest/out/normal");
	configConnection();
	execSQLfile("cloudtest/sql/normal/before_normal.sql",
	"cloudtest/out/normal/before_normal.out");
	execSQLfileandCheck("cloudtest/sql/normal/all.sql",
	"cloudtest/out/normal/all.out");
	}

	#define PROCESS_NUM 10
	#define ITERATION_NUM 1
	TEST_F(TestCloud, Parallel) {
	std::string result;
	Command::getCommandStatus("mkdir -p " + getTestRootPath() +
	"/cloudtest/out/parallel");
	Command::getCommandStatus("rm -rf " + getTestRootPath() +
	"/cloudtest/out/parallel/round*");
	configConnection();
	execSQLfile("cloudtest/sql/parallel/before_parallel.sql",
	"cloudtest/out/parallel/before_parallel.out");
	for (int i = 0; i < ITERATION_NUM; i++) {
	std::string outpath =
	"cloudtest/out/parallel/round" + std::to_string(i) + "/";
	Command::getCommandStatus("mkdir -p " + getTestRootPath() + "/" + outpath);
	runParallelSQLFile("cloudtest/sql/parallel/parallel.sql",
	outpath + "parallel.out", PROCESS_NUM);
	}

	std::string outputFile;
	for (int i = 0; i < ITERATION_NUM; ++i)
	for (int j = 0; j < PROCESS_NUM; ++j) {
	outputFile = "cloudtest/out/parallel/round" + std::to_string(i) + "/" +
	"parallel_process_" + std::to_string(j) + ".out";
	bool result = hawq::test::SQLUtility::checkPatternInFile(
	outputFile, ": ERROR:\|FATAL\|PANIC");
	EXPECT_TRUE(result) << outputFile << " find : ERROR:\|FATAL\|PANIC";
	}
	}

	TestCloud::TestCloud()
	: testRootPath(hawq::test::SQLUtility::getTestRootPath()), usexml(false) {
	setConfigXml("cloudtest/test_cloud.xml");
	}

	bool TestCloud::setConfigXml(const std::string &xmlfile) {
	if (xmlfile.empty()) {
	std::cout << "xml file should not be empty when you call setConfigXml";
	return false;
	} else {
	std::string xmlabsfile = testRootPath + "/" + xmlfile;
	if (!std::ifstream(xmlabsfile)) {
	std::cout << xmlabsfile << " doesn't exist";
	return false;
	}
	try {
	std::unique_ptr<hawq::test::XmlConfig> xmlconf;
	xmlconf.reset(new hawq::test::XmlConfig(xmlabsfile));
	xmlconf->parse();
	hostName = xmlconf->getString("cloud_host");
	cluster2host = xmlconf->getString("cloud_host2");
	port = xmlconf->getString("cloud_port", "5432");
	databaseName = xmlconf->getString("cloud_database", "postgres");
	userName = xmlconf->getString("cloud_user");
	usexml = true;
	xmlconf.release();
	return true;
	} catch (...) {
	std::cout << "Parse Xml file" << xmlabsfile << "error";
	return false;
	}
	}
	}

	void TestCloud::configConnection() {
	conn.reset(new hawq::test::PSQL(databaseName, hostName, port, userName,
	HAWQ_PASSWORD));
	}

	std::string TestCloud::getTestRootPath() const { return this->testRootPath; }

	void TestCloud::execSQLfile(const std::string &sqlFile,
	const std::string &outFile) {
	std::string sqlFileAbsPath = testRootPath + "/" + sqlFile;
	std::string outFileAbsPath = testRootPath + "/" + outFile;
	conn->setOutputFile(outFileAbsPath);
	EXPECT_EQ(0, conn->runSQLFile(sqlFileAbsPath, "").getLastStatus());
	conn->resetOutput();
	}

	void TestCloud::execSQLfileandCheck(const std::string &sqlFile,
	const std::string &outFile) {
	execSQLfile(sqlFile, outFile);
	bool result = hawq::test::SQLUtility::checkPatternInFile(
	outFile, ": ERROR:\|FATAL\|PANIC");
	EXPECT_TRUE(result) << outFile << " find ERROR\|FATAL\|PANIC";
	}

	bool TestCloud::testLogin(const std::string &host, const std::string &portStr,
	const std::string &database, const std::string &user,
	const std::string &pwd) const {
	std::string loginCmd = "psql -h " + host + " -p " + portStr + " -d " +
	database + " -U " + user + " --c '\\q'";
	std::string result = Command::getCommandOutput("export PGPASSWORD=\'" + pwd +
	"\' && " + loginCmd);
	return result.empty();
	}

	bool TestCloud::testLogin(const std::string &user,
	const std::string &pwd) const {
	return testLogin(hostName, port, databaseName, user, pwd);
	}

	bool TestCloud::testLogin(const std::string &pwd) const {
	return testLogin(hostName, port, databaseName, userName, pwd);
	}

	std::string TestCloud::execSql(const std::string &host,
	const std::string &sql) {
	return execSql(host, port, databaseName, userName, HAWQ_PASSWORD, sql);
	}

	std::string TestCloud::execSql(const std::string &sql) {
	return execSql(userName, HAWQ_PASSWORD, sql);
	}

	std::string TestCloud::execSql(const std::string &user, const std::string &pwd,
	const std::string &sql) {
	return execSql(hostName, port, databaseName, user, pwd, sql);
	}

	std::string TestCloud::execSql(const std::string &host,
	const std::string &portStr,
	const std::string &database,
	const std::string &user, const std::string &pwd,
	const std::string &sql) {
	std::string sqlCmd = "echo \"" + sql + "\" \| psql -h " + host + " -p " +
	portStr + " -d " + database + " -U " + user;
	std::string result = Command::getCommandOutput("export PGPASSWORD=\'" + pwd +
	"\' && " + sqlCmd);
	return result;
	}

	bool TestCloud::checkOut(const std::string &out, const std::string &pattern) {
	return (out.find("ERROR:") != std::string::npos)
	? false
	: (out.find(pattern) != std::string::npos);
	}

	void TestCloud::runParallelSQLFile(const std::string sqlFile,
	const std::string outputFile, int processnum,
	const std::string ansFile) {
	hawq::test::SQLUtility sqlUtil(this->databaseName, this->hostName, this->port,
	this->userName);
	sqlUtil.runParallelSQLFile(sqlFile, outputFile, processnum, ansFile);
	}