797 lines
31 KiB
Python
797 lines
31 KiB
Python
#!/usr/bin/python3
|
|
"""
|
|
Description: This script intended to run the Performance Tests on Windows, Linux and Mac.
|
|
Requirements:
|
|
Run setup_env_unix.sh( Linux and Mac ) or setup_env_windows.ps1( Windows ) before invoking this script.
|
|
modify lib/connect.php with the credentials to connect to the test database.
|
|
"""
|
|
|
|
import shutil
|
|
from shutil import copyfile
|
|
import os
|
|
import sys
|
|
import argparse
|
|
import subprocess
|
|
import fileinput
|
|
import subprocess
|
|
from subprocess import call
|
|
import xml.etree.ElementTree as ET
|
|
import pyodbc
|
|
import platform
|
|
import re
|
|
import datetime
|
|
import time
|
|
from time import strftime
|
|
import hashlib
|
|
|
|
"""
|
|
Paths to current benchmarks. These constants should be modified if there are any changes in folder structure of the project.
|
|
"""
|
|
|
|
sqlsrv_path = "benchmark" + os.sep + "sqlsrv"
|
|
pdo_path = "benchmark" + os.sep + "pdo_sqlsrv"
|
|
|
|
"""
|
|
Path to the connect.php file that contains test database credentials. Note that, the benchmarks are run against this database and it is different from Result database.
|
|
"""
|
|
connect_file = "lib" + os.sep + "connect.php"
|
|
connect_file_bak = connect_file + ".bak"
|
|
result_file = "lib" + os.sep + "result_db.php"
|
|
|
|
"""
|
|
Global data format used across the script
|
|
"""
|
|
fmt = "%Y-%m-%d %H:%M:%S.0000000"
|
|
|
|
def validate_platform( platform_name ):
|
|
"""
|
|
This module validates the platform name passed in to the script as an argument.
|
|
If no match, the script will stop the execution.
|
|
Args:
|
|
platform_name (str): Platform name to validate
|
|
Returns:
|
|
N/A
|
|
"""
|
|
platforms = [
|
|
"Windows10"
|
|
, "WindowsServer2016"
|
|
, "WindowsServer2012"
|
|
, "Ubuntu16"
|
|
, "RedHat7"
|
|
, "SUSE12"
|
|
, "Sierra"]
|
|
if platform_name not in platforms:
|
|
print ( "Platform must be one of the following:" )
|
|
print( platforms )
|
|
exit( 1 )
|
|
|
|
class DB( object ):
|
|
"""
|
|
A class to keep database credentials
|
|
Attributes:
|
|
server_name (str): The name or the IP address of the server.
|
|
database_name (str): The name of the database
|
|
username (str): Database username
|
|
password (str): Database password for username
|
|
"""
|
|
def __init__ ( self
|
|
, server_name = None
|
|
, database_name = None
|
|
, username = None
|
|
, password = None):
|
|
self.server_name = server_name
|
|
self.database_name = database_name
|
|
self.username = username
|
|
self.password = password
|
|
|
|
class XMLResult( object ):
|
|
"""
|
|
A class to keep a result set of a benchmark generated by PHPBench as an XML file.
|
|
Attributes:
|
|
benchmark_name (str): The name or the benchmark.
|
|
success (int): 0 or 1. 0 if the benchmark failed to execute, 1 if the execution was successful.
|
|
duration (int,optional): In case of success, time taken to run the benchmark.
|
|
memory (int, optional): In case of success, memory peak when executing the benchmark.
|
|
iterations(int, optional): In case of success, number of iterations the benchmark was run for.
|
|
error_message(str, optional): In case of failure, descriptive error message.
|
|
"""
|
|
def __init__ ( self
|
|
, benchmark_name = None
|
|
, success = None
|
|
, duration = None
|
|
, memory = None
|
|
, iterations = None
|
|
, error_message = None ):
|
|
self.benchmark_name = benchmark_name
|
|
self.success = success
|
|
self.duration = duration
|
|
self.memory = memory
|
|
self.iterations = iterations
|
|
self.error_message = error_message
|
|
|
|
def get_test_name( name ):
|
|
"""
|
|
This module maps PHPBench benchmark names to the names that are used accross the teams.
|
|
Args:
|
|
name (str): Name of the benchmark
|
|
Returns:
|
|
The mapped name
|
|
Raises:
|
|
KeyError when the name passed in does not match any of the keys
|
|
"""
|
|
test_name_dict = {
|
|
'SqlsrvConnectionBench': 'connection'
|
|
, 'SqlsrvCreateDbTableProcBench': 'create'
|
|
, 'SqlsrvCRUDBench': 'crud'
|
|
, 'SqlsrvInsertBench': 'crud-create'
|
|
, 'SqlsrvFetchBench': 'crud-retrieve'
|
|
, 'SqlsrvUpdateBench': 'crud-update'
|
|
, 'SqlsrvDeleteBench': 'crud-delete'
|
|
, 'SqlsrvFetchLargeBench': 'large'
|
|
, 'SqlsrvSelectVersionBench': 'version'
|
|
, 'PDOConnectionBench': 'connection'
|
|
, 'PDOCreateDbTableProcBench': 'create'
|
|
, 'PDOCRUDBench': 'crud'
|
|
, 'PDOInsertBench': 'crud-create'
|
|
, 'PDOFetchBench': 'crud-retrieve'
|
|
, 'PDOUpdateBench': 'crud-update'
|
|
, 'PDODeleteBench': 'crud-delete'
|
|
, 'PDOFetchLargeBench': 'large'
|
|
, 'PDOSelectVersionBench': 'version'
|
|
}
|
|
return test_name_dict[ name ]
|
|
|
|
def get_run_command( path_to_tests, dump_file ):
|
|
"""
|
|
This module returns the command to run the tests
|
|
Args:
|
|
path_to_tests (str): The folder that contains the tests to be run
|
|
dump_file (str): The name of the XML file to output the results
|
|
Returns:
|
|
The command to run the tests
|
|
"""
|
|
command = "vendor" + os.sep + "bin" + os.sep + "phpbench run {0} --dump-file={1}"
|
|
return command.format( path_to_tests, dump_file )
|
|
|
|
def get_id( conn, id_field, table, name_field, value ):
|
|
"""
|
|
This module returns id of an entry when value is a string
|
|
Args:
|
|
conn (obj): A connection to the result database
|
|
id_field (str): The name of the id column
|
|
table (str): The name of the table that contains the entry
|
|
name_field (str): The name of the field to compare the value against
|
|
value (str): The value that its id is requested
|
|
Returns:
|
|
id of the value if the value exists in the table, None otherwise
|
|
"""
|
|
query = "SELECT {0} FROM {1} WHERE {2}='{3}'"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( id_field, table, name_field, value ))
|
|
id = cursor.fetchone()
|
|
cursor.close()
|
|
if id is not None:
|
|
return id[0]
|
|
return id
|
|
|
|
def get_id_no_quote( conn, id_field, table, name_field, value ):
|
|
"""
|
|
This module returns id of an entry when value is not a string.
|
|
@TODO This is a hack, could not get binary binding working with pyodbc.
|
|
This module should be removed and get_id should use binding parameters.
|
|
Args:
|
|
conn (obj): A connection to the result database
|
|
id_field (str): The name of the id column
|
|
table (str): The name of the table that contains the entry
|
|
name_field (str): The name of the field to compare the value against
|
|
value (bin): The value that its id is requested
|
|
Returns:
|
|
id of the value if the value exists in the table, None otherwise
|
|
"""
|
|
query = "SELECT {0} FROM {1} WHERE {2}={3}"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( id_field, table, name_field, value ))
|
|
id = cursor.fetchone()
|
|
cursor.close()
|
|
if id is not None:
|
|
return id[0]
|
|
return id
|
|
|
|
def get_test_database( database_file ):
|
|
"""
|
|
This module reads test database details from connect.php and stores them into an instance of DB class
|
|
Returns:
|
|
A DB object that contains database credentials
|
|
"""
|
|
test_db = DB()
|
|
for line in open( database_file ):
|
|
if "server" in line:
|
|
test_db.server_name = line.split("=")[1].strip()[1:-2]
|
|
elif "database" in line:
|
|
test_db.database_name = line.split("=")[1].strip()[1:-2]
|
|
elif "uid" in line:
|
|
test_db.username = line.split("=")[1].strip()[1:-2]
|
|
elif "pwd" in line:
|
|
test_db.password = line.split("=")[1].strip()[1:-2]
|
|
return test_db
|
|
|
|
def connect( db ):
|
|
"""
|
|
This module creates a connection to the given database
|
|
Args:
|
|
db (obj): database object
|
|
Returns:
|
|
A connection object to the given database
|
|
"""
|
|
return pyodbc.connect(
|
|
driver="{ODBC Driver 13 for SQL Server}"
|
|
, host=db.server_name
|
|
, database=db.database_name
|
|
, user=db.username
|
|
, password=db.password
|
|
, autocommit = True)
|
|
|
|
def get_server_version( server ):
|
|
"""
|
|
This module returns the version of the given server
|
|
Args:
|
|
server (obj): Server object to connect to
|
|
Returns:
|
|
The output of @@Version
|
|
"""
|
|
conn = connect( server )
|
|
cursor = conn.cursor()
|
|
cursor.execute( "SELECT @@VERSION")
|
|
version = cursor.fetchone()[0]
|
|
cursor.close()
|
|
return version
|
|
|
|
def get_sha1_file( filename ):
|
|
"""
|
|
This module generates sha1sum for the given file
|
|
Args:
|
|
filename (str): Full path to the file
|
|
Returns:
|
|
sha1sum hash of the file
|
|
"""
|
|
hash_size = 256
|
|
sha1 = hashlib.sha1()
|
|
with open( filename, 'rb' ) as f:
|
|
while True:
|
|
data = f.read( hash_size )
|
|
if not data:
|
|
break
|
|
sha1.update( data )
|
|
return "0x" + sha1.hexdigest()
|
|
|
|
def insert_server_entry( conn, server_name, server_version ):
|
|
"""
|
|
This module inserts a new entry into Servers table
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
server_name (str): Name of the Test Server that the tests are run against
|
|
server_version (str): @@Version of the Test Server
|
|
Returns:
|
|
N/A
|
|
"""
|
|
query = "INSERT INTO Servers ( HostName, Version ) VALUES ( '{0}', '{1}' )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( server_name, server_version ))
|
|
cursor.close()
|
|
|
|
def insert_client_entry ( conn, name ):
|
|
"""
|
|
This module inserts a new entry into Clients table
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
name (str): Name of the Client machine that the tests are run on
|
|
Returns:
|
|
N/A
|
|
"""
|
|
query = "INSERT INTO Clients ( HostName ) VALUES( '{0}' )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( name ))
|
|
cursor.close()
|
|
|
|
def insert_team_entry ( conn, name ):
|
|
"""
|
|
This module inserts a new entry into Teams table
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
name (str): Team name
|
|
Returns:
|
|
N/A
|
|
"""
|
|
query = "INSERT INTO Teams ( TeamName ) VALUES( '{0}' )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( name ))
|
|
cursor.close()
|
|
|
|
def insert_test_entry( conn, name ):
|
|
"""
|
|
This module inserts a new entry into PerformanceTests table
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
name (str): Test name
|
|
Returns:
|
|
N/A
|
|
"""
|
|
#TO-DO Remove unnecessary columns from the table and fix the query string. Amd64 and 0 are used to bypass not null
|
|
query = "INSERT INTO PerformanceTests ( TestName, Arch, HashVer ) VALUES( '{0}', 'Amd64', 0 )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( name ))
|
|
cursor.close()
|
|
|
|
def insert_driver_entry( conn, driver_path, driver_hash ):
|
|
"""
|
|
This module inserts a new entry into Drivers table
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
name (str): Full path to the driver
|
|
driver_hash (bin): sha1sum hash of the driver
|
|
Returns:
|
|
N/A
|
|
"""
|
|
file_date = time.strftime( fmt, time.gmtime( os.path.getmtime( driver_path )))
|
|
query = "INSERT INTO Drivers ( Arch, FileDate, SHA1, HashVer ) VALUES ( ?, ?, {0}, 1 )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format(driver_hash), ( get_php_arch(), file_date ))
|
|
cursor.close()
|
|
|
|
def get_server_id( conn, test_db ):
|
|
"""
|
|
This module retrieves the id of a Server entry. If the given server does not exist in Servers table,
|
|
the module inserts it into the Servers table and retrieves its id.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
test_db (obj): An object that contains Test Server details
|
|
Returns:
|
|
id of the given server
|
|
"""
|
|
server_id = get_id( conn, "ServerId", "Servers", "HostName", test_db.server_name )
|
|
if server_id is None:
|
|
insert_server_entry( conn, test_db.server_name, get_server_version( test_db ))
|
|
server_id = get_id( conn, "ServerId", "Servers", "HostName", test_db.server_name )
|
|
return server_id
|
|
|
|
def get_client_id( conn ):
|
|
"""
|
|
This module retrieves the id of a Client entry. If the given client does not exist in Clients table,
|
|
the module inserts it into the Clients table and retrieves its id.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
Returns:
|
|
id of the client
|
|
"""
|
|
client_name = platform.node()
|
|
client_id = get_id( conn, "ClientId", "Clients", "HostName", client_name )
|
|
if client_id is None:
|
|
insert_client_entry( conn, client_name )
|
|
client_id = get_id( conn, "ClientId", "Clients", "HostName", client_name )
|
|
return client_id
|
|
|
|
def get_team_id( conn ):
|
|
"""
|
|
This module retrieves the id of a Team entry. If the given team name - PHP does not exist in Teams table,
|
|
the module inserts it into the Teams table and retrieves its id.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
Returns:
|
|
id of the team
|
|
"""
|
|
team_name = "PHP"
|
|
team_id = get_id( conn, "TeamId", "Teams", "TeamName", team_name)
|
|
if team_id is None:
|
|
insert_team_entry( conn, team_name )
|
|
team_id = get_id( conn, "TeamId", "Teams", "TeamName", team_name)
|
|
return team_id
|
|
|
|
def get_test_id( conn, test_name ):
|
|
"""
|
|
This module retrieves the id of a Test entry. If the given test does not exists in PerformanceTests table,
|
|
the module inserts it into the PerformanceTests table and retrieves its id.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
test_name (str): The name of the test that the id is requested for
|
|
Returns:
|
|
id of the test
|
|
"""
|
|
test_id = get_id( conn, "TestId", "PerformanceTests", "TestName", test_name )
|
|
if test_id is None:
|
|
insert_test_entry( conn, test_name )
|
|
test_id = get_id( conn, "TestId", "PerformanceTests", "TestName", test_name )
|
|
return test_id
|
|
|
|
def get_driver_id( conn, driver_name ):
|
|
"""
|
|
This module retrieves the id of a Driver entry. If the given driver does not exists in Drivers table,
|
|
the module inserts it into the Drivers table and retrieves its id.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
driver_name (str): The name of the driver that the id is requested for
|
|
Returns:
|
|
id of the driver
|
|
"""
|
|
driver_path = get_path_to_driver( driver_name )
|
|
driver_hash = get_sha1_file( driver_path )
|
|
driver_id = get_id_no_quote( conn, "DriverId", "Drivers", "SHA1", driver_hash )
|
|
if driver_id is None:
|
|
insert_driver_entry( conn, driver_path, driver_hash )
|
|
driver_id = get_id_no_quote( conn, "DriverId", "Drivers", "SHA1", driver_hash )
|
|
return driver_id
|
|
|
|
def insert_result_entry_and_get_id( conn, test_id, client_id, driver_id, server_id, team_id, success ):
|
|
"""
|
|
This module inserts a new result entry into PerformanceResults table and retrieves its id.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
test_id (int): The id of the test
|
|
client_id (int): The id of the client that the test was run on
|
|
driver_id (int): The id of the driver that the test was run against
|
|
server_id (int): The id of the server that the test was run against
|
|
team_id (int): The id of the team that the test belongs to
|
|
success (int): 0 if the test failed, 1 otherwise
|
|
Returns:
|
|
id of the result
|
|
"""
|
|
query = "INSERT INTO PerformanceResults( TestId, ClientId, DriverId, ServerId, TeamId, Success ) OUTPUT INSERTED.ResultId VALUES( {0}, {1}, {2}, {3}, {4}, {5} )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( test_id, client_id, driver_id, server_id, team_id, success ))
|
|
result_id = cursor.fetchone()
|
|
cursor.close()
|
|
if result_id is not None:
|
|
return result_id[0]
|
|
return id
|
|
|
|
def insert_result_key_value( conn, table_name, result_id, key, value ):
|
|
"""
|
|
This module inserts a new entry into a key-value table.
|
|
Args:
|
|
conn (obj): Connection object to the Results database
|
|
table_name (string): The name of the table. Current possible values: KeyValueTableBigInt, KeyValueTableDate, KeyValueTableString
|
|
result_id (int): The result id that is associated with the key-value table
|
|
key (str): name of the property
|
|
value (int, date, string): The value of the key
|
|
Returns:
|
|
N/A
|
|
"""
|
|
query = "INSERT INTO {0} ( ResultId, name, value ) VALUES( ?, ?, ? )"
|
|
cursor = conn.cursor()
|
|
cursor.execute( query.format( table_name ), ( result_id, key, value ) )
|
|
cursor.close()
|
|
|
|
def get_php_arch():
|
|
"""
|
|
This module determines the architecture of the default php of the system
|
|
Args:
|
|
N/A
|
|
Returns
|
|
x86 or x64
|
|
"""
|
|
p = subprocess.Popen( "php -r \"echo PHP_INT_SIZE;\"", stdout=subprocess.PIPE, shell = True )
|
|
out, err = p.communicate()
|
|
if out.decode('ascii') == "8":
|
|
return "x64"
|
|
elif out.decode('ascii') == "4":
|
|
return "x86"
|
|
|
|
def get_php_version():
|
|
"""
|
|
This module determines the version of the default php of the system
|
|
Args:
|
|
N/A
|
|
Returns:
|
|
php version
|
|
"""
|
|
p = subprocess.Popen( "php -r \"echo phpversion();\"", stdout=subprocess.PIPE, shell = True )
|
|
out, err = p.communicate()
|
|
return out.decode('ascii')
|
|
|
|
def get_php_thread():
|
|
"""
|
|
This module determines the thread safety of the default php of the system
|
|
Args:
|
|
N/A
|
|
Returns:
|
|
nts or ts
|
|
"""
|
|
if os.name == 'nt':
|
|
command = "php -i | findstr \"Thread\""
|
|
else:
|
|
command = "php -i | grep 'Thread'"
|
|
p = subprocess.Popen( command, stdout=subprocess.PIPE, shell = True )
|
|
out, err = p.communicate()
|
|
if out.decode('ascii').split()[3].strip() == 'disabled':
|
|
return "nts"
|
|
else:
|
|
return "ts"
|
|
|
|
def get_driver_version( driver_name ):
|
|
"""
|
|
This module determines the version of the given php driver.
|
|
Args:
|
|
driver_name (str): Name of the driver. Possible values sqlsrv and pdo_sqlsrv
|
|
Returns:
|
|
The version of the given driver
|
|
"""
|
|
command = "php -r \"echo phpversion('{0}');\""
|
|
p = subprocess.Popen( command.format( driver_name ), stdout=subprocess.PIPE, shell = True )
|
|
out, err = p.communicate()
|
|
return out.decode('ascii')
|
|
|
|
def get_msodbcsql_version( test_db ):
|
|
"""
|
|
This module determines the version of MSODBCSQL using the sqlsrv driver.
|
|
Args:
|
|
test_db (obj): An object that contains Test Server details
|
|
Returns:
|
|
MSODBCSQL version
|
|
"""
|
|
command = "php -r \"echo sqlsrv_client_info( sqlsrv_connect( '{0}', array( 'UID'=>'{1}', 'PWD'=>'{2}')))['DriverVer'];\""
|
|
p = subprocess.Popen( command.format( test_db.server_name, test_db.username, test_db.password ), stdout=subprocess.PIPE, shell = True )
|
|
out, err = p.communicate()
|
|
return out.decode('ascii')
|
|
|
|
def get_path_to_driver( driver_name ):
|
|
"""
|
|
This module returns the full path to the given php driver
|
|
Args:
|
|
driver_name (str): Name of the driver. Possible values sqlsrv and pdo_sqlsrv
|
|
Returns:
|
|
Full path to the given driver
|
|
"""
|
|
p = subprocess.Popen( "php -r \"echo ini_get('extension_dir');\"", stdout=subprocess.PIPE, shell = True )
|
|
out, err = p.communicate()
|
|
extension_dir = out.decode('ascii')
|
|
if os.name == 'nt':
|
|
return extension_dir + os.sep + "php_" + driver_name + ".dll"
|
|
else:
|
|
return extension_dir + os.sep + driver_name + ".so"
|
|
|
|
def enable_mars():
|
|
"""
|
|
This module enables MARS by modifying connect.php file
|
|
"""
|
|
print( "Enabling MARS...")
|
|
with fileinput.FileInput( connect_file, inplace=True, backup='.bak') as file:
|
|
for line in file:
|
|
print( line.replace( "$mars=false;", "$mars=true;" ), end='')
|
|
|
|
def disable_mars():
|
|
"""
|
|
This module disables MARS by modifying connect.php file
|
|
"""
|
|
print( "Disabling MARS...")
|
|
os.remove( connect_file )
|
|
copyfile( connect_file_bak, connect_file )
|
|
|
|
def enable_pooling():
|
|
"""
|
|
This module enables Connection Pooling.
|
|
On Windows, this is done by modifying connect.php file.
|
|
On Linux and Mac, odbcinst.ini file needs to be modified.
|
|
@TO-DO: Currently modifying odbcinst.ini requires root permissions.
|
|
Copy the MSODBCSQL to a location which does not require sudo.
|
|
"""
|
|
print( "Enabling Pooling...")
|
|
if os.name == 'nt':
|
|
with fileinput.FileInput( connect_file, inplace=True, backup='.bak') as file:
|
|
for line in file:
|
|
print( line.replace( "$pooling=false;", "$pooling=true;" ), end='')
|
|
else:
|
|
# Get the location of odbcinst.ini
|
|
odbcinst = os.popen( "odbcinst -j" ).read().splitlines()[1].split()[1]
|
|
odbcinst_bak = odbcinst + ".bak"
|
|
|
|
# Create a copy of odbcinst.ini
|
|
copyfile( odbcinst, odbcinst_bak )
|
|
|
|
# Lines to enable Connection pooling
|
|
lines_to_append="CPTimeout=5\n[ODBC]\nPooling=Yes\n"
|
|
|
|
with open( odbcinst, "a" ) as f:
|
|
f.write( lines_to_append )
|
|
|
|
def disable_pooling():
|
|
"""
|
|
This module disables Connection Pooling.
|
|
On Windows, this is done by modifying connect.php file.
|
|
On Linux and Mac, odbcinst.ini file needs to be modified.
|
|
@TO-DO: Currently modifying odbcinst.ini requires root permissions.
|
|
Copy the MSODBCSQL to a location which does not require sudo.
|
|
"""
|
|
print("Disabling Pooling...")
|
|
if os.name == 'nt':
|
|
os.remove( connect_file )
|
|
copyfile( connect_file_bak, connect_file )
|
|
else:
|
|
# Get the location of odbcinst.ini
|
|
odbcinst = os.popen( "odbcinst -j" ).read().splitlines()[1].split()[1]
|
|
odbcinst_bak = odbcinst + ".bak"
|
|
os.remove( odbcinst )
|
|
copyfile( odbcinst_bak, odbcinst )
|
|
os.remove( odbcinst_bak )
|
|
|
|
def run_tests( php_driver, test_name ):
|
|
"""
|
|
This module runs the tests using PHPBench
|
|
Args:
|
|
php_driver (str): Name of the driver to be tested: sqlsrv, pdo_sqlsrv, or both
|
|
test_name (str): File name of the test or all
|
|
Returns:
|
|
N/A
|
|
"""
|
|
print("Running the tests...")
|
|
add_to_path = ''
|
|
if test_name != 'all':
|
|
add_to_path = os.sep + test_name
|
|
if php_driver == 'sqlsrv' or php_driver == 'both':
|
|
call( get_run_command( sqlsrv_path + add_to_path, "sqlsrv-results.xml" ), shell=True )
|
|
if php_driver == 'pdo_sqlsrv' or php_driver == 'both':
|
|
call( get_run_command( pdo_path + add_to_path, "pdo_sqlsrv-results.xml" ), shell=True )
|
|
|
|
def parse_results( dump_file ):
|
|
"""
|
|
This module parses the .xml files generated by PHPBench
|
|
@TO-DO: Currently only limited detailes are parsed, such as duration and peak memory.
|
|
PHPBench reports a lot more information that can be helpful.
|
|
Consider looking at the xml files.
|
|
Args:
|
|
dump_file (str): The name of the XML file to be parsed.
|
|
Returns:
|
|
An array of XMLResult objects, where each object contains benchmark information, such as duration and memory.
|
|
"""
|
|
xml_results = []
|
|
tree = ET.parse( dump_file )
|
|
root = tree.getroot()
|
|
# The following lines assume a certain xml structure.
|
|
# Get all the benchmarks in a list
|
|
benchmarks = root[0].findall( 'benchmark' )
|
|
for benchmark in benchmarks:
|
|
xml_result = XMLResult()
|
|
#Get the benchmark name and remove the leasing backslash
|
|
xml_result.benchmark_name = benchmark.get( 'class' )[1:]
|
|
errors = benchmark[0][0].find( 'errors' )
|
|
# Store the error message and mark the benchmark as failed if something went wrong when running the benchmark.
|
|
if( errors is not None ):
|
|
xml_result.success = 0
|
|
xml_result.error_message = errors[0].text
|
|
# If the bechmark was run successfully, parse the results. This is where you would add code to parse more details about the benchmark.
|
|
else:
|
|
xml_result.success = 1
|
|
# convert microseconds to seconds
|
|
xml_result.duration = int( round( int( benchmark[0][0].find( 'stats' ).get( 'sum' )) / 1000000 ))
|
|
iterations = benchmark[0][0].findall( 'iteration' )
|
|
xml_result.iterations = len( iterations )
|
|
# Memory peak is an iteration specific, so going through all the iterations and capturing the highest.
|
|
# Memory peak is usually the same for all iterations.
|
|
memory_peak = 0
|
|
for iteration in iterations:
|
|
iter_memory_peak = int( iteration.get( 'mem-peak' ))
|
|
if iter_memory_peak > memory_peak:
|
|
memory_peak = iter_memory_peak
|
|
xml_result.memory = memory_peak
|
|
xml_results.append( xml_result )
|
|
return xml_results
|
|
|
|
def parse_and_store_results( dump_file, test_db, result_db, platform, driver, start_time, mars, pooling ):
|
|
"""
|
|
This module parses the given xml file and stores the results into Result Database.
|
|
Args:
|
|
dump_file (str): Name of the xml file that containst the results from PHPBench
|
|
test_db (obj): An object that contains Test Database details
|
|
result_db (obj): An object that contains Result Database details
|
|
platform (str): The platform name that the tests are run on
|
|
driver (str): Name of the driver, sqlsrv or pdo_sqlsrv
|
|
start_time (date): Time when the script was run
|
|
mars (int): 0 to turn MARS off, 1 otherwise
|
|
pooling (int): 0 to turn Connection Pooling off, 1 otherwise
|
|
Returns:
|
|
N/A
|
|
"""
|
|
# Check if the xml file actually exist
|
|
if not os.path.exists(dump_file):
|
|
print(dump_file + " does not exist")
|
|
return
|
|
|
|
# Connect to the Result Database
|
|
conn = connect( result_db )
|
|
|
|
server_id = get_server_id( conn, test_db )
|
|
client_id = get_client_id( conn )
|
|
team_id = get_team_id( conn )
|
|
driver_id = get_driver_id( conn, driver )
|
|
|
|
|
|
php_arch = get_php_arch()
|
|
php_thread = get_php_thread()
|
|
php_version = get_php_version()
|
|
driver_version = get_driver_version( driver )
|
|
msodbcsql_version = get_msodbcsql_version( test_db )
|
|
|
|
cursor = conn.cursor()
|
|
#parse the results from xml file
|
|
results = parse_results( dump_file )
|
|
# Store every result into the Result Database
|
|
for result in results:
|
|
test_name = get_test_name( result.benchmark_name )
|
|
test_id = get_test_id( conn, test_name )
|
|
result_id = insert_result_entry_and_get_id( conn, test_id, client_id, driver_id, server_id, team_id, result.success )
|
|
|
|
if result.success:
|
|
insert_result_key_value( conn, "KeyValueTableBigInt", result_id, "duration", result.duration )
|
|
insert_result_key_value( conn, "KeyValueTableBigInt", result_id, "memory", result.memory )
|
|
insert_result_key_value( conn, "KeyValueTableBigInt", result_id, "iterations", result.iterations)
|
|
else:
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "error", result.error_message )
|
|
|
|
insert_result_key_value( conn, "KeyValueTableDate" , result_id, "startTime" , start_time )
|
|
insert_result_key_value( conn, "KeyValueTableBigInt", result_id, "mars" , mars )
|
|
insert_result_key_value( conn, "KeyValueTableBigInt", result_id, "pooling" , pooling )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "driver" , driver )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "php_arch" , php_arch )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "os" , platform )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "php_thread" , php_thread )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "php_version" , php_version )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "msodbcsql" , msodbcsql_version )
|
|
insert_result_key_value( conn, "KeyValueTableString", result_id, "driver_version" , driver_version )
|
|
|
|
def parse_and_store_results_all( test_db, result_db, platform, start_time, mars, pooling ):
|
|
"""
|
|
This module parses the given sqlsrv-regular.xml, sqlsrv-large.xml,pdo_sqlsrv-regular.xml, pdo_sqlsrv-large.xml and stores the results into Result Database.
|
|
Args:
|
|
test_db (obj): An object that contains Test Database details
|
|
result_db (obj): An object that contains Result Database details
|
|
platform (str): The platform name that the tests are run on
|
|
start_time (date): Time when the script was run
|
|
mars (int): 0 to turn MARS off, 1 otherwise
|
|
pooling (int): 0 to turn Connection Pooling off, 1 otherwise
|
|
Returns:
|
|
N/A
|
|
|
|
"""
|
|
print("Parsing and storing the results...")
|
|
parse_and_store_results( "sqlsrv-results.xml", test_db, result_db, platform, "sqlsrv", start_time, mars, pooling )
|
|
parse_and_store_results( "pdo_sqlsrv-results.xml", test_db, result_db, platform, "pdo_sqlsrv", start_time, mars, pooling )
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument( '-platform', '--PLATFORM', required=True, help='The name of the platform the tests run on' )
|
|
parser.add_argument( '-php-driver', '--PHP_DRIVER', default='both', help='Name of the PHP driver: sqlsrv, pdo_sqlsrv or both')
|
|
parser.add_argument( '-testname', '--TESTNAME', default='all', help='File name for only one test or all' )
|
|
args = parser.parse_args()
|
|
|
|
# Start time is recorded only in the beginning of this script execution. So it is not benchmark specific.
|
|
# Start time can be used to group the results
|
|
start_time = datetime.datetime.now().strftime( fmt )
|
|
print( "Start time: " + start_time )
|
|
|
|
validate_platform( args.PLATFORM )
|
|
result_db = get_test_database( result_file )
|
|
test_db = get_test_database( connect_file )
|
|
|
|
print("Running the tests with default settings...")
|
|
|
|
run_tests( args.PHP_DRIVER, args.TESTNAME )
|
|
parse_and_store_results_all( test_db, result_db, args.PLATFORM, start_time, 0, 0 )
|
|
"""
|
|
The following lines are commented out, because it already takes a long time to run the tests with the default settings.
|
|
Echo block can be uncommented and run separately.
|
|
|
|
print("Running the tests with MARS ON...")
|
|
enable_mars()
|
|
run_tests( args.PHP_DRIVER, args.TESTNAME )
|
|
parse_and_store_results_all( test_db, result_db, args.PLATFORM, start_time, 1, 0 )
|
|
disable_mars()
|
|
|
|
|
|
print("Running the tests with Pooling ON...")
|
|
enable_pooling()
|
|
run_tests( args.PHP_DRIVER, args.TESTNAME )
|
|
parse_and_store_results_all( test_db, result_db, args.PLATFORM, start_time, 0, 1 )
|
|
disable_pooling()
|
|
"""
|
|
exit()
|
|
|
|
|