nirvdrum-rubber 1.1.7 → 2.0.0.rails3.beta6

data/generators/vulcanize/templates/resque/config/rubber/deploy-resque.rb

@@ -4,36 +4,55 @@ namespace :rubber do
   namespace :resque do
   
     rubber.allow_optional_tasks(self)
-  
-    after "rubber:install_packages", "rubber:resque:custom_install"
-    
-    task :custom_install, :roles => :resque do
-      rubber.sudo_script 'install_resque', <<-ENDSCRIPT
-        if [ -d resque ]; then
-          rm -r resque
-        fi
-
-        git clone git://github.com/defunkt/resque.git
-
-        if [ -d #{rubber_env.resque_web_dir} ]; then
-          rm -r #{rubber_env.resque_web_dir}
-        fi
-
-        mkdir -p #{rubber_env.resque_web_dir}
-        mkdir #{rubber_env.resque_web_dir}/tmp
-        mv resque/config.ru #{rubber_env.resque_web_dir}
-        mv resque/lib/resque/server/* #{rubber_env.resque_web_dir}/
-
-        rm -f /var/www/resque
-        ln -s #{rubber_env.resque_web_dir}/public /var/www/resque
-      ENDSCRIPT
+
+    namespace :worker do
+
+      rubber.allow_optional_tasks(self)
+
+      before "deploy:stop", "rubber:resque:worker:stop"
+      after "deploy:start", "rubber:resque:worker:start"
+      after "deploy:restart", "rubber:resque:worker:restart"
+
+      desc "Starts resque workers"
+      task :start, :roles => :resque_worker do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{rails_env} ./script/resque_worker_management.rb start", :as => rubber_env.app_user
+      end
+
+      desc "Stops resque workers"
+      task :stop, :roles => :resque_worker do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{rails_env} ./script/resque_worker_management.rb stop", :as => rubber_env.app_user
+      end
+
+      desc "Restarts resque workers"
+      task :restart, :roles => :resque_worker do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{rails_env} ./script/resque_worker_management.rb restart", :as => rubber_env.app_user
+      end
     end
 
-    after "rubber:setup_app_permissions", "rubber:resque:setup_resque_permissions"
+    namespace :web do
+      rubber.allow_optional_tasks(self)
+
+      before "deploy:stop", "rubber:resque:web:stop"
+      after "deploy:start", "rubber:resque:web:start"
+      after "deploy:restart", "rubber:resque:web:restart"
+
+      desc "Starts resque web tools"
+      task :start, :roles => :resque_web do
+        rsudo "RAILS_ENV=#{RUBBER_ENV} resque-web --pid-file /var/run/resque_web.pid --port #{rubber_env.resque_web_port} --no-launch #{current_path}/config/initializers/resque.rb"
+      end
+
+      desc "Stops resque web tools"
+      task :stop, :roles => :resque_web do
+        rsudo "RAILS_ENV=#{RUBBER_ENV} resque-web --pid-file /var/run/resque_web.pid --kill"
+      end
+
+      desc "Restarts resque web tools"
+      task :restart, :roles => :resque_web do
+        rubber.resque.web.stop
+        rubber.resque.web.start
+      end
 
-    task :setup_resque_permissions, :roles => :resque do
-      run "chown -R #{rubber_env.app_user}:#{rubber_env.app_user} #{rubber_env.resque_web_dir}/config.ru"
     end
-    
+
   end
 end

data/generators/vulcanize/templates/resque/config/rubber/role/resque_web/monit-resque_web.conf

@@ -0,0 +1,14 @@
+<%
+  @path = '/etc/monit/monit.d/monit-resque_web.conf'
+
+  PIDFILE = "/var/run/resque_web.pid"
+  start_program = "HOME=/root resque-web --pid-file #{PIDFILE} --port #{rubber_env.resque_web_port} --no-launch #{RUBBER_ROOT}/config/initializers/resque.rb"
+  stop_program  = "HOME=/root resque-web --pid-file #{PIDFILE} --kill"
+%>
+
+check process resque_web with pidfile <%= PIDFILE %>
+  group resque_web
+  start program = "bash -l -c '<%= start_program %>'"
+  stop program = "bash -l -c '<%= stop_program %>'"
+
+  if totalmem > 350.0 MB for 15 cycles then restart

data/generators/vulcanize/templates/resque/config/rubber/role/resque_worker/monit-resque_worker.conf

@@ -0,0 +1,19 @@
+<%
+  @path = '/etc/monit/monit.d/monit-resque_worker.conf'
+%>
+
+<% rubber_env.resque_workers.each_with_index do |worker, i| %>
+  <%
+    PIDFILE = "#{RUBBER_ROOT}/tmp/pids/resque_worker_#{i}.pid"
+
+    start_program = "cd #{RUBBER_ROOT} && ./script/resque_worker_management.rb start #{i}"
+    stop_program  = "cd #{RUBBER_ROOT} && ./script/resque_worker_management.rb stop #{i}"
+  %>
+
+  check process resque_worker_<%= i %> with pidfile <%= PIDFILE %>
+    group resque_worker
+    start program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= start_program %>'"
+    stop program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= stop_program %>'"
+
+    if totalmem > 350.0 MB for 15 cycles then restart
+<% end %>

data/generators/vulcanize/templates/resque/config/rubber/rubber-resque.yml

@@ -1,10 +1,18 @@
-resque_web_dir: /opt/resque
+resque_web_port: 5678
 
-resque_worker_default_count: 5
+# list of workers with the queues to be run on each - on each worker instance,
+# a worker is run for each item in this list to handle the queues specified
+#
+resque_workers:
+  -
+    queues: *
+    poll_interval: 1
+  -
+    queues: *
+    poll_interval: 1
+
+gems: [yajl-ruby resque]
 
 role_dependencies:
-  css_validator: [redis]
+  web_tools: [resque_web]
 
-roles:
-  resque:
-    gems: [redis redis-namespace yajl-ruby sinatra resque]

data/generators/vulcanize/templates/resque/script/resque_worker_management.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+env = ENV["RUBBER_ENV"] ||= "development"
+root = File.join(File.dirname(__FILE__), '..')
+rails_env_file = File.join(root, 'config', 'environment.rb')
+
+if File.exists? rails_env_file
+  require(rails_env_file)
+else
+  require "rubber"
+  Rubber::initialize(root, env)
+  require 'resque'
+  require "#{root}/config/initializers/resque.rb"
+end
+
+def start_all(workers)
+  puts "Starting all workers"
+  workers.each_with_index do |worker, i|
+    start(worker, i)
+  end
+end
+
+def start(worker, index)
+  puts "Starting worker #{index}/#{worker.queues}"
+
+  log_file = log_file(index)
+  pid_file = pid_file(index)
+
+  queues = worker.queues.to_s.split(',')
+
+  daemonize(log_file, pid_file) do
+    resque_worker = Resque::Worker.new(*queues)
+    resque_worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+    resque_worker.very_verbose = ENV['VVERBOSE']
+
+    puts "*** Starting worker #{resque_worker}"
+    resque_worker.work(worker.poll_interval.to_i || 5) # interval, will block
+  end
+end
+
+def stop_all(workers)
+  puts "Stopping all workers"
+  workers.size.times do |i|
+    stop(i)
+  end
+end
+
+def stop(index)
+  puts "Stopping worker #{index}"
+  
+  pid_file = pid_file(index)
+  pid = File.read(pid_file).to_i rescue nil
+  if pid
+    puts "Killing worker #{index}: pid #{pid}"
+    begin
+      Process.kill("QUIT", pid)
+    rescue Exception => e
+      puts e
+    end
+    File.delete(pid_file) if File.exist?(pid_file)
+  else
+    puts "No pid file for worker #{index}: #{pid_file}"
+  end
+end
+
+def daemonize(log_file, pid_file)
+  return if fork
+  Process::setsid
+  exit!(0) if fork
+  Dir::chdir("/")
+  File.umask 0000
+  FileUtils.touch log_file
+  STDIN.reopen    log_file
+  STDOUT.reopen   log_file, "a"
+  STDERR.reopen   log_file, "a"
+
+  File.open(pid_file, 'w') {|f| f.write("#{Process.pid}") }
+  
+  yield if block_given?
+  exit(0)
+end
+
+def pid_file(index)
+  File.expand_path "#{Rubber.root}/tmp/pids/resque_worker_#{index}.pid"
+end
+
+def log_file(index)
+  File.expand_path "#{Rubber.root}/log/resque_worker_#{index}.log"
+end
+
+action = ARGV[0]
+worker_index = ARGV[1] ? ARGV[1].to_i : nil
+if action.nil? || ! %w[start stop restart].include?(action)
+  puts "Usage: script/resque_worker_management.rb [start|stop|restart]"
+end
+
+workers = Rubber.config.resque_workers
+
+case action
+  when 'start'
+    worker_index ? start(workers[worker_index], worker_index) : start_all(workers)
+  when 'stop'
+    worker_index ? stop(worker_index) : stop_all(workers)
+  when 'restart'
+    if worker_index
+      stop(worker_index)
+      start(workers[worker_index], worker_index)
+    else
+      stop_all(workers)
+      start_all(workers)
+    end
+end

data/generators/vulcanize/templates/resque/templates.rb

@@ -0,0 +1 @@
+gem "resque"if Rubber::Util::is_bundler?

data/generators/vulcanize/templates/sphinx/config/rubber/deploy-sphinx.rb

@@ -18,7 +18,7 @@ namespace :rubber do
     task :custom_install, :roles => :sphinx do
       # install sphinx from source
       ver = "0.9.8.1"
-      rubber.run_script 'install_sphinx', <<-ENDSCRIPT
+      rubber.sudo_script 'install_sphinx', <<-ENDSCRIPT
         # check if already installed
         if [ -x /usr/local/bin/searchd ]
           then echo 'Found sphinx searchd on system'
@@ -60,25 +60,25 @@ namespace :rubber do
     desc "Do sphinx setup tasks"
     task :setup, :roles => :sphinx do
       # Setup links to sphinx config/index as they need to persist between deploys
-      run "mkdir -p #{sphinx_root} #{sphinx_root}/config #{sphinx_root}/db"
-      run "chown -R #{runner}:#{runner} #{sphinx_root}"
+      rsudo "mkdir -p #{sphinx_root} #{sphinx_root}/config #{sphinx_root}/db"
+      rsudo "chown -R #{runner}:#{runner} #{sphinx_root}"
     end
 
     desc "Setup paths for sphinx runtime"
     task :config_dir, :roles => :sphinx do
-      run "rm -rf #{current_path}/sphinx && ln -sf #{sphinx_root} #{current_path}/sphinx"
+      rsudo "rm -rf #{current_path}/sphinx"
+      rsudo "ln -sf #{sphinx_root} #{current_path}/sphinx"
     end
 
     # runs the given ultrasphinx rake tasks
     def run_sphinx task
-      cmd = "cd #{current_path} && sudo -u #{runner} RAILS_ENV=#{RUBBER_ENV} rake #{task}"
-      run cmd
+      rsudo "cd #{current_path} && RAILS_ENV=#{RUBBER_ENV} rake #{task}", :as => runner
     end
 
 
     desc "Stops sphinx searchd"
-    task :stop, :roles => :sphinx, :on_error => :continue do
-      run_sphinx 'ts:stop'
+    task :stop, :roles => :sphinx do
+      run_sphinx 'ts:stop; exit 0'
     end
 
     desc "Starts sphinx searchd"

data/generators/vulcanize/templates/sphinx/config/rubber/role/sphinx/monit-sphinx.conf

@@ -1,10 +1,13 @@
 <%
   @path = '/etc/monit/monit.d/monit-sphinx.conf'
+
+  PIDFILE = "#{RUBBER_ROOT}/log/searchd.#{RUBBER_ENV}.pid"
+  start_program = "cd #{RUBBER_ROOT} && rake ts:start"
+  stop_program = "cd #{RUBBER_ROOT} && rake ts:stop"
 %>
 
-check process sphinx with pidfile <%= RUBBER_ROOT %>/log/searchd.<%= RUBBER_ENV %>.pid
+check process sphinx with pidfile <%= PIDFILE %>
   group sphinx-<%= RUBBER_ENV %>
-  start program = "/usr/bin/sudo -u rails sh -c 'cd <%= RUBBER_ROOT %> && PATH=<%= rubber_env.ruby_prefix %>/bin:/usr/local/bin:$PATH RAILS_ENV=<%= RUBBER_ENV %> rake ts:start'"
-  stop program  = "/usr/bin/sudo -u rails sh -c 'cd <%= RUBBER_ROOT %> && PATH=<%= rubber_env.ruby_prefix %>/bin:/usr/local/bin:$PATH RAILS_ENV=<%= RUBBER_ENV %> rake ts:stop'"
+  start program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= start_program %>'"
+  stop program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= stop_program %>'"
   if failed host <%= rubber_env.host %> port 3312 with timeout 5 seconds for 5 cycles then restart
-

data/generators/vulcanize/vulcanize_generator.rb

@@ -1,67 +1,157 @@
-require 'fileutils'
 require 'find'
+require 'yaml'
+
+if defined?(Rails) && Rails::VERSION::MAJOR == 2
+  require 'fileutils'
+  require 'commands/generate'
+
+  class VulcanizeGenerator < Rails::Generator::NamedBase
+
+    TEMPLATE_ROOT = File.dirname(__FILE__) + "/templates" unless defined?(TEMPLATE_ROOT)
+    TEMPLATE_FILE = "templates.yml" unless defined?(TEMPLATE_FILE)
+
+    def manifest
+      record do |m|
+        templates = [file_name] + actions
+        templates.each do |t|
+          apply_template(m, t)
+        end
+      end
+    end
+
+    def apply_template(m, name)
+      sp = source_path("#{name}/")
+      unless File.directory?(sp)
+        raise Rails::Generator::UsageError.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      templ_conf = load_template_config(sp)
+      deps = templ_conf['dependent_templates'] || []
+      deps.each do |dep|
+        apply_template(m, dep)
+      end
+
+      Find.find(sp) do |f|
+        Find.prune if File.basename(f) =~ /^(CVS|\.svn)$/
+        Find.prune if f == "#{sp}#{TEMPLATE_FILE}"
+
+        rel = f.gsub(/#{source_root}\//, '')
+        dest_rel = rel.gsub(/^#{name}\//, '')
+        m.directory(dest_rel) if File.directory?(f)
+        if File.file?(f)
+          # force scripts to be executable
+          opts = (File.read(f) =~ /^#!/) ? {:chmod => 0755} : {}
+          m.file(rel, dest_rel, opts)
+        end
 
-class VulcanizeGenerator < Rails::Generator::NamedBase
-  
-  TEMPLATE_ROOT = File.dirname(__FILE__) + "/templates"
-  TEMPLATE_FILE = "templates.yml"
-    
-  def manifest
-    record do |m|
-      templates = [file_name] + actions
-      templates.each do |t|
-        apply_template(m, t)
       end
     end
+
+    protected
+      def valid_templates
+        valid = Dir.entries(TEMPLATE_ROOT).delete_if {|e| e =~ /(^\.)|svn|CVS/ }
+      end
+
+      def load_template_config(template_dir)
+        templ_file = "#{template_dir}/templates.yml"
+        templ_conf = YAML.load(File.read(templ_file)) rescue {}
+        return templ_conf
+      end
+
+      def banner
+        usage = "Usage: #{$0} vulcanize template_name ...\n"
+        usage << "where template_name is one of:\n\n"
+        valid_templates.each do |t|
+          templ_conf = load_template_config("#{TEMPLATE_ROOT}/#{t}")
+          desc = templ_conf['description']
+          usage << "    #{t}: #{desc}\n"
+        end
+        return usage
+      end
   end
 
-  def apply_template(m, name)
-    sp = source_path("#{name}/")
-    unless File.directory?(sp)
-      raise Rails::Generator::UsageError.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+else
+  require 'rails/generators'
+
+  class VulcanizeGenerator < Rails::Generators::NamedBase
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
     end
-    
-    templ_conf = load_template_config(sp)
-    deps = templ_conf['dependent_templates'] || []
-    deps.each do |dep|
-      apply_template(m, dep)
+
+    def copy_template_files
+      @template_dependencies = find_dependencies(file_name)
+      ([file_name] + @template_dependencies).each do |template|
+        apply_template(template)
+      end
     end
-    
-    Find.find(sp) do |f|
-      Find.prune if File.basename(f) =~ /^(CVS|\.svn)$/
-      Find.prune if f == "#{sp}#{TEMPLATE_FILE}"
-      
-      rel = f.gsub(/#{source_root}\//, '')
-      dest_rel = rel.gsub(/^#{name}\//, '')
-      m.directory(dest_rel) if File.directory?(f)
-      if File.file?(f)
-        # force scripts to be executable
-        opts = (File.read(f) =~ /^#!/) ? {:chmod => 0755} : {}
-        m.file(rel, dest_rel, opts)
+
+    protected
+
+    # helper to test for rails for optional templates
+    def rails?
+      Rubber::Util::is_rails?
+    end
+
+    def find_dependencies(name)
+      template_dir = File.join(self.class.source_root, name, '')
+      unless File.directory?(template_dir)
+        raise Rails::Generators::Error.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      template_conf = load_template_config(template_dir)
+      template_dependencies = template_conf['dependent_templates'] || []
+
+      template_dependencies.clone.each do |dep|
+        template_dependencies.concat(find_dependencies(dep))
       end
 
+      return template_dependencies.uniq
+    end
+
+    def apply_template(name)
+      template_dir = File.join(self.class.source_root, name, '')
+      unless File.directory?(template_dir)
+        raise Rails::Generators::Error.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      template_conf = load_template_config(template_dir)
+
+      extra_generator_steps_file = File.join(template_dir, 'templates.rb')
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      end
+
+      Find.find(template_dir) do |f|
+        Find.prune if f == File.join(template_dir, 'templates.yml')  # don't copy over templates.yml
+        Find.prune if f == extra_generator_steps_file # don't copy over templates.rb
+
+        template_rel = f.gsub(/#{template_dir}/, '')
+        source_rel = f.gsub(/#{self.class.source_root}\//, '')
+        dest_rel   = source_rel.gsub(/^#{name}\//, '')
+
+        # Only include optional files when their conditions eval to true
+        optional = template_conf['optional'][template_rel] rescue nil
+        Find.prune if optional && ! eval(optional)
+
+        if File.directory?(f)
+          empty_directory(dest_rel)
+        else
+          copy_file(source_rel, dest_rel)
+          src_mode = File.stat(f).mode
+          dest_mode = File.stat(File.join(destination_root, dest_rel)).mode
+          chmod(dest_rel, src_mode) if src_mode != dest_mode
+        end
+      end
     end
-  end
 
-  protected
     def valid_templates
-      valid = Dir.entries(TEMPLATE_ROOT).delete_if {|e| e =~ /(^\.)|svn|CVS/ }
+      valid = Dir.entries(self.class.source_root).delete_if {|e| e =~  /(^\.)|svn|CVS/ }
     end
-    
+
     def load_template_config(template_dir)
-      templ_file = "#{template_dir}/templates.yml"
-      templ_conf = YAML.load(File.read(templ_file)) rescue {}
-      return templ_conf
+      YAML.load(File.read(File.join(template_dir, 'templates.yml'))) rescue {}
     end
+  end
 
-    def banner
-      usage = "Usage: #{$0} vulcanize template_name ...\n"
-      usage << "where template_name is one of:\n\n"
-      valid_templates.each do |t|
-        templ_conf = load_template_config("#{TEMPLATE_ROOT}/#{t}")
-        desc = templ_conf['description']
-        usage << "    #{t}: #{desc}\n" 
-      end
-      return usage
-    end
 end

data/lib/generators/vulcanize/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Prepares the rails application for deploying with rubber by installing a
+    sample rubber configuration template
+
+Examples:
+    ./script/generate vulcanize minimal_mysql

data/lib/generators/vulcanize/templates/apache/config/rubber/deploy-apache.rb

@@ -0,0 +1,51 @@
+
+namespace :rubber do
+
+  namespace :apache do
+  
+    rubber.allow_optional_tasks(self)
+
+    after "rubber:install_packages", "rubber:apache:custom_install"
+
+    task :custom_install, :roles => :apache do
+      rsudo "a2dissite default"
+    end
+
+    # serial_task can only be called after roles defined - not normally a problem, but
+    # rubber auto-roles don't get defined till after all tasks are defined
+    on :load do
+      rubber.serial_task self, :serial_restart, :roles => :apache do
+        rsudo "service apache2 restart"
+      end
+      rubber.serial_task self, :serial_reload, :roles => :apache do
+        rsudo "if ! ps ax | grep -v grep | grep -c apache2 &> /dev/null; then service apache2 start; else service apache2 reload; fi"
+      end
+    end
+    
+    before "deploy:stop", "rubber:apache:stop"
+    after "deploy:start", "rubber:apache:start"
+    after "deploy:restart", "rubber:apache:reload"
+    
+    desc "Stops the apache web server"
+    task :stop, :roles => :apache do
+      rsudo "service apache2 stop; exit 0"
+    end
+    
+    desc "Starts the apache web server"
+    task :start, :roles => :apache do
+      rsudo "service apache2 start"
+    end
+    
+    desc "Restarts the apache web server"
+    task :restart, :roles => :apache do
+      serial_restart
+    end
+  
+    desc "Reloads the apache web server"
+    task :reload, :roles => :apache do
+      serial_reload
+    end
+  
+  end
+
+end

data/lib/generators/vulcanize/templates/apache/config/rubber/role/apache/deflate.conf

@@ -0,0 +1,10 @@
+<%
+  @path = "/etc/apache2/mods-available/deflate.conf"
+  @post = "a2enmod deflate"
+%>
+<IfModule mod_deflate.c>
+  SetOutputFilter DEFLATE
+  BrowserMatch ^Mozilla/4 gzip-only-text/html
+  BrowserMatch ^Mozilla/4.0[678] no-gzip
+  BrowserMatch bMSIE !no-gzip !gzip-only-text/html
+</IfModule>

data/lib/generators/vulcanize/templates/apache/config/rubber/role/apache/expires.conf

@@ -0,0 +1,9 @@
+<%
+  @path = "/etc/apache2/mods-available/expires.conf"
+  @post = "a2enmod expires"
+%>
+ExpiresActive On
+<FilesMatch "\.(ico|gif|jpe?g|png|js|css)$">
+  ExpiresDefault "access plus 1 year"
+</FilesMatch>
+

data/lib/generators/vulcanize/templates/apache/config/rubber/role/apache/headers.conf

@@ -0,0 +1,6 @@
+<%
+  @path = "/etc/apache2/mods-available/headers.conf"
+  @post = "a2enmod headers"
+%>
+# Make sure proxies don't deliver the wrong content
+Header append Vary User-Agent env=!dont-vary

data/lib/generators/vulcanize/templates/apache/config/rubber/role/apache/monit-apache.conf

@@ -0,0 +1,8 @@
+<%
+  @path = '/etc/monit/monit.d/monit-apache.conf'
+%>
+<% PIDFILE = "/var/run/apache2.pid" %>
+check process apache with pidfile <%= PIDFILE %>
+  group apache-<%= RUBBER_ENV %>
+  start program = "/usr/sbin/service apache2 start"
+  stop program = "/usr/sbin/service apache2 stop"

data/lib/generators/vulcanize/templates/apache/config/rubber/role/apache/ports.conf

@@ -0,0 +1,8 @@
+<%
+  @path = '/etc/apache2/ports.conf'
+  # need to stop here so that apache will release port 80 before other
+  # services start and need to bind to it (e.g. haproxy)
+  @post = 'service apache2 stop'
+%>
+# empty ports file since other modules contribute which ports to open (vhosts)
+