isaac-deprec 1.99.30

data/lib/deprec/capistrano_extensions.rb

@@ -0,0 +1,435 @@
+# Copyright 2006-2008 by Mike Bailey. All rights reserved.
+require 'capistrano'
+require 'fileutils'
+
+module Deprec2
+  
+  # Temporarily modify ROLES if HOSTS not set
+  # Capistrano's default behaviour is for HOSTS to override ROLES
+  def for_roles(roles)
+    old_roles = ENV['ROLES']
+    ENV['ROLES'] = roles.to_s unless ENV['HOSTS']
+    yield
+    ENV['ROLES'] = old_roles.to_s unless ENV['HOSTS']
+  end
+  
+  # Temporarily ignore ROLES and HOSTS
+  def ignoring_roles_and_hosts
+    old_roles = ENV['ROLES']
+    old_hosts = ENV['HOSTS']
+    ENV['ROLES'] = nil
+    ENV['HOSTS'] = nil
+    yield
+    ENV['ROLES'] = old_roles
+    ENV['HOSTS'] = old_hosts
+  end
+  
+  DEPREC_TEMPLATES_BASE = File.join(File.dirname(__FILE__), 'templates')
+
+  # Render template (usually a config file) 
+  # 
+  # Usually we render it to a file on the local filesystem.
+  # This way, we keep a copy of the config file under source control.
+  # We can make manual changes if required and push to new hosts.
+  #
+  # If the options hash contains :path then it's written to that path.
+  # If it contains :remote => true, the file will instead be written to remote targets
+  # If options[:path] and options[:remote] are missing, it just returns the rendered
+  # template as a string (good for debugging).
+  #
+  #  XXX I would like to get rid of :render_template_to_file
+  #  XXX Perhaps pass an option to this function to write to remote
+  #
+  def render_template(app, options={})
+    template = options[:template]
+    path = options[:path] || nil
+    remote = options[:remote] || false
+    mode = options[:mode] || 0755
+    owner = options[:owner] || nil
+  
+    # replace this with a check for the file
+    if ! template
+      puts "render_template() requires a value for the template!"
+      return false 
+    end
+  
+    # If local copies of deprec templates exist they will be used 
+    # If you don't specify the location with the local_template_dir option
+    # it defaults to config/templates.
+    # e.g. config/templates/nginx/nginx.conf.erb
+    local_template = File.join(local_template_dir, app.to_s, template)
+    if File.exists?(local_template)
+      puts
+      puts "Using local template (#{local_template})"
+      template = ERB.new(IO.read(local_template), nil, '-')
+    else
+      template = ERB.new(IO.read(File.join(DEPREC_TEMPLATES_BASE, app.to_s, template)), nil, '-')
+    end
+    rendered_template = template.result(binding)
+  
+    if remote 
+      # render to remote machine
+      puts 'You need to specify a path to render the template to!' unless path
+      exit unless path
+      sudo "test -d #{File.dirname(path)} || sudo mkdir -p #{File.dirname(path)}"
+      std.su_put rendered_template, path, '/tmp/', :mode => mode
+      sudo "chown #{owner} #{path}" if defined?(owner)
+    elsif path 
+      # render to local file
+      full_path = File.join('config', app.to_s, path)
+      path_dir = File.dirname(full_path)
+      if File.exists?(full_path)
+        if IO.read(full_path) == rendered_template
+          puts "[skip] File exists and is identical (#{full_path})."
+          return false
+        elsif overwrite?(full_path, rendered_template)
+          File.delete(full_path)
+        else
+          puts "[skip] Not overwriting #{full_path}"
+          return false
+        end
+      end
+      FileUtils.mkdir_p "#{path_dir}" if ! File.directory?(path_dir)
+      # added line above to make windows compatible
+      # system "mkdir -p #{path_dir}" if ! File.directory?(path_dir) 
+      File.open(full_path, 'w'){|f| f.write rendered_template }
+      puts "[done] #{full_path} written"
+    else
+      # render to string
+      return rendered_template
+    end
+  end
+  
+  def overwrite?(full_path, rendered_template)
+    if defined?(overwrite_all)      
+      if overwrite_all == true
+        return true
+      else
+        return false
+      end
+    end
+    
+    # XXX add :always and :never later - not sure how to set persistent value from here
+    # response = Capistrano::CLI.ui.ask "File exists. Overwrite? ([y]es, [n]o, [a]lways, n[e]ver)" do |q|
+    puts
+    response = Capistrano::CLI.ui.ask "File exists (#{full_path}). 
+    Overwrite? ([y]es, [n]o, [d]iff)" do |q|
+      q.default = 'n'
+    end
+    
+    case response
+    when 'y'
+      return true
+    when 'n'
+      return false
+    when 'd'
+      require 'tempfile'
+      tf = Tempfile.new("deprec_diff") 
+      tf.puts(rendered_template)
+      tf.close
+      puts
+      puts "Running diff -u current_file new_file_if_you_overwrite"
+      puts
+      system "diff -u #{full_path} #{tf.path} | less"
+      puts
+      overwrite?(full_path, rendered_template)
+    # XXX add :always and :never later - not sure how to set persistent value from here  
+    # when 'a'
+    #   set :overwrite_all, true
+    # when 'e'
+    #   set :overwrite_all, false
+    end
+    
+  end
+
+  def render_template_to_file(template_name, destination_file_name, templates_dir = DEPREC_TEMPLATES_BASE)
+    template_name += '.conf' if File.extname(template_name) == '' # XXX this to be removed
+
+    file = File.join(templates_dir, template_name)
+    buffer = render :template => File.read(file)
+
+    temporary_location = "/tmp/#{template_name}"
+    put buffer, temporary_location
+    sudo "cp #{temporary_location} #{destination_file_name}"
+    delete temporary_location
+  end
+  
+  # Copy configs to server(s). Note there is no :pull task. No changes should 
+  # be made to configs on the servers so why would you need to pull them back?
+  def push_configs(app, files)   
+    app = app.to_s
+    files.each do |file|
+      # If the file path is relative we will prepend a path to this projects
+      # own config directory for this service.
+      if file[:path][0,1] != '/'
+        full_remote_path = File.join(deploy_to, app, file[:path]) 
+      else
+        full_remote_path = file[:path]
+      end
+      full_local_path = File.join('config', app, file[:path])
+      sudo "test -d #{File.dirname(full_remote_path)} || sudo mkdir -p #{File.dirname(full_remote_path)}"
+      #
+      # XXX work this in to check for per-host variants of config files
+      #
+      # if any variants of this file exist for this host (they have -hostname at end)
+      #   servers = find_servers_for_task(current_task)
+      #   servers.each do |server|
+      #     puts server(..., :hosts => server) # XXX find a way to restrict su_put to one host
+      #   end
+      # else
+      #   # just send them the normal way, it's quicker in parallel
+        std.su_put File.read(full_local_path), full_remote_path, '/tmp/', :mode=>file[:mode]
+      # end
+      #
+      sudo "chown #{file[:owner]} #{full_remote_path}"
+    end
+  end
+  
+  def teardown_connections
+    sessions.keys.each do |server|
+         sessions[server].close
+         sessions.delete(server)
+    end
+  end
+
+  def append_to_file_if_missing(filename, value, options={})
+    # XXX sort out single quotes in 'value' - they'l break command!
+    # XXX if options[:requires_sudo] and :use_sudo then use sudo
+    sudo <<-END
+    sh -c '
+    grep -F "#{value}" #{filename} > /dev/null 2>&1 || 
+    echo "#{value}" >> #{filename}
+    '
+    END
+  end
+
+  # create new user account on target system
+  def useradd(user, options={})
+    options[:shell] ||= '/bin/bash' # new accounts on ubuntu 6.06.1 have been getting /bin/sh
+    switches = ''
+    switches += " --shell=#{options[:shell]} " if options[:shell]
+    switches += ' --create-home ' unless options[:homedir] == false
+    switches += " --gid #{options[:group]} " unless options[:group].nil?
+    invoke_command "grep '^#{user}:' /etc/passwd || sudo /usr/sbin/useradd #{switches} #{user}", 
+    :via => run_method
+  end
+
+  # create a new group on target system
+  def groupadd(group, options={})
+    via = options.delete(:via) || run_method
+    # XXX I don't like specifying the path to groupadd - need to sort out paths before long
+    invoke_command "grep '#{group}:' /etc/group || sudo /usr/sbin/groupadd #{group}", :via => via
+  end
+
+  # add group to the list of groups this user belongs to
+  def add_user_to_group(user, group)
+    invoke_command "groups #{user} | grep ' #{group} ' || sudo /usr/sbin/usermod -G #{group} -a #{user}",
+    :via => run_method
+  end
+
+  # create directory if it doesn't already exist
+  # set permissions and ownership
+  # XXX move mode, path and
+  def mkdir(path, options={})
+    via = options.delete(:via) || :run
+    # XXX need to make sudo commands wrap the whole command (sh -c ?)
+    # XXX removed the extra 'sudo' from after the '||' - need something else
+    invoke_command "test -d #{path} || #{sudo if via == :sudo} mkdir -p #{path}"
+    invoke_command "chmod #{sprintf("%3o",options[:mode]||0755)} #{path}", :via => via if options[:mode]
+    invoke_command "chown -R #{options[:owner]} #{path}", :via => via if options[:owner]
+    groupadd(options[:group], :via => via) if options[:group]
+    invoke_command "chgrp -R #{options[:group]} #{path}", :via => via if options[:group]
+  end
+  
+  def create_src_dir
+    mkdir(src_dir, :mode => 0775, :group => group_src, :via => :sudo)
+  end
+  
+  # download source package if we don't already have it
+  def download_src(src_package, src_dir)
+    set_package_defaults(src_package)
+    create_src_dir
+    # check if file exists and if we have an MD5 hash or bytecount to compare 
+    # against if so, compare and decide if we need to download again
+    if defined?(src_package[:md5sum])
+      md5_clause = " && echo '#{src_package[:md5sum]}' | md5sum -c - "
+    end
+    case src_package[:download_method]
+      # when getting source with git
+      when :git
+        # ensure git is installed
+        apt.install( {:base => %w(git-core)}, :stable) #TODO fix this to test ubuntu version <hardy might need specific git version for full git submodules support
+        package_dir = File.join(src_dir, src_package[:dir])
+        run "if [ -d #{package_dir} ]; then cd #{package_dir} && #{sudo} git checkout master && #{sudo} git pull && #{sudo} git submodule init && #{sudo} git submodule update; else #{sudo} git clone #{src_package[:url]} #{package_dir} && cd #{package_dir} && #{sudo} git submodule init && #{sudo} git submodule update ; fi"
+      	# Checkout the revision wanted if defined
+      	if src_package[:version]
+      	  run "cd #{package_dir} && git branch | grep '#{src_package[:version]}$' && #{sudo} git branch -D '#{src_package[:version]}'; exit 0"
+      	  run "cd #{package_dir} && #{sudo} git checkout -b #{src_package[:version]} #{src_package[:version]}" 
+        end
+	
+      # when getting source with wget    
+      when :http
+        # ensure wget is installed
+        apt.install( {:base => %w(wget)}, :stable )
+        # XXX replace with invoke_command
+        run "cd #{src_dir} && test -f #{src_package[:filename]} #{md5_clause} || #{sudo} wget --quiet --timestamping #{src_package[:url]}"
+      else
+        puts "DOWNLOAD SRC: Download method not recognised. src_package[:download_method]: #{src_package[:download_method]}"
+    end
+  end
+
+  # unpack src and make it writable by the group
+  def unpack_src(src_package, src_dir)
+    set_package_defaults(src_package)
+    package_dir = File.join(src_dir, src_package[:dir])
+    case src_package[:download_method]
+      # when unpacking git sources - nothing to do
+      when :git
+        puts "UNPACK SRC: nothing to do for git installs"
+      when :http
+        sudo <<-EOF
+        bash -c '
+        cd #{src_dir};
+        test -d #{package_dir}.old && rm -fr #{package_dir}.old;
+        test -d #{package_dir} && mv #{package_dir} #{package_dir}.old;
+        #{src_package[:unpack]}
+        '
+        EOF
+      else
+        puts "UNPACK SRC: Download method not recognised. src_package[:download_method]: #{src_package[:download_method]} "
+    end
+    sudo <<-EOF
+    bash -c '
+    cd #{src_dir};
+    chgrp -R #{group} #{package_dir};  
+    chmod -R g+w #{package_dir};
+    '
+    EOF
+  end
+
+  def set_package_defaults(pkg)
+    pkg[:filename] ||= File.basename(pkg[:url])
+    pkg[:dir] ||= pkg[:filename].sub(/(\.tgz|\.tar\.gz)/,'')
+    pkg[:download_method] ||= :http
+    pkg[:unpack] ||= "tar zxf #{pkg[:filename]};"
+    pkg[:configure] ||= './configure ;'
+    pkg[:make] ||= 'make;'
+    pkg[:install] ||= 'make install;'
+  end
+
+  # install package from source
+  def install_from_src(src_package, src_dir)
+    package_dir = File.join(src_dir, src_package[:dir])
+    unpack_src(src_package, src_dir)
+    apt.install( {:base => %w(build-essential)}, :stable )
+    # XXX replace with invoke_command
+    sudo <<-SUDO
+    sh -c '
+    cd #{package_dir};
+    #{src_package[:configure]}
+    #{src_package[:make]}
+    #{src_package[:install]}
+    #{src_package[:post_install]}
+    '
+    SUDO
+  end
+
+
+  ##
+  # Run a command and ask for input when input_query is seen.
+  # Sends the response back to the server.
+  #
+  # +input_query+ is a regular expression that defaults to /^Password/.
+  #
+  # Can be used where +run+ would otherwise be used.
+  #
+  #  run_with_input 'ssh-keygen ...', /^Are you sure you want to overwrite\?/
+
+  def run_with_input(shell_command, input_query=/^Password/, response=nil)
+    handle_command_with_input(:run, shell_command, input_query, response)
+  end
+
+  ##
+  # Run a command using sudo and ask for input when a regular expression is seen.
+  # Sends the response back to the server.
+  #
+  # See also +run_with_input+
+  #
+  # +input_query+ is a regular expression
+
+  def sudo_with_input(shell_command, input_query=/^Password/, response=nil)
+    handle_command_with_input(:sudo, shell_command, input_query, response)
+  end
+
+  def invoke_with_input(shell_command, input_query=/^Password/, response=nil)
+    handle_command_with_input(run_method, shell_command, input_query, response)
+  end
+
+  ##
+  # Run a command using sudo and continuously pipe the results back to the console.
+  #
+  # Similar to the built-in +stream+, but for privileged users.
+
+  def sudo_stream(command)
+    sudo(command) do |ch, stream, out|
+      puts out if stream == :out
+      if stream == :err
+        puts "[err : #{ch[:host]}] #{out}"
+        break
+      end
+    end
+  end
+
+  # We don't need this. Put 'USER=root' on the command line instead.
+  #
+  # XXX Not working in deprec2
+  # ##
+  # # Run a command using the root account.
+  # #
+  # # Some linux distros/VPS providers only give you a root login when you install.
+  # 
+  # def run_as_root(shell_command)
+  #   std.connect_as_root do |tempuser|
+  #     run shell_command
+  #   end
+  # end
+  # 
+  # ##
+  # # Run a task using root account.
+  # #
+  # # Some linux distros/VPS providers only give you a root login when you install.
+  # #
+  # # tempuser: contains the value replaced by 'root' for the duration of this call
+  # 
+  # def as_root()
+  #   std.connect_as_root do |tempuser|
+  #     yield tempuser
+  #   end
+  # end
+
+  private
+
+  ##
+  # Does the actual capturing of the input and streaming of the output.
+  #
+  # local_run_method: run or sudo
+  # shell_command: The command to run
+  # input_query: A regular expression matching a request for input: /^Please enter your password/
+
+  def handle_command_with_input(local_run_method, shell_command, input_query, response=nil)
+    send(local_run_method, shell_command) do |channel, stream, data|
+      logger.info data, channel[:host]
+      if data =~ input_query
+        if response
+          channel.send_data "#{response}\n"
+        else 
+          response = ::Capistrano::CLI.password_prompt "#{data}"
+          channel.send_data "#{response}\n"
+        end
+      end
+    end
+  end
+  
+end
+
+Capistrano.plugin :deprec2, Deprec2

data/lib/deprec/recipes/aoe.rb

@@ -0,0 +1,79 @@
+# Copyright 2006-2008 by Mike Bailey. All rights reserved.
+Capistrano::Configuration.instance(:must_exist).load do 
+
+  SRC_PACKAGES[:aoe] = {
+    :url => "http://support.coraid.com/support/linux/aoe6-64.tar.gz",
+    :md5sum => "c5e1ebb734e3b29c0a3d886a700ca44a  aoe6-64.tar.gz",
+    :configure => ''
+  }
+  
+  SRC_PACKAGES[:cec] = {
+    :url => "http://easynews.dl.sourceforge.net/sourceforge/aoetools/cec-8.tgz",
+    :md5sum => "7899dc549f9a368e532f9c39ed819f71  cec-8.tgz",
+    :configure => '',
+    :install => "test -f /usr/sbin/cec && rm /usr/sbin/cec; make install;"
+  }
+  
+  SRC_PACKAGES[:ddt] = {
+    :url => "http://support.coraid.com/support/sr/ddt-8.tgz",
+    :md5sum => "256a58aba5e05f9995fb9de6aadadf92  ddt-8.tgz"
+  }
+  
+  SRC_PACKAGES[:aoemask] = {
+    :url => "http://support.coraid.com/support/sr/aoemask-1.tgz",
+    :md5sum => "379461a28d511e269f4593b846bd1288  aoemask-1.tgz"
+  }
+    
+  namespace :deprec do
+    namespace :aoe do
+      
+      desc "Install aoe drivers required to mount Coraid block devices"
+      task :install, :roles => :aoe do
+        install_deps
+        deprec2.download_src(SRC_PACKAGES[:aoe], src_dir)
+        deprec2.install_from_src(SRC_PACKAGES[:aoe], src_dir)
+      end
+
+      task :install_deps, :roles => :aoe do
+        apt.install( {:base => %w(build-essential linux-headers-$(uname -r) vblade aoetools)}, :stable )
+      end
+      
+      desc "Install all AoE related software"
+      task :install_all, :roles => :aoe do
+        top.deprec.aoe.install
+        top.deprec.cec.install
+        top.deprec.ddt.install
+        top.deprec.aoemask.install
+      end
+      
+    end
+
+    namespace :cec do
+      desc "install CEC (Coraid Ethernet Console)"
+      task :install, :roles => :aoe do
+        deprec2.download_src(SRC_PACKAGES[:cec], src_dir)
+        deprec2.install_from_src(SRC_PACKAGES[:cec], src_dir)
+      end
+    end
+    
+    namespace :ddt do
+      desc "install DDT (tool for testing performance)"
+      task :install, :roles => :aoe do
+        deprec2.download_src(SRC_PACKAGES[:ddt], src_dir)
+        deprec2.install_from_src(SRC_PACKAGES[:ddt], src_dir)
+      end
+    end
+    
+    namespace :aoemask do
+      desc "install aoemask"
+      task :install, :roles => :aoe do
+        deprec2.download_src(SRC_PACKAGES[:aoemask], src_dir)
+        deprec2.install_from_src(SRC_PACKAGES[:aoemask], src_dir)
+      end
+    end
+        
+  end
+  
+end
+
+

data/lib/deprec/recipes/apache.rb

@@ -0,0 +1,179 @@
+# Copyright 2006-2008 by Mike Bailey. All rights reserved.
+Capistrano::Configuration.instance(:must_exist).load do 
+  namespace :deprec do
+    namespace :apache do
+      
+      # put apache config for site in shared/config/apache2 dir
+      # link it into apps to enable, unlink to disable? 
+      # http://times.usefulinc.com/2006/09/15-rails-debian-apache
+      
+      # XXX Check this over after a nice sleep
+      #
+      # def set_apache_conf
+      #   if apache_default_vhost
+      #     set :apache_conf, "/usr/local/apache2/conf/default.conf" unless apache_default_vhost_conf
+      #   else 
+      #     set :apache_conf, "/usr/local/apache2/conf/apps/#{application}.conf" unless apache_conf
+      #   end
+      # end
+        
+      set(:apache_server_name) { domain }
+      set :apache_user, 'daemon' # XXX this is not yet being inserted into httpd.conf!
+                                 # I've added it for deprec:nagios:install
+      set :apache_conf, nil
+      set :apache_default_vhost, false
+      set :apache_default_vhost_conf, nil
+      set :apache_ctl, "/usr/local/apache2/bin/apachectl"
+      set(:apache_server_aliases) { web_server_aliases }
+      set :apache_proxy_port, 8000
+      set :apache_proxy_servers, 2
+      set :apache_proxy_address, "127.0.0.1"
+      set :apache_ssl_enabled, false
+      set :apache_ssl_ip, nil
+      set :apache_ssl_forward_all, false
+      set :apache_ssl_chainfile, false
+      set :apache_docroot, '/usr/local/apache2/htdocs'
+      set :apache_vhost_dir, '/usr/local/apache2/conf/apps'
+      set :apache_config_file, '/usr/local/apache2/conf/httpd.conf'
+      
+      SRC_PACKAGES[:apache] = {
+        :md5sum => "80d3754fc278338033296f0d41ef2c04  httpd-2.2.9.tar.gz", 
+        :url => "http://www.apache.org/dist/httpd/httpd-2.2.9.tar.gz",
+        :configure => %w(
+          ./configure
+          --enable-mods-shared=all
+          --enable-proxy 
+          --enable-proxy-balancer 
+          --enable-proxy-http 
+          --enable-rewrite  
+          --enable-cache 
+          --enable-headers 
+          --enable-ssl 
+          --enable-deflate 
+          --with-included-apr   #_so_this_recipe_doesn't_break_when_rerun
+          --enable-dav          #_for_subversion_
+          --enable-so           #_for_subversion_
+          ;
+          ).reject{|arg| arg.match '#'}.join(' '),
+        :make => 'make;',
+        :post_install => 'install -b support/apachectl /etc/init.d/httpd;'
+      }
+      
+      desc "Install apache"
+      task :install do
+        install_deps
+        deprec2.download_src(SRC_PACKAGES[:apache], src_dir)
+        deprec2.install_from_src(SRC_PACKAGES[:apache], src_dir)
+        setup_vhost_dir
+        # install_index_page
+        activate
+        SYSTEM_CONFIG_FILES[:apache].each do |file|
+          deprec2.render_template(:apache, file.merge(:remote => true))
+        end
+      end
+      
+      # install dependencies for apache
+      task :install_deps do
+        apt.install( {:base => %w(zlib1g-dev zlib1g openssl libssl-dev)}, :stable )
+      end
+      
+      # Create dir for vhost config files
+      task :setup_vhost_dir do
+        deprec2.mkdir(apache_vhost_dir, :owner => 'root', :group => group, :mode => 0775, :via => :sudo)
+        deprec2.append_to_file_if_missing(apache_config_file, 'Include conf/apps/')
+      end
+      
+      SYSTEM_CONFIG_FILES[:apache] = [
+        # They're generated and put in place during install
+        # I may put them in here at some point
+      ]
+
+      PROJECT_CONFIG_FILES[:apache] = [
+        
+        {:template => "httpd-vhost-app.conf.erb",
+         :path => 'conf/httpd-vhost-app.conf',
+         :mode => 0755,
+         :owner => 'root:root'}
+      ]
+
+      desc "Generate configuration file(s) for apache from template(s)"
+      task :config_gen do
+        config_gen_system
+        config_gen_project
+      end
+
+      task :config_gen_system do
+        SYSTEM_CONFIG_FILES[:apache].each do |file|
+          deprec2.render_template(:apache, file)
+        end
+      end
+
+      task :config_gen_project do
+        PROJECT_CONFIG_FILES[:apache].each do |file|
+          deprec2.render_template(:apache, file)
+        end
+      end
+      
+      desc "Push apache config files to server"
+      task :config, :roles => :web do
+        config_system
+        config_project
+      end
+
+      task :config_system, :roles => :web do
+        deprec2.push_configs(:apache, SYSTEM_CONFIG_FILES[:apache])
+      end
+
+      task :config_project, :roles => :web do
+        deprec2.push_configs(:apache, PROJECT_CONFIG_FILES[:apache])
+        sudo "ln -sf #{deploy_to}/apache/conf/httpd-vhost-app.conf /usr/local/apache2/conf/apps/#{application}.conf"        
+      end
+
+      desc "Start Apache"
+      task :start, :roles => :web do
+        send(run_method, "#{apache_ctl} start")
+      end
+
+      desc "Stop Apache"
+      task :stop, :roles => :web do
+        send(run_method, "#{apache_ctl} stop")
+      end
+
+      desc "Restart Apache"
+      task :restart, :roles => :web do
+        send(run_method, "#{apache_ctl} restart")
+      end
+
+      desc "Reload Apache"
+      task :reload, :roles => :web do
+        send(run_method, "#{apache_ctl} reload")
+      end
+
+      desc "Set apache to start on boot"
+      task :activate do
+        send(run_method, "update-rc.d httpd defaults")
+      end
+      
+      desc "Set apache to not start on boot"
+      task :deactivate, :roles => :web do
+        send(run_method, "update-rc.d -f httpd remove")
+      end
+      
+      task :backup, :roles => :web do
+        # not yet implemented
+      end
+      
+      task :restore, :roles => :web do
+        # not yet implemented
+      end
+
+      # Generate an index.html page  
+      task :install_index_page do
+        deprec2.mkdir(apache_docroot, :owner => :root, :group => :deploy, :mode => 0775, :via => :sudo)
+        std.su_put deprec2.render_template(:apache, :template => 'index.html.erb'), File.join(apache_docroot, 'index.html')
+        std.su_put deprec2.render_template(:apache, :template => 'master.css'), File.join(apache_docroot, 'master.css')
+      end
+      
+    end
+  end
+end