def check():
env.platform_family = detect.detect()
assert file.is_dir("/var/www/vhosts"), '/var/www/vhosts is wrong'
assert port.is_listening(80), 'port 80 not listening'
assert port.is_listening(8080), 'port 8080 not listening'
assert package.installed("varnish"), 'varnish not installed'
assert drupal_is_responding(), 'Drupal did not respond as expected.'
apache_process = 'apache2'
php_package = 'php5'
if env.platform_family == 'debian':
apache_process = 'apache2'
php_package = 'php5'
elif env.platform_family == 'rhel':
apache_process = 'httpd'
php_package = 'php'
else:
raise ValueError('OS ' + env.platform_family +
' unknown, update tests.')
assert package.installed(php_package), 'php not installed'
assert process.is_up(apache_process), 'apache is not running'
assert service.is_enabled(apache_process), 'apache is not enabled'
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()
assert file.is_dir("/var/www/vhosts"), '/var/www/vhosts is wrong'
assert port.is_listening(80), 'port 80 not listening'
assert port.is_listening(8080), 'port 8080 not listening'
assert package.installed("varnish"), 'varnish not installed'
assert drupal_is_responding(), 'Drupal did not respond as expected.'
apache_process = 'apache2'
php_package = 'php5'
if env.platform_family == 'debian':
apache_process = 'apache2'
php_package = 'php5'
elif env.platform_family == 'rhel':
apache_process = 'httpd'
php_package = 'php'
else:
raise ValueError('OS ' + env.platform_family +
' unknown, update tests.')
assert package.installed(php_package), 'php not installed'
assert process.is_up(apache_process), 'apache is not running'
assert service.is_enabled(apache_process), 'apache is not enabled'
def check():
env.platform_family = detect.detect()
if env.platform_family == "rhel":
assert package.installed("httpd"), "httpd not installed"
assert package.installed("holland"), "holland is not installed"
assert package.installed("mysql55"), "mysql55 is not insalled"
assert process.is_up("httpd"), "process httpd not running"
assert service.is_enabled("httpd"), "httpd not enabled"
# welcome.conf causes a 403 when running apache_is_responding()
# with the stock build.
if env.platform_family == "debian":
print "Ubuntu 12.04/14.04 or Debian 7.x/8.x"
assert package.installed("apache2"), "apache2 is not installed"
assert package.installed("mysql-server-5.5"), ("mysql-server-5.5 not" +
" installed")
assert process.is_up("apache2"), "apache2 is not running"
assert service.is_enabled("apache2"), "apache2 is not enabled"
assert apache_is_responding(), "apache2 is not responding"
assert port.is_listening(80), "port 80 not listening"
assert port.is_listening(443), "port 443 not listening"
assert port.is_listening(3306), "port 3306 not listening"
assert phpmyadmin_is_responding(), "phpmyadmin is not responding"
assert holland_is_running(), "holland cannot run"
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()
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()
if env.platform_family == "rhel":
assert package.installed("httpd"), "httpd not installed"
assert package.installed("holland"), "holland is not installed"
assert package.installed("mysql55"), "mysql55 is not insalled"
assert process.is_up("httpd"), "process httpd not running"
assert service.is_enabled("httpd"), "httpd not enabled"
# welcome.conf causes a 403 when running apache_is_responding()
# with the stock build.
if env.platform_family == "debian":
print "Ubuntu 12.04/14.04 or Debian 7.x/8.x"
assert package.installed("apache2"), "apache2 is not installed"
assert package.installed("mysql-server-5.5"), ("mysql-server-5.5 not" +
" installed")
assert process.is_up("apache2"), "apache2 is not running"
assert service.is_enabled("apache2"), "apache2 is not enabled"
assert apache_is_responding(), "apache2 is not responding"
assert port.is_listening(80), "port 80 not listening"
assert port.is_listening(443), "port 443 not listening"
assert port.is_listening(3306), "port 3306 not listening"
assert phpmyadmin_is_responding(), "phpmyadmin is not responding"
assert holland_is_running(), "holland cannot run"
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()
# 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()
assert port.is_listening(80)
assert port.is_listening(443)
assert port.is_listening(8888)
assert process.is_up("nginx")
assert service.is_enabled("nginx")
assert ipynb_is_responding()
def memcached():
env.platform_family = detect.detect()
assert service.is_enabled("memcached")
assert package.installed("memcached")
assert port.is_listening(11211)
assert port.is_listening(11212)
assert process.is_up("memcached")
assert service.is_enabled("memcached")
def memcached():
env.platform_family = detect.detect()
assert service.is_enabled("memcached")
assert package.installed("memcached")
assert port.is_listening(11211)
assert port.is_listening(11212)
assert process.is_up("memcached")
assert service.is_enabled("memcached")
def check():
env.platform_family = detect.detect()
assert port.is_listening(80)
assert port.is_listening(443)
assert port.is_listening(8888)
assert process.is_up("nginx")
assert service.is_enabled("nginx")
assert ipynb_is_responding()
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 port.is_listening(2368), 'port 2368/ghost is not listening'
assert port.is_listening(80), 'port 80/nginx is not listening'
assert port.is_listening(443), 'port 443/nginx is not listening'
assert process.is_up('node'), 'node/ghost is not running'
assert service.is_enabled('nginx'), 'nginx is not enabled'
assert process.is_up('nginx'), 'nginx is not running'
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 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()
site = "http://localhost/"
string = "Apache2 Ubuntu Default Page"
assert file.exists("/opt/railo/install.log"), "Railo install log missing."
assert port.is_listening(80), "Port 80 is not listening."
assert port.is_listening(8888), "Port 8888 is not listening."
assert process.is_up("java"), "The java process is not running."
assert service.is_enabled("apache2"), "The apache2 service is not enabled."
assert service.is_enabled("railo_ctl"), "The Railo service is not enabled."
assert http_check(site, string), "Apache is not responding."
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("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 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()
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("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 file.is_dir("/var/www/vhosts")
assert port.is_listening(80)
assert package.installed("holland")
assert drupal_is_responding(), 'Drupal did not respond as expected.'
apache_process = 'apache2'
php_package = 'php5'
mysql_process = 'mysql'
if env.platform_family == 'debian':
apache_process = 'apache2'
php_package = 'php5'
mysql_process = 'mysql'
elif env.platform_family == 'rhel':
apache_process = 'httpd'
php_package = 'php'
mysql_process = 'mysqld'
else:
raise ValueError('OS ' + env.platform_family +
' unknown, update tests.')
assert package.installed(php_package)
assert process.is_up(apache_process)
assert process.is_up(mysql_process)
assert service.is_enabled(apache_process)
assert service.is_enabled(mysql_process)
def check():
env.platform_family = detect.detect()
assert port.is_listening(25565), 'port 25535/minecraft is not listening'
assert service.is_enabled(
'minecraft-server'), 'Minecraft Server is not enabled'
def mysql():
env.platform_family = detect.detect()
if env.platform_family == 'debian':
mysql_package = 'mysql-server-5.5'
mysql_process = 'mysql'
holland_package = 'holland'
elif env.platform_family == 'rhel':
mysql_package = 'mysql-server'
mysql_process = 'mysqld'
holland_package = 'holland'
else:
raise ValueError('OS ' + env.platform_family +
' unknown, update tests.')
packages = [holland_package, mysql_package]
for pkg in packages:
assert package.installed(pkg), ('package ' + pkg + 'not found')
assert port.is_listening(3306), '3306 not listening'
root_my_cnf = "/root/.my.cnf"
assert file.exists(root_my_cnf), 'root my.cnf does not exist'
assert file.mode_is(root_my_cnf, 600), \
'permissions are wrong on root my.cnf'
assert file.owner_is(root_my_cnf, "root"), 'owner is wrong on root my.cnf'
assert process.is_up(mysql_process), 'mysql is not running'
assert service.is_enabled(mysql_process), 'mysql is not enabled'
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()
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()
assert package.installed("mysql-server-5.5")
assert port.is_listening(3306)
assert process.is_up("mysqld")
assert file.exists("/root/.my.cnf")
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()
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()
assert package.installed("mysql-server-5.5")
assert port.is_listening(3306)
assert process.is_up("mysqld")
assert file.exists("/root/.my.cnf")
def check():
env.platform_family = detect.detect()
assert file.exists('/var/www/vhosts/example.com/httpdocs/xmlrpc.php'),\
'xmlrpc.php did not exist'
assert port.is_listening(80), 'port 80/nginx is not listening'
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'
if ("secondary" not in socket.gethostname()):
assert process.is_up('lsyncd'), 'lsyncd is not running'
assert service.is_enabled('lsyncd'), 'lsyncd is not enabled'
assert http_check('http://localhost/', 'Powered by WordPress')
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()
assert package.installed("memcached")
assert file.exists("/etc/memcached.conf")
assert port.is_listening(11212)
assert process.is_up("memcached")
assert service.is_enabled("memcached")
def check():
env.platform_family = detect.detect()
assert package.installed("memcached")
assert file.exists("/etc/memcached.conf")
assert port.is_listening(11212)
assert process.is_up("memcached")
assert service.is_enabled("memcached")
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 package.installed("jenkins")
assert port.is_listening(8080)
assert user.exists("jenkins")
assert service.is_enabled("jenkins")
assert jenkins_is_responding_on_http()
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 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 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 port.is_listening(3306), 'port 3306/mysql is not listening'
if (env.platform_family == "rhel"):
assert process.is_up('mysql'), 'apache is not running'
elif (env.platform_family == 'debian'):
assert process.is_up('mysql'), ' is not running'
def check():
env.platform_family = detect.detect()
assert port.is_listening(3306), 'port 3306/mysql is not listening'
if (env.platform_family == "rhel"):
assert process.is_up('mysql'), 'apache is not running'
elif (env.platform_family == 'debian'):
assert process.is_up('mysql'), ' is not running'
def check():
env.platform_family = detect.detect()
assert package.installed("nginx")
assert package.installed("mysql-server-5.5")
assert file.exists("/usr/local/bin/node")
assert file.exists("/usr/local/bin/npm")
assert port.is_listening(80)
assert port.is_listening(2368)
assert port.is_listening(3306)
assert user.exists("ghost")
assert group.is_exists("ghost")
assert user.is_belonging_group("ghost", "www-data")
assert process.is_up("nginx")
assert process.is_up("node")
assert process.is_up("mysqld")
assert service.is_enabled("nginx")
assert service.is_enabled("mysqld")
def apache():
env.platform_family = detect.detect()
apache_config = "/etc/apache2/sites-enabled/wordpress.conf"
assert package.installed("apache2")
assert process.is_up("apache2")
assert service.is_enabled("apache2")
assert port.is_listening(8080)
assert file.has_line(apache_config, "VirtualHost *:8080")
def apache2():
assert package.installed("apache2")
assert service.is_enabled("apache2")
assert service.is_up("apache2")
assert port.is_listening(80)
assert file.is_file("/etc/apache2/httpd.conf")
assert file.has_line("/etc/apache2/httpd.conf", "ServerName localhost")
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/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/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 port.is_listening(3306), 'port 3306/mysql is not listening'
if (env.platform_family == "rhel"):
assert process.is_up('mysql'), 'galera is not running'
assert service.is_enabled('mysql'), 'galera is not enabled'
elif (env.platform_family == 'debian'):
assert process.is_up('mysql'), 'galera is not running'
assert service.is_enabled('mysql'), 'galera is not enabled'
def varnish():
env.platform_family = detect.detect()
varnish_config = "/etc/varnish/default.vcl"
assert package.installed("varnish")
assert process.is_up("varnishd")
assert service.is_enabled("varnish")
assert port.is_listening(80)
assert file.has_line(varnish_config, "backend master")
assert file.has_line(varnish_config, "backend local")
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.'
