def check():
env.platform_family = detect.detect()
site = "http://localhost/"
string = env.string
assert file.exists('/var/www/vhosts/application/index.php'), \
'/var/www/vhosts/application/index.php did not exist'
assert port.is_listening(80), 'port 80/apache2 is not listening'
assert port.is_listening(3306), 'port 3306/mysqld is not listening'
assert port.is_listening(11211), 'port 11211/memcached is not listening'
assert user.exists('mysql'), 'mysql user does not exist'
assert user.exists('memcache'), 'memcache user does not exist'
assert process.is_up('apache2'), 'apache2 is not running'
assert process.is_up('mysqld'), 'mysqld is not running'
assert process.is_up('memcached'), 'memcached is not running'
assert service.is_enabled('apache2'), 'apache2 service not enabled'
assert service.is_enabled('mysql'), 'mysql service not enabled'
assert service.is_enabled('memcached'), 'memcached service not enabled'
assert http_check(site, string), 'Apache is not responding as expected.'
def check():
env.platform_family = detect.detect()
# web server is listening
assert port.is_listening(80), 'Web port 80 is not listening'
# redis is listening
assert port.is_listening(6381), 'Redis port 6381 is not listening'
# nginx user is created
assert user.exists("nginx"), 'nginx user does not exist'
# domain ftp user is created
assert user.exists("magento_sftp"), 'magento_sftp user does not exist'
# processes are running
assert process.is_up("nginx"), 'nginx is not running'
assert process.is_up("php-fpm"), 'php-fpm is not running'
assert process.is_up("redis"), 'redis is not running'
# services are enabled
assert service.is_enabled("nginx"), 'nginx service not enabled'
assert service.is_enabled("redis"), 'redis service not enabled'
assert service.is_enabled("php-fpm"), 'php-fpm not enabled'
assert service.is_enabled("mysql"), 'database service not enabled'
# magento main page is available
assert magento_is_responding(), 'Magento did not respond as expected.'
def check():
env.platform_family = detect.detect()
packages = ['st2',
'st2chatops',
'st2mistral',
'st2web',
'rabbitmq-server',
'mongodb-org-server',
'postgresql'
]
services = ['st2api',
'st2sensorcontainer',
'mistral',
'st2resultstracker',
'rabbitmq-server',
'mongod',
'postgresql'
]
for pkg in packages:
assert package.installed(pkg),\
"package {0} is not installed".format(pkg)
for srv in services:
assert service.is_enabled(srv),\
"service {0} is not enabled".format(srv)
assert user.exists("stanley"), "user stanley does not exist"
def check():
env.platform_family = detect.detect()
# web server is listening
assert port.is_listening(80), 'Web port 80 is not listening'
# redis is listening
assert port.is_listening(6379), 'Redis port 6379 is not listening'
assert port.is_listening(6380), 'Redis port 6380 is not listening'
assert port.is_listening(6381), 'Redis port 6381 is not listening'
# nginx user is created
assert user.exists("nginx"), 'nginx user does not exist'
if (env.platform_family == "rhel"):
assert process.is_up('nginx'), 'nginx is not running'
assert process.is_up('php-fpm'), 'php-fpm is not running'
assert service.is_enabled('nginx'), 'nginx is not enabled'
assert service.is_enabled('php-fpm'), 'php-fpm is not enabled'
elif (env.platform_family == 'debian'):
assert process.is_up('nginx'), 'nginx is not running'
assert process.is_up('php5-fpm'), 'php-fpm is not running'
assert service.is_enabled('nginx'), 'nginx is not enabled'
assert service.is_enabled('php5-fpm'), 'php-fpm is not enabled'
# magento main page is available
assert magento_is_responding(), 'Magento did not respond as expected.'
def check():
env.platform_family = detect.detect()
dot_npm = "/home/user1/.npm"
assert file.exists(dot_npm), \
"%s does not exist" % dot_npm
assert file.is_dir(dot_npm), \
"%s is not a directory" % dot_npm
assert file.mode_is(dot_npm, '755'), \
"%s is not mode 755" % dot_npm
assert file.owner_is(dot_npm, 'user1'), \
"%s is not owned by user1" % dot_npm
# directory { should be_grouped_into 'my_nodejs_app' }
assert port.is_listening(80), "port 80/apache2 is not listening"
assert user.exists("user1"), "user my_nodejs_app does not exist"
assert process.is_up("node"), "node process is not up"
# its('args') { should match 'server.js|app.js' }
assert service.is_enabled("node-app"), \
"node-app service is not enabled"
assert nodejs_is_responding(), "node demo app did not respond as expected"
def check():
env.platform_family = detect.detect()
# web server is listening
assert port.is_listening(80), 'Web port 80 is not listening'
# redis is listening
assert port.is_listening(6379), 'Redis port 6379 is not listening'
assert port.is_listening(6380), 'Redis port 6380 is not listening'
assert port.is_listening(6381), 'Redis port 6381 is not listening'
# nginx user is created
assert user.exists("nginx"), 'nginx user does not exist'
if (env.platform_family == "rhel"):
assert process.is_up('nginx'), 'nginx is not running'
assert process.is_up('php-fpm'), 'php-fpm is not running'
assert service.is_enabled('nginx'), 'nginx is not enabled'
assert service.is_enabled('php-fpm'), 'php-fpm is not enabled'
elif (env.platform_family == 'debian'):
assert process.is_up('nginx'), 'nginx is not running'
assert process.is_up('php5-fpm'), 'php-fpm is not running'
assert service.is_enabled('nginx'), 'nginx is not enabled'
assert service.is_enabled('php5-fpm'), 'php-fpm is not enabled'
# magento main page is available
assert magento_is_responding(), 'Magento did not respond as expected.'
def check():
env.platform_family = detect.detect()
packages = ['st2common',
'st2reactor',
'st2actions',
'st2api',
'st2auth',
'st2debug',
'python-st2client',
'rabbitmq-server',
'mongodb-server',
'mysql-server'
]
services = ['actionrunner',
'st2api',
'sensor_container',
'rules_engine',
'mistral',
'st2resultstracker',
'rabbitmq-server',
'mongodb',
'mysql'
]
for pkg in packages:
assert package.installed(pkg),\
"package {0} is not installed".format(pkg)
for srv in services:
assert service.is_enabled(srv),\
"service {0} is not enabled".format(srv)
assert user.exists("stanley"), "user stanley does not exist"
def check():
env.platform_family = detect.detect()
dot_npm = "/home/user1/.npm"
assert file.exists(dot_npm), \
"%s does not exist" % dot_npm
assert file.is_dir(dot_npm), \
"%s is not a directory" % dot_npm
assert file.mode_is(dot_npm, '755'), \
"%s is not mode 755" % dot_npm
assert file.owner_is(dot_npm, 'user1'), \
"%s is not owned by user1" % dot_npm
# directory { should be_grouped_into 'my_nodejs_app' }
assert port.is_listening(80), "port 80/apache2 is not listening"
assert user.exists("user1"), "user my_nodejs_app does not exist"
assert process.is_up("node"), "node process is not up"
# its('args') { should match 'server.js|app.js' }
assert service.is_enabled("node-app"), \
"node-app service is not enabled"
assert nodejs_is_responding(), "node demo app did not respond as expected"
def check():
env.platform_family = detect.detect()
# web server is listening
assert port.is_listening(80), 'Web port 80 is not listening'
# redis is listening
assert port.is_listening(6379), 'Redis port 6379 is not listening'
assert port.is_listening(6380), 'Redis port 6380 is not listening'
assert port.is_listening(6381), 'Redis port 6381 is not listening'
# nginx user is created
assert user.exists("nginx"), 'nginx user does not exist'
# processes are running
assert process.is_up("nginx"), 'nginx is not running'
assert process.is_up("php-fpm"), 'php-fpm is not running'
assert process.is_up("redis"), 'redis is not running'
assert process.is_up("rackspace-monitoring-agent"), 'Monitoring agent is not running'
assert process.is_up("driveclient"), 'Backup agent is not running'
# holland backups are configured
assert file.exists("/etc/holland/backupsets/default.conf"), "Backup configuration does not exist"
assert file.exists("/etc/cron.d/holland"), 'Backup cron job not configured'
# services are enabled
assert service.is_enabled("nginx"), 'nginx service not enabled'
assert service.is_enabled("redis"), 'redis service not enabled'
assert service.is_enabled("php-fpm"), 'php-fpm not enabled'
assert service.is_enabled("rackspace-monitoring-agent"), 'monitoring agent not enabled'
assert service.is_enabled("driveclient"), 'driveclient (backups) not enabled'
# magento main page is available
assert magento_is_responding(), 'Magento did not respond as expected.'
def check():
env.platform_family = detect.detect()
# file
assert file.exists("/etc/hosts")
assert file.is_file("/etc/hosts")
assert file.is_dir("/tmp/")
assert file.dir_exists("/tmp/")
assert file.has_line("/etc/passwd", "sshd")
assert file.owner_is("/bin/sh", "root")
if env.platform_family == "freebsd":
assert file.is_link("/compat")
assert file.group_is("/bin/sh", "wheel")
assert file.mode_is("/bin/sh", "555")
else:
assert file.is_link("/usr/tmp")
assert file.group_is("/bin/sh", "root")
assert file.mode_is("/bin/sh", "777")
assert package.installed("wget.x86_64")
assert user.exists("sshd")
assert user.is_belonging_group("worker", "users")
assert group.is_exists("wheel")
assert port.is_listening(22)
assert cron.has_entry('shirou', 'python')
if env.platform_family == "freebsd":
assert service.is_enabled("apache22")
assert process.is_up("httpd")
else:
assert service.is_enabled("http")
assert process.is_up("http") is False
def check():
env.platform_family = detect.detect()
config_js = '/var/app/current/config.js'
assert file.exists(config_js), \
"%s does not exist" % config_js
assert file_contains(config_js, 'StrictHostKeyChecking false'), \
"%s does not turn off StrictHostKeyChecking" % config_js
dot_npm = "/home/my_nodejs_app/.npm"
assert file.exists(dot_npm), \
"%s does not exist" % dot_npm
assert file.is_dir(dot_npm), \
"%s is not a directory" % dot_npm
assert file.is_mode(dot_npm, 'r-xr-xr-x'), \
"%s is not mode 755" % dot_npm
assert file.owner_is(dot_npm, 'my_nodejs_app'), \
"%s is not owned by my_nodejs_app" % dot_npm
# directory { should be_grouped_into 'my_nodejs_app' }
assert port.is_listening(80), "port 80/apache2 is not listening"
assert user.exists("my_nodejs_app"), "user my_nodejs_app does not exist"
assert user_has_shell('my_nodejs_app', ':/bin/bash'), \
"user should have bash shell"
assert process.is_up("node"), "node process is not up"
# its('args') { should match 'server.js|app.js' }
assert service.is_enabled("my_nodejs_app"), \
"my_nodejs_app service is not enabled"
assert apache2_is_responding(), "node demo app did not respond as expected"
def check():
env.platform_family = detect.detect()
for pkg in ["rabbitmq-server",
"python-pip",
"curl",
"unzip",
"supervisor",
"dnsmasq"]:
assert package.installed(pkg), \
"package {} is not installed".format(pkg)
for path in ["/var/lib/rabbitmq/.erlang.cookie",
"/etc/supervisor/conf.d/consul.conf",
"/usr/local/lib/supervisor/start_consul.sh",
"/etc/dnsmasq.d/consul_dns.conf"]:
assert file.exists(path), "file {} does not exist".format(path)
assert port.is_listening(5672), "port 5672 (RabbitMQ) is not listening"
assert user.exists("rabbitmq"), "there is no rabbitmq user"
assert group.is_exists("rabbitmq"), "there is no rabbitmq group"
assert process.is_up("supervisord"), "supervisord is not running"
assert process.is_up("consul"), "consul is not running"
assert process.is_up("epmd"), "epmd is not running"
assert process.is_up("beam.smp"), "beam.smp is not running"
assert process.is_up("dnsmasq"), "dnsmasq is not running"
assert service.is_enabled("rabbitmq-server"), "nginx is not enabled"
assert service.is_enabled("supervisor"), "supervisor is not enabled"
assert amqp_works(env.amqp_login, env.amqp_password, env.host), \
"RabbitMQ did not respond as expected"
def check():
env.platform_family = detect.detect()
config_js = '/var/app/current/config.js'
assert file.exists(config_js), \
"%s does not exist" % config_js
assert file_contains(config_js, 'StrictHostKeyChecking false'), \
"%s does not turn off StrictHostKeyChecking" % config_js
dot_npm = "/home/my_nodejs_app/.npm"
assert file.exists(dot_npm), \
"%s does not exist" % dot_npm
assert file.is_dir(dot_npm), \
"%s is not a directory" % dot_npm
assert file.is_mode(dot_npm, 'r-xr-xr-x'), \
"%s is not mode 755" % dot_npm
assert file.owner_is(dot_npm, 'my_nodejs_app'), \
"%s is not owned by my_nodejs_app" % dot_npm
# directory { should be_grouped_into 'my_nodejs_app' }
assert port.is_listening(80), "port 80/apache2 is not listening"
assert user.exists("my_nodejs_app"), "user my_nodejs_app does not exist"
assert user_has_shell('my_nodejs_app', ':/bin/bash'), \
"user should have bash shell"
assert process.is_up("node"), "node process is not up"
# its('args') { should match 'server.js|app.js' }
assert service.is_enabled("my_nodejs_app"), \
"my_nodejs_app service is not enabled"
assert apache2_is_responding(), "node demo app did not respond as expected"
def check():
env.platform_family = detect.detect()
assert package.installed("jenkins"), 'Jenkins is not installed'
assert port.is_listening(8080), 'Jenkins is not listening'
assert user.exists("jenkins"), 'Jenkins user does not exist'
assert service.is_enabled("jenkins"), 'Jenkins service is not enabled'
assert jenkins_is_responding_on_http(), 'Jenkins is not responding'
def check():
env.platform_family = detect.detect()
assert package.installed("jenkins")
assert port.is_listening(8080)
assert user.exists("jenkins")
assert service.is_enabled("jenkins")
assert jenkins_is_responding_on_http()
def disabled_test_hello_systemvm_envassert(self):
"""Test we can run envassert assertions on the systemvm"""
assert file.exists('/etc/hosts')
for packageName in ['dnsmasq', 'haproxy', 'keepalived', 'curl']:
assert package.installed(packageName), 'package %s should be installed' % packageName
assert user.exists('cloud'), 'user cloud should exist'
def check():
env.platform_family = detect.detect()
assert file.exists('/var/www/vhosts/example.com/xmlrpc.php'),\
'xmlrpc.php did not exist'
assert port.is_listening(21), 'port 21/vsftpd is not listening'
assert port.is_listening(80), 'port 80/varnishd is not listening'
assert port.is_listening(3306), 'port 3306/mysqld is not listening'
assert port.is_listening(6082), 'port 6082/varnishd is not listening'
assert port.is_listening(8080), 'port 8080/apache2 is not listening'
assert port.is_listening(11211), 'port 11211/memcached is not listening'
assert user.exists('ftp'), 'ftp user does not exist'
assert user.exists('varnish'), 'varnish user does not exist'
assert user.exists('varnishlog'), 'varnishlog user does not exist'
assert user.exists('mysql'), 'mysql user does not exist'
assert user.exists('memcache'), 'memcache user does not exist'
assert user.exists('wp_user'), 'wp_user user does not exist'
assert user.exists('wp_user').get('passwd') != '!', 'wp_user pass missing'
assert process.is_up('apache2'), 'apache2 is not running'
assert process.is_up('mysqld'), 'mysqld is not running'
assert process.is_up('varnishd'), 'varnishd is not running'
assert process.is_up('memcached'), 'memcached is not running'
assert process.is_up('vsftpd'), 'vsftpd is not running'
assert service.is_enabled('apache2'), 'apache2 service not enabled'
assert service.is_enabled('mysql'), 'mysql service not enabled'
assert service.is_enabled('varnish'), 'varnish service not enabled'
assert service.is_enabled('varnishlog'), 'varnishlog service not enabled'
assert service.is_enabled('memcached'), 'memcached service not enabled'
assert service.is_enabled('vsftpd'), 'vsftpd service not enabled'
assert http_check('http://localhost/', 'Powered by WordPress')
def lsyncd():
env.platform_family = detect.detect()
wordpress_user = "******"
web_group = "www-data"
ssh_dir = "/var/www/vhosts/example.com/.ssh"
private_key = os.path.join(ssh_dir, "id_rsa")
assert package.installed("lsyncd"), 'lsyncd is not installed'
check_lsync_up()
assert service.is_enabled("lsyncd"), 'lsyncd is not enabled'
assert user.exists(wordpress_user), 'wp_user user does not exist'
assert user.exists('wp_user').get('passwd') != '!', 'wp_user pass missing'
assert user.is_belonging_group(wordpress_user, web_group), 'wp_user does belong to correct group'
assert file.dir_exists(ssh_dir), 'ssh directory does not exist'
assert file.owner_is(ssh_dir, wordpress_user), 'wp_user does not own ssh directory'
assert file.owner_is(private_key, wordpress_user), 'wp_user does not own ssh key'
assert file.mode_is(private_key, 600), 'ssh key is not set to correct mode'
def disabled_test_hello_systemvm_envassert(self):
"""Test we can run envassert assertions on the systemvm"""
assert file.exists('/etc/hosts')
for packageName in ['dnsmasq', 'haproxy', 'keepalived', 'curl']:
assert package.installed(
packageName), 'package %s should be installed' % packageName
assert user.exists('cloud'), 'user cloud should exist'
def check():
env.platform_family = detect.detect()
assert file.exists("/etc/redis/redis.conf")
assert port.is_listening(6379)
assert user.exists("redis")
assert group.is_exists("redis")
assert process.is_up("redis-server")
assert service.is_enabled("redisredis")
def check():
env.platform_family = detect.detect()
assert file.exists("/etc/mongod.conf"), "/etc/mongod.conf does not exist"
assert port.is_listening(27017), "nothing is listening on port 27017"
assert user.exists("mongodb"), "there is no mongodb user"
assert group.is_exists("mongodb"), "there is no mongodb group"
assert process.is_up("mongod"), "mongod is not running"
assert service.is_enabled("mongod"), "service mongod is not enabled"
assert replset_is_ok(), "replica set status was not ok"
def check():
env.platform_family = detect.detect()
assert file.exists("/etc/mongod.conf"), "/etc/mongod.conf does not exist"
assert port.is_listening(27017), "nothing is listening on port 27017"
assert user.exists("mongodb"), "there is no mongodb user"
assert group.is_exists("mongodb"), "there is no mongodb group"
assert process.is_up("mongod"), "mongod is not running"
assert service.is_enabled("mongod"), "service mongod is not enabled"
assert replset_is_ok(), "replica set status was not ok"
def check_db_mysql():
env.platform_family = detect.detect()
assert file.exists("/etc/mysql/my.cnf"), \
"/etc/mysql/my.cnf does not exist"
assert port.is_listening(3306), "port 3306 is not listening"
assert user.exists("mysql"), "user mysql does not exist"
assert group.is_exists("mysql"), "group mysql does not exist"
assert process.is_up("mysqld"), "mysqld process is not up"
assert service.is_enabled("mysql"), "mysql is not enabled"
def check():
env.platform_family = detect.detect()
assert package.installed("cassandra")
assert file.exists("/etc/cassandra/cassandra.yaml")
assert port.is_listening(7000)
assert user.exists("cassandra")
assert group.is_exists("cassandra")
assert user.is_belonging_group("cassandra", "cassandra")
assert process.is_up("java")
assert service.is_enabled("cassandra")
def check():
env.platform_family = detect.detect()
assert package.installed("jenkins")
assert file.exists("/var/lib/jenkins/hudson.model.UpdateCenter.xml")
assert port.is_listening(8080)
assert port.is_listening(8081)
assert user.exists("jenkins")
assert process.is_up("daemon")
assert service.is_enabled("jenkins")
assert jenkins_is_responding_on_http()
def check():
env.platform_family = detect.detect()
assert package.installed("td-agent")
assert file.exists("/etc/td-agent/td-agent.conf")
assert port.is_listening(8888)
assert port.is_listening(24224)
assert user.exists("td-agent")
assert group.is_exists("td-agent")
assert user.is_belonging_group("td-agent", "td-agent")
assert process.is_up("ruby")
assert service.is_enabled("td-agent")
def check():
env.platform_family = detect.detect()
assert file.exists('/home/rails/railsapp/current/config/database.yml'), \
'/home/rails/railsapp/current/config/database.yml did not exist'
assert port.is_listening(80), 'port 80/nginx is not listening'
assert port.is_listening(3306), 'port 3306/mysqld is not listening'
assert user.exists('mysql'), 'mysql user does not exist'
assert user.exists('rails'), 'rails user does not exist'
assert process.is_up('ruby'), 'unicorn is not running'
assert process.is_up('nginx'), 'nginx is not running'
assert process.is_up('mysqld'), 'mysqld is not running'
assert service.is_enabled('nginx'), 'nginx service not enabled'
assert service.is_enabled('mysql'), 'mysql service not enabled'
assert service.is_enabled('unicorn'), 'unicorn service not enabled'
assert app_is_responding(), 'Rails app did not respond as expected.'
def lsyncd():
env.platform_family = detect.detect()
wordpress_user = "******"
web_group = "www-data"
ssh_dir = "/var/www/vhosts/example.com/.ssh"
private_key = os.path.join(ssh_dir, "id_rsa")
assert package.installed("lsyncd"), 'lsyncd is not installed'
assert process.is_up("lsyncd"), 'lsyncd is not up'
assert service.is_enabled("lsyncd"), 'lsyncd is not enabled'
assert user.exists(wordpress_user), 'wp_user user does not exist'
assert user.exists('wp_user').get('passwd') != '!', 'wp_user pass missing'
assert user.is_belonging_group(
wordpress_user, web_group), 'wp_user does belong to correct group'
assert file.dir_exists(ssh_dir), 'ssh directory does not exist'
assert file.owner_is(ssh_dir,
wordpress_user), 'wp_user does not own ssh directory'
assert file.owner_is(private_key,
wordpress_user), 'wp_user does not own ssh key'
assert file.mode_is(private_key, 600), 'ssh key is not set to correct mode'
def check():
env.platform_family = detect.detect()
assert package.installed("jenkins")
assert package.installed("jenkins-cli")
assert file.exists("/etc/jenkins/cli.conf")
assert port.is_listening(8080)
assert port.is_listening(8081)
assert user.exists("jenkins")
assert process.is_up("daemon")
assert service.is_enabled("jenkins")
assert jenkins_is_responding_on_http()
def check():
env.platform_family = detect.detect()
assert file.exists('/var/www/vhosts/example.com/xmlrpc.php'), 'xmlrpc.php did not exist'
assert port.is_listening(21), 'port 21/vsftpd is not listening'
assert port.is_listening(80), 'port 80/varnishd is not listening'
assert port.is_listening(3306), 'port 3306/mysqld is not listening'
assert port.is_listening(6082), 'port 6082/varnishd is not listening'
assert port.is_listening(8080), 'port 8080/apache2 is not listening'
assert port.is_listening(11211), 'port 11211/memcached is not listening'
assert user.exists('ftp'), 'ftp user does not exist'
assert user.exists('varnish'), 'varnish user does not exist'
assert user.exists('varnishlog'), 'varnishlog user does not exist'
assert user.exists('mysql'), 'mysql user does not exist'
assert user.exists('memcache'), 'memcache user does not exist'
assert user.exists('wp_user'), 'wp_user user does not exist'
assert process.is_up('apache2'), 'apache2 is not running'
assert process.is_up('mysqld'), 'mysqld is not running'
assert process.is_up('varnishd'), 'varnishd is not running'
assert process.is_up('memcached'), 'memcached is not running'
assert process.is_up('vsftpd'), 'vsftpd is not running'
assert service.is_enabled('apache2'), 'apache2 service not enabled'
assert service.is_enabled('mysql'), 'mysql service not enabled'
assert service.is_enabled('varnish'), 'varnish service not enabled'
assert service.is_enabled('varnishlog'), 'varnishlog service not enabled'
assert service.is_enabled('memcached'), 'memcached service not enabled'
assert service.is_enabled('vsftpd'), 'vsftpd service not enabled'
assert wordpress_is_responding(), 'Wordpress did not respond as expected.'
def check():
env.platform_family = detect.detect()
assert file.exists('/var/www/magento/.configured'), \
'.configured did not exist'
if env.platform_family == 'rhel':
memcache_user = '******'
php_fpm_process_name = 'php-fpm'
php_fpm_service_name = 'php-fpm'
elif env.platform_family == 'debian':
memcache_user = '******'
php_fpm_process_name = 'php5-fpm'
php_fpm_service_name = 'php5-fpm'
assert port.is_listening(80), 'port 80 is not listening'
assert port.is_listening(443), 'port 443 is not listenging'
assert port.is_listening(3306), 'port 3306 is not listening'
assert port.is_listening(9001), 'port 9001 is not listening'
assert port.is_listening(11211), 'port 11211 is not listening'
assert port.is_listening(11212), 'port 11212 is not listening'
assert user.exists("magento"), 'magento user does not exist'
assert user.exists("mysql"), 'mysql user does not exist'
assert user.exists(memcache_user), \
'{} user does not exist'.format(memcache_user)
assert process.is_up("nginx"), 'nginx is not running'
assert process.is_up("mysqld"), 'mysqld is not running'
assert process.is_up(php_fpm_process_name), \
'{} is not running'.format(php_fpm_process_name)
assert process.is_up("memcached"), 'memcached is not running'
assert service.is_enabled("nginx"), 'nginx service not enabled'
assert service.is_enabled("mysql"), 'mysql service not enabled'
assert service.is_enabled(php_fpm_service_name), \
'{} not enabled'.format(php_fpm_service_name)
assert service.is_enabled("memcached"), 'memcached service not enabled'
assert magento_is_responding(), 'Magento did not respond as expected.'
def check():
env.platform_family = detect.detect()
assert file.exists('/var/www/vhosts/application/index.php'), \
'/var/www/vhosts/application/index.php did not exist'
assert port.is_listening(80), 'port 80/apache2 is not listening'
assert port.is_listening(3306), 'port 3306/mysqld is not listening'
assert port.is_listening(11211), 'port 11211/memcached is not listening'
assert user.exists('mysql'), 'mysql user does not exist'
assert user.exists('memcache'), 'memcache user does not exist'
assert process.is_up('apache2'), 'apache2 is not running'
assert process.is_up('mysqld'), 'mysqld is not running'
assert process.is_up('memcached'), 'memcached is not running'
assert service.is_enabled('apache2'), 'apache2 service not enabled'
assert service.is_enabled('mysql'), 'mysql service not enabled'
assert service.is_enabled('memcached'), 'memcached service not enabled'
assert apache2_is_responding(), 'apache2 did not respond as expected.'
def check():
env.platform_family = detect.detect()
assert port.is_listening(443), "port 443 (nginx) is not listening"
assert port.is_listening(8080), "port 8080 (gitlab) is not listening"
assert port.is_listening(22), "port 22 (ssh) is not listening"
assert user.exists("git"), "there is no git user"
assert group.is_exists("git"), "there is no git group"
assert user.is_belonging_group("git", "git"), "user git is not in the git group"
assert process.is_up("nginx"), "nginx is not running"
assert process.is_up("postgres"), "postgres is not running"
assert process.is_up("redis-server"), "redis-server is not running"
assert gitlab_is_responding(), "gitlab did not respond as expected"
def check():
env.platform_family = detect.detect()
assert package.installed("apache2")
assert file.exists("/srv/venv/bin/django-admin.py")
assert file.exists("/etc/apache2/mods-enabled/wsgi.conf")
assert file.exists("/etc/apache2/mods-enabled/wsgi.load")
assert port.is_listening(80)
assert user.exists("pydev")
assert group.is_exists("pydev")
assert user.is_belonging_group("pydev", "pydev")
assert process.is_up("apache2")
assert service.is_enabled("apache2")
def lsync_client():
env.platform_family = detect.detect()
wordpress_user = "******"
web_group = "www-data"
ssh_dir = "/var/www/vhosts/example.com/.ssh"
auth_keys = os.path.join(ssh_dir, "authorized_keys")
assert user.exists(wordpress_user)
assert user.is_belonging_group(wordpress_user, web_group)
assert file.dir_exists(ssh_dir)
assert file.owner_is(ssh_dir, wordpress_user)
assert file.owner_is(auth_keys, wordpress_user)
assert file.mode_is(auth_keys, 644)
def check():
env.platform_family = detect.detect()
assert package.installed("chef-server-core")
assert file.exists("/etc/opscode/chef-server.rb")
assert port.is_listening(80)
assert port.is_listening(443)
assert user.exists("opscode")
assert group.is_exists("opscode")
assert user.is_belonging_group("opscode", "opscode")
assert process.is_up("nginx")
assert process.is_up("postgres")
assert service.is_enabled("nginx")
assert service.is_enabled("postgres")
def acceptance_tests_on_ubuntu14_img_for_flocker(distribution):
""" checks that the Ubuntu 14 image is suitable for running the Flocker
acceptance tests
:param string distribution: which OS to use 'centos7', 'ubuntu1404'
"""
with settings():
env.platform_family = detect.detect()
# Jenkins should call the correct interpreter based on the shebang
# However,
# We noticed that our Ubuntu /bin/bash call were being executed
# as /bin/sh.
# So we as part of the slave image build process symlinked
# /bin/sh -> /bin/bash.
# https://clusterhq.atlassian.net/browse/FLOC-2986
log_green('check that /bin/sh is symlinked to bash')
assert file.is_link("/bin/sh")
assert 'bash' in run('ls -l /bin/sh')
# the client acceptance tests run on docker instances
log_green('check that docker is enabled')
assert 'docker' in run('ls -l /etc/init')
# make sure we installed all the packages we need
log_green('assert that required deb packages are installed')
for pkg in ubuntu14_required_packages():
log_green('... checking package: %s' % pkg)
assert package.installed(pkg)
# Our tests require us to run docker as ubuntu.
# So we add the user ubuntu to the docker group.
# During bootstrapping of the node, jenkins will update the init
# file so that docker is running with the correct group.
# TODO: move that jenkins code here
log_green('check that ubuntu is part of group docker')
assert user.exists("ubuntu")
assert group.is_exists("docker")
assert user.is_belonging_group("ubuntu", "docker")
# the acceptance tests look for a package in a yum repository,
# we provide one by starting a webserver and pointing the tests
# to look over there.
# for that we need 'nginx' installed and running
log_green('check that nginx is running')
assert package.installed('nginx')
assert port.is_listening(80, "tcp")
assert process.is_up("nginx")
assert 'nginx' in run('ls -l /etc/init.d/')
def check_master():
env.platform_family = detect.detect()
assert file.exists("/etc/redis/master.conf"), \
"master.conf does not exist"
assert file.exists("/etc/redis/sentinel_cluster.conf"), \
"sentinel_cluster.conf does not exist"
assert port.is_listening(6379), "port 6379 is not listening"
assert port.is_listening(26379), "port 26379 is not listening"
assert user.exists("redis"), "user redis does not exist"
assert group.is_exists("redis"), "group redis does not exist"
assert process.is_up("redis-server"), "redis-server process is not up"
assert service.is_enabled("redismaster"), "redismaster is not enabled"
assert service.is_enabled("redis_sentinel_cluster"), \
"redis_sentinel_cluster is not enabled"
def check():
env.platform_family = detect.detect()
assert file.exists('/srv/minecraft/minecraft_server.1.8.jar'), \
'/srv/minecraft/minecraft_server.1.8.jar does not exist'
assert port.is_listening(25565), 'port 25565/java is not listening'
assert user.exists('mcserver'), 'user mcserver does not exist'
assert group.is_exists('mcserver'), 'group mcserver does not exist'
assert process.is_up('java'), 'process java is not running'
assert service.is_enabled('minecraft'), 'service minecraft is not enabled'
def check():
env.platform_family = detect.detect()
assert package.installed("java-common")
assert package.installed("nginx")
assert file.exists("/usr/local/bin/elasticsearch")
assert port.is_listening(9200)
assert port.is_listening(9300)
assert port.is_listening(8080)
assert user.exists("elasticsearch")
assert group.is_exists("elasticsearch")
assert user.is_belonging_group("elasticsearch", "elasticsearch")
assert process.is_up("java")
assert process.is_up("nginx")
assert service.is_enabled("nginx")
assert service.is_enabled("elasticsearch")
def check():
env.platform_family = detect.detect()
assert package.installed("apache2")
assert package.installed("memcached")
assert file.is_dir("/opt/graphite")
assert file.exists("/etc/sv/statsd")
assert port.is_listening(443)
assert port.is_listening(2003)
assert port.is_listening(2004)
assert port.is_listening(8126)
assert user.exists("statsd")
assert process.is_up("apache2")
assert process.is_up("memcached")
assert service.is_enabled("apache2")
assert service.is_enabled("memcached")
assert graphite_is_responding()
def check():
env.platform_family = detect.detect()
assert file.exists('/home/strongloop/loopback-example-app/package.json'), \
'/home/strongloop/loopback-example-app/package.json does not exist'
assert file.exists('/etc/supervisor.d/strongloop.conf'), \
'/etc/supervisor.d/strongloop.conf does not exist'
assert port.is_listening(3000), 'port 3000/node is not listening'
assert user.exists('strongloop'), 'user strongbad does not exist'
assert group.is_exists('strongloop'), 'group strongloop does not exist'
assert process.is_up('supervisord'), 'process supervisord is not running'
assert process.is_up('node'), 'process node is not running'
assert service.is_enabled('supervisor'), \
'service supervisor is not enabled'
def check():
env.platform_family = detect.detect()
assert file.exists('/var/www/vhosts/example.com/.configured'), \
'.configured did not exist'
assert port.is_listening(80), 'port 80 is not listening'
assert port.is_listening(443), 'port 443 is not listenging'
assert port.is_listening(9001), 'port 9001 is not listening'
assert user.exists("magento"), 'magento user does not exist'
assert process.is_up("nginx"), 'nginx is not running'
assert process.is_up("php5-fpm"), 'php5-fpm is not running'
assert service.is_enabled("nginx"), 'nginx service not enabled'
assert service.is_enabled("php5-fpm"), 'php5-fpm service not enabled'
assert magento_is_responding(), 'Magento did not respond as expected.'
def check():
env.platform_family = detect.detect()
assert file.exists("/etc/apache2/sites-enabled/example.com.conf"), \
"/etc/apache2/sites-enabled/example.com.conf does not exist"
assert port.is_listening(80), "port 80/apache2 is not listening"
assert port.is_listening(11211), "port 11211/memcached is not listening"
assert user.exists("memcache"), "user memcache does not exist"
assert group.is_exists("memcache"), "group memcache does not exist"
assert process.is_up("apache2"), "apache2 process is not up"
assert process.is_up("memcached"), "memcached process is not up"
assert service.is_enabled("apache2"), "redismaster is not enabled"
assert service.is_enabled("memcached"), "memcached is not enabled"
assert apache2_is_responding(), "php app did not respond as expected"
def check():
env.platform_family = detect.detect()
assert package.installed("nginx"), 'nginx not installed'
assert package.installed("mysql-server-5.5"), \
'mysql-server-5.5 not installed'
assert file.exists("/usr/local/bin/node"), 'node not found'
assert file.exists("/usr/local/bin/npm"), 'npm not found'
assert port.is_listening(80), '80/nginx is not listening'
assert port.is_listening(2368), '2368/node is not listening'
assert port.is_listening(3306), '3306/mysqld is not listening'
assert user.exists("ghost"), 'ghost user does not exist'
assert group.is_exists("ghost"), 'ghost group does not exist'
assert user.is_belonging_group("ghost", "www-data"), \
'ghost user not in group www-data'
assert process.is_up("nginx"), 'nginx is not running'
assert process.is_up("node"), 'node is not running'
assert process.is_up("mysqld"), 'mysqld is not running'
assert service.is_enabled("nginx"), 'nginx service not enabled'
assert service.is_enabled("mysqld"), 'mysqld service not enabled'
assert ghost_is_responding(), 'Ghost did not respond as expected'
