dreamcat4-moonshadow 0.0.1

data/lib/moonshine/manifest.rb

@@ -0,0 +1,151 @@
+# This is the base Moonshine Manifest class, which provides a simple system
+# for loading moonshine recpies from plugins, a template helper, and parses
+# several configuration files:
+#
+#   config/moonshine.yml
+#
+# The contents of <tt>config/moonshine.yml</tt> are expected to serialize into
+# a hash, and are loaded into the manifest's Configatron::Store.
+#
+#   config/database.yml
+#
+# The contents of your database config are parsed and are available at
+# <tt>configuration[:database]</tt>.
+#
+# If you'd like to create another 'default rails stack' using other tools that
+# what Moonshine::Manifest::Rails uses, subclass this and go nuts.
+class Moonshine::Manifest < ShadowPuppet::Manifest
+  # Load a Moonshine Plugin
+  #
+  #   class MyManifest < Moonshine::Manifest
+  #
+  #     # Evals vendor/plugins/moonshine_my_app/moonshine/init.rb
+  #     plugin :moonshine_my_app
+  #
+  #     # Evals lib/my_recipe.rb
+  #     plugin 'lib/my_recipe.rb'
+  #
+  #     ...
+  #   end
+  def self.plugin(name = nil)
+    if name.is_a?(Symbol)
+      path = File.join(rails_root, 'vendor', 'plugins', 'moonshine_' + name.to_s, 'moonshine', 'init.rb')
+    else
+      path = name
+    end
+    Kernel.eval(File.read(path), binding, path)
+    true
+  end
+
+  # The working directory of the Rails application this manifests describes.
+  def self.rails_root
+   @rails_root ||= File.expand_path(ENV["RAILS_ROOT"] || Dir.getwd)
+  end
+
+  def rails_root
+   self.class.rails_root
+  end
+
+  # The current Rails environment
+  def self.rails_env
+    ENV["RAILS_ENV"] || 'production'
+  end
+
+  # The current Rails environment
+  def rails_env
+    self.class.rails_env
+  end
+
+  # The current environment's database configuration
+  def database_environment
+   configuration[:database][rails_env.to_sym]
+  end
+
+  # The current deployment target. Best when used with capistrano-ext's multistage settings.
+  def self.deploy_stage
+    ENV['DEPLOY_STAGE'] || 'undefined'
+  end
+
+  # The current deployment target. Best when used with capistrano-ext's multistage settings.
+  def deploy_stage
+    self.class.deploy_stage
+  end
+
+  # Only run tasks on the specified deploy_stage.
+  #
+  # You can call it with the exact stage you want to run on:
+  #
+  #  on_stage(:my_stage) do
+  #    puts "I'm on my_stage"
+  #  end
+  #
+  # Or you can pass an array of stages to run on:
+  #
+  #  on_stage(:my_stage, :my_other_stage) do
+  #    puts "I'm on one of my stages"
+  #  end
+  #
+  # Or you can run a task unless it is on a stage:
+  #
+  #  on_stage(:unless => :my_stage) do
+  #    puts "I'm not on my_stage"
+  #  end
+  #
+  # Or you can run a task unless it is on one of several stages:
+  #
+  #  on_stage(:unless => [:my_stage, :my_other_stage]) do
+  #    puts "I'm not on my stages"
+  #  end
+  def on_stage(*args)
+    options = args.extract_options!
+    if_opt = options[:if]
+    unless_opt = options[:unless]
+
+    unless if_opt || unless_opt
+      if_opt = args
+    end
+
+    if if_opt && if_opt.is_a?(Array) && if_opt.map {|x| x.to_s}.include?(deploy_stage)
+      yield
+    elsif if_opt && (if_opt.is_a?(String) || if_opt.is_a?(Symbol)) && deploy_stage == if_opt.to_s
+      yield
+    elsif unless_opt && unless_opt.is_a?(Array) && !unless_opt.map {|x| x.to_s}.include?(deploy_stage)
+      yield
+    elsif unless_opt && (unless_opt.is_a?(String) || unless_opt.is_a?(Symbol)) && deploy_stage != unless_opt.to_s
+      yield
+    end
+  end
+
+  # Render the ERB template located at <tt>pathname</tt>. If a template exists
+  # with the same basename at <tt>RAILS_ROOT/app/manifests/templates</tt>, it
+  # is used instead. This is useful to override templates provided by plugins
+  # to customize application configuration files.
+  def template(pathname, b = binding)
+    template_contents = nil
+    basename = pathname.index('/') ? pathname.split('/').last : pathname
+    if File.exist?(File.expand_path(File.join(rails_root, 'app', 'manifests', 'templates', basename)))
+      template_contents = File.read(File.expand_path(File.join(rails_root, 'app', 'manifests', 'templates', basename)))
+    elsif File.exist?(File.expand_path(pathname))
+      template_contents = File.read(File.expand_path(pathname))
+    else
+      raise LoadError, "Can't find template #{pathname}"
+    end
+    ERB.new(template_contents).result(b)
+  end
+
+  def self.initial_configuration
+    # config/moonshine.yml
+    moonshine_yml = IO.read(File.join(rails_root, 'config', 'moonshine.yml')) rescue nil
+    configure(YAML::load(ERB.new(moonshine_yml).result)) if moonshine_yml
+
+    # database config
+    database_yml = IO.read(File.join(rails_root, 'config', 'database.yml')) rescue nil
+    configure(:database => YAML::load(ERB.new(database_yml).result)) if database_yml
+
+    # gems
+    configure(:gems => (YAML.load_file(File.join(rails_root, 'config', 'gems.yml')) rescue nil))
+  end
+
+  initial_configuration
+
+end

data/lib/moonshine/manifest/rails.rb

@@ -0,0 +1,54 @@
+#The Rails Manifest includes recipes for Apache, Mysql, Sqlite3 and Rails
+#running on Ubuntu 8.04 or greater.
+class Moonshine::Manifest::Rails < Moonshine::Manifest
+  def validate_platform
+    unless Facter.lsbdistid == 'Ubuntu' && Facter.lsbdistrelease.to_f >= 8.04
+      error = <<-ERROR
+
+
+      Moonshine::Manifest::Rails is currently only supported on Ubuntu 8.04
+      or greater. If you'd like to see your favorite distro supported, fork
+      Moonshine on GitHub!
+      ERROR
+      raise NotImplementedError, error
+    end
+  end
+  recipe :validate_platform
+
+  configure(:apt_gems => YAML.load_file(File.join(File.dirname(__FILE__), 'rails', 'apt_gems.yml')))
+
+  require File.join(File.dirname(__FILE__), 'rails', 'passenger.rb')
+  include Moonshine::Manifest::Rails::Passenger
+  require File.join(File.dirname(__FILE__), 'rails', 'mysql.rb')
+  include Moonshine::Manifest::Rails::Mysql
+  require File.join(File.dirname(__FILE__), 'rails', 'postgresql.rb')
+  include Moonshine::Manifest::Rails::Postgresql
+  require File.join(File.dirname(__FILE__), 'rails', 'sqlite3.rb')
+  include Moonshine::Manifest::Rails::Sqlite3
+  require File.join(File.dirname(__FILE__), 'rails', 'apache.rb')
+  include Moonshine::Manifest::Rails::Apache
+  require File.join(File.dirname(__FILE__), 'rails', 'rails.rb')
+  include Moonshine::Manifest::Rails::Rails
+  require File.join(File.dirname(__FILE__), 'rails', 'os.rb')
+  include Moonshine::Manifest::Rails::Os
+
+  # A super recipe for installing Apache, Passenger, a database, 
+  # Rails, NTP, Cron, Postfix. To customize your stack, call the
+  # individual recipes you want to include rather than default_stack.
+  #
+  # The database installed is based on the adapter in database.yml.
+  def default_stack
+    self.class.recipe :apache_server
+    self.class.recipe :passenger_gem, :passenger_configure_gem_path, :passenger_apache_module, :passenger_site
+    case database_environment[:adapter]
+    when 'mysql'
+      self.class.recipe :mysql_server, :mysql_gem, :mysql_database, :mysql_user, :mysql_fixup_debian_start
+    when 'postgresql'
+      self.class.recipe :postgresql_server, :postgresql_gem, :postgresql_user, :postgresql_database
+    when 'sqlite' || 'sqlite3'
+      self.class.recipe :sqlite3
+    end
+    self.class.recipe :rails_rake_environment, :rails_gems, :rails_directories, :rails_bootstrap, :rails_migrations, :rails_logrotate
+    self.class.recipe :ntp, :time_zone, :postfix, :cron_packages, :motd, :security_updates
+  end
+end

data/lib/moonshine/manifest/rails/apache.rb

@@ -0,0 +1,99 @@
+module Moonshine::Manifest::Rails::Apache
+
+  # Installs Apache 2.2 and enables mod_rewrite and mod_status. Enables mod_ssl
+  # if <tt>configuration[:ssl]</tt> is present
+  def apache_server
+    package "apache2-mpm-worker", :ensure => :installed
+    service "apache2", :require => package("apache2-mpm-worker"), :restart => '/etc/init.d/apache2 restart', :ensure => :running
+    a2enmod('rewrite')
+    a2enmod('status')
+    if configuration[:ssl]
+      a2enmod('headers')
+      a2enmod('ssl')
+    end
+    if configuration[:apache] && configuration[:apache][:users]
+      htpasswd = configuration[:apache][:htpasswd] || "#{configuration[:deploy_to]}/shared/config/htpasswd"
+      
+      file htpasswd, :ensure => :file, :owner => 'rails', :mode => '644'
+      
+      configuration[:apache][:users].each do |user,pass|
+        exec "htpasswd #{user}",
+          :command => "htpasswd -b #{htpasswd} #{user} #{pass}",
+          :unless  => "grep '#{user}' #{htpasswd}"
+      end
+    end
+    status = <<-STATUS
+<IfModule mod_status.c>
+ExtendedStatus On
+<Location /server-status>
+     SetHandler server-status
+     order deny,allow
+     deny from all
+     allow from 127.0.0.1
+</Location>
+</IfModule>
+STATUS
+    file '/etc/apache2/mods-available/status.conf',
+      :ensure => :present,
+      :mode => '644',
+      :require => exec('a2enmod status'),
+      :content => status,
+      :notify => service("apache2")
+    file '/etc/logrotate.d/varlogapachelog.conf', :ensure => :absent
+  end
+
+private
+
+  # Symlinks a site from <tt>/etc/apache2/sites-enabled/site</tt> to
+  #<tt>/etc/apache2/sites-available/site</tt>. Creates
+  #<tt>exec("a2ensite #{site}")</tt>.
+  def a2ensite(site, options = {})
+    exec("a2ensite #{site}", {
+        :command => "/usr/sbin/a2ensite #{site}",
+        :unless => "ls /etc/apache2/sites-enabled/#{site}",
+        :require => package("apache2-mpm-worker"),
+        :notify => service("apache2")
+      }.merge(options)
+    )
+  end
+
+  # Removes a symlink from <tt>/etc/apache2/sites-enabled/site</tt> to
+  #<tt>/etc/apache2/sites-available/site</tt>. Creates
+  #<tt>exec("a2dissite #{site}")</tt>.
+  def a2dissite(site, options = {})
+    exec("a2dissite #{site}", {
+        :command => "/usr/sbin/a2dissite #{site}",
+        :onlyif => "ls /etc/apache2/sites-enabled/#{site}",
+        :require => package("apache2-mpm-worker"),
+        :notify => service("apache2")
+      }.merge(options)
+    )
+  end
+
+  # Symlinks a module from <tt>/etc/apache2/mods-enabled/mod</tt> to
+  #<tt>/etc/apache2/mods-available/mod</tt>. Creates
+  #<tt>exec("a2enmod #{mod}")</tt>.
+  def a2enmod(mod, options = {})
+    exec("a2enmod #{mod}", {
+        :command => "/usr/sbin/a2enmod #{mod}",
+        :unless => "ls /etc/apache2/mods-enabled/#{mod}.load",
+        :require => package("apache2-mpm-worker"),
+        :notify => service("apache2")
+      }.merge(options)
+    )
+  end
+
+  # Removes a symlink from <tt>/etc/apache2/mods-enabled/mod</tt> to
+  #<tt>/etc/apache2/mods-available/mod</tt>. Creates
+  #<tt>exec("a2dismod #{mod}")</tt>.
+  def a2dismod(mod, options = {})
+    exec("a2dismod #{mod}", {
+        :command => "/usr/sbin/a2enmod #{mod}",
+        :onlyif => "ls /etc/apache2/mods-enabled/#{mod}.load",
+        :require => package("apache2-mpm-worker"),
+        :notify => service("apache2")
+      }.merge(options)
+    )
+  end
+  
+end

data/lib/moonshine/manifest/rails/apt_gems.yml

@@ -0,0 +1,32 @@
+curb:
+- libcurl4-openssl-dev
+mysql:
+- libmysqlclient15-dev
+sqlite3-ruby:
+- sqlite3
+- libsqlite3-dev
+nokogiri:
+- libxml2-dev
+- libxslt1-dev
+rmagick:
+- imagemagick
+- libmagick9-dev
+paperclip:
+- imagemagick
+- libmagick9-dev
+thoughtbot-paperclip:
+- imagemagick
+- libmagick9-dev
+mini_magick:
+- imagemagick
+- libmagick9-dev
+postgres:
+- postgresql-client
+- postgresql-contrib
+- libpq-dev
+libxml-ruby:
+- libxml2
+- libxml2-dev
+image_science:
+- libfreeimage3
+- libfreeimage-dev

data/lib/moonshine/manifest/rails/mysql.rb

@@ -0,0 +1,79 @@
+module Moonshine::Manifest::Rails::Mysql
+
+  # Installs <tt>mysql-server</tt> from apt and enables the <tt>mysql</tt>
+  # service. Also creates a configuration file at
+  # <tt>/etc/mysql/conf.d/moonshine.cnf</tt>. See
+  # <tt>templates/moonshine.cnf</tt> for configuration options.
+  def mysql_server
+    package 'mysql-server', :ensure => :installed
+    service 'mysql', :ensure => :running, :require => [
+      package('mysql-server'),
+      package('mysql')
+    ]
+    #ensure the mysql key is present on the configuration hash
+    configure(:mysql => {})
+    file '/etc/mysql', :ensure => :directory
+    file '/etc/mysql/conf.d', :ensure => :directory
+    file '/etc/mysql/conf.d/innodb.cnf',
+      :ensure => :present,
+      :content => template(File.join(File.dirname(__FILE__), 'templates', 'innodb.cnf.erb')),
+      :before => package('mysql-server')
+    file '/etc/mysql/conf.d/moonshine.cnf',
+      :ensure => :present,
+      :content => template(File.join(File.dirname(__FILE__), 'templates', 'moonshine.cnf.erb')),
+      :require => package('mysql-server'),
+      :notify => service('mysql')
+    file '/etc/logrotate.d/varlogmysql.conf', :ensure => :absent
+  end
+
+  # Install the <tt>mysql</tt> rubygem and dependencies
+  def mysql_gem
+    gem('mysql')
+  end
+
+  # GRANT the database user specified in the current <tt>database_environment</tt>
+  # permisson to access the database with the supplied password
+  def mysql_user
+    grant =<<EOF
+GRANT ALL PRIVILEGES 
+ON #{database_environment[:database]}.*
+TO #{database_environment[:username]}@localhost
+IDENTIFIED BY \\"#{database_environment[:password]}\\";
+FLUSH PRIVILEGES;
+EOF
+
+    exec "mysql_user",
+      :command => mysql_query(grant),
+      :unless  => "mysqlshow -u#{database_environment[:username]} -p#{database_environment[:password]} #{database_environment[:database]}",
+      :require => exec('mysql_database'),
+      :before => exec('rake tasks')
+  end
+
+  # Create the database from the current <tt>database_environment</tt>
+  def mysql_database
+    exec "mysql_database",
+      :command => mysql_query("create database #{database_environment[:database]};"),
+      :unless => mysql_query("show create database #{database_environment[:database]};"),
+      :require => service('mysql'),
+      :notify => exec('rails_bootstrap')
+  end
+
+  # Noop <tt>/etc/mysql/debian-start</tt>, which does some nasty table scans on
+  # MySQL start.
+  def mysql_fixup_debian_start
+    file '/etc/mysql/debian-start',
+      :ensure => :present,
+      :content => "#!/bin/bash\nexit 0",
+      :mode => '755',
+      :owner => 'root',
+      :require => package('mysql-server')
+  end
+
+private
+
+  # Internal helper to shell out and run a query. Doesn't select a database.
+  def mysql_query(sql)
+    "su -c \'/usr/bin/mysql -u root -e \"#{sql}\"\'"
+  end
+
+end

data/lib/moonshine/manifest/rails/os.rb

@@ -0,0 +1,115 @@
+module Moonshine::Manifest::Rails::Os
+  # Set up cron and enable the service. You can create cron jobs in your
+  # manifests like so:
+  #
+  #   cron :run_me_at_three
+  #     :command => "/usr/sbin/something",
+  #     :user => root,
+  #     :hour => 3
+  #
+  #   cron 'rake:task',
+  #       :command => "cd #{rails_root} && RAILS_ENV=#{ENV['RAILS_ENV']} rake rake:task",
+  #       :user => configuration[:user],
+  #       :minute => 15
+  def cron_packages
+    service "cron", :require => package("cron"), :ensure => :running
+    package "cron", :ensure => :installed
+  end
+
+  # Create a MOTD to remind those logging in via SSH that things are managed
+  # with Moonshine
+  def motd
+    motd_contents ="""-----------------
+Moonshine Managed
+-----------------
+
+  Application:  #{configuration[:application]}
+  Repository:   #{configuration[:repository]}
+  Deploy Path:  #{configuration[:deploy_to]}
+
+----------------
+  A Reminder
+----------------
+As the configuration of this server is managed with Moonshine, please refrain
+from installing any gems, packages, or dependencies directly on the server.
+----------------
+"""
+    file '/var/run/motd',
+      :mode => '644',
+      :content => `uname -snrvm`+motd_contents
+    file '/etc/motd.tail',
+      :mode => '644',
+      :content => motd_contents
+  end
+
+  # Install postfix.
+  def postfix
+    package 'postfix', :ensure => :latest
+  end
+
+  # Install ntp and enables the ntp service.
+  def ntp
+    package 'ntp', :ensure => :latest
+    service 'ntp', :ensure => :running, :require => package('ntp'), :pattern => 'ntpd'
+  end
+
+  # Set the system timezone to <tt>configuration[:time_zone]</tt> or 'UTC' by
+  # default.
+  def time_zone
+    zone = configuration[:time_zone] || 'UTC'
+    zone = 'UTC' if zone.nil? || zone.strip == ''
+    file "/etc/timezone",
+      :content => zone+"\n",
+      :ensure => :present
+    file "/etc/localtime",
+      :ensure => "/usr/share/zoneinfo/#{zone}",
+      :notify => service('ntp')
+  end
+
+  # Configure automatic security updates. Output regarding errors
+  # will be sent to <tt>configuration[:user]</tt>. To exclude specific
+  # packages from these upgrades, create an array of packages on
+  # <tt>configuration[:unattended_upgrade][:package_blacklist]</tt>
+  def security_updates
+    configure(:unattended_upgrade => {})
+    unattended_config = <<-CONFIG
+APT::Periodic::Update-Package-Lists "#{configuration[:unattended_upgrade][:package_lists]||1}";
+APT::Periodic::Unattended-Upgrade "#{configuration[:unattended_upgrade][:interval]||1}";
+CONFIG
+
+    package 'unattended-upgrades', :ensure => :latest
+    file '/etc/apt/apt.conf.d/10periodic',
+      :ensure => :present,
+      :mode => '644',
+      :content => unattended_config
+    file '/etc/apt/apt.conf.d/50unattended-upgrades',
+      :ensure => :present,
+      :mode => '644',
+      :content => template(File.join(File.dirname(__FILE__), "templates", "unattended_upgrades.erb"))
+  end
+
+private
+
+  #Provides a helper for creating logrotate config for various parts of your
+  #stack. For example:
+  #
+  #  logrotate('/srv/theapp/shared/logs/*.log', {
+  #    :options => %w(daily missingok compress delaycompress sharedscripts),
+  #    :postrotate => 'touch /srv/theapp/current/tmp/restart.txt'
+  #  })
+  #
+  def logrotate(log_or_glob, options = {})
+    options = options.respond_to?(:to_hash) ? options.to_hash : {}
+
+    package "logrotate", :ensure => :installed, :require => package("cron"), :notify => service("cron")
+
+    safename = log_or_glob.gsub(/[^a-zA-Z]/, '')
+
+    file "/etc/logrotate.d/#{safename}.conf",
+      :ensure => :present,
+      :content => template(File.join(File.dirname(__FILE__), "templates", "logrotate.conf.erb"), binding),
+      :notify => service("cron"),
+      :alias => "logrotate_#{safename}"
+  end
+
+end