dreamcat4-moonshadow 0.0.1

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

@@ -0,0 +1,93 @@
+module Moonshine::Manifest::Rails::Passenger
+  # Install the passenger gem
+  def passenger_gem
+    configure(:passenger => {})
+    package "passenger", :ensure => (configuration[:passenger][:version] || :latest), :provider => :gem
+  end
+
+  # Build, install, and enable the passenger apache module. Please see the
+  # <tt>passenger.conf.erb</tt> template for passenger configuration options.
+  def passenger_apache_module
+    # Install Apache2 developer library
+    package "apache2-threaded-dev", :ensure => :installed
+
+    file "/usr/local/src", :ensure => :directory
+
+    exec "symlink_passenger",
+      :command => 'ln -nfs `passenger-config --root` /usr/local/src/passenger',
+      :unless => 'ls -al /usr/local/src/passenger | grep `passenger-config --root`',
+      :require => [
+        package("passenger"),
+        file("/usr/local/src")
+      ]
+
+    # Build Passenger from source
+    exec "build_passenger",
+      :cwd => configuration[:passenger][:path],
+      :command => '/usr/bin/ruby -S rake clean apache2',
+      :unless => "ls `passenger-config --root`/ext/apache2/mod_passenger.so",
+      :require => [
+        package("passenger"),
+        package("apache2-mpm-worker"),
+        package("apache2-threaded-dev"),
+        exec('symlink_passenger')
+      ]
+
+    load_template = "LoadModule passenger_module #{configuration[:passenger][:path]}/ext/apache2/mod_passenger.so"
+
+    file '/etc/apache2/mods-available/passenger.load',
+      :ensure => :present,
+      :content => load_template,
+      :require => [exec("build_passenger")],
+      :notify => service("apache2"),
+      :alias => "passenger_load"
+
+    file '/etc/apache2/mods-available/passenger.conf',
+      :ensure => :present,
+      :content => template(File.join(File.dirname(__FILE__), 'templates', 'passenger.conf.erb')),
+      :require => [exec("build_passenger")],
+      :notify => service("apache2"),
+      :alias => "passenger_conf"
+
+    a2enmod 'passenger', :require => [exec("build_passenger"), file("passenger_conf"), file("passenger_load")]
+  end
+
+  # Creates and enables a vhost configuration named after your application.
+  # Also ensures that the <tt>000-default</tt> vhost is disabled.
+  def passenger_site
+    file "/etc/apache2/sites-available/#{configuration[:application]}",
+      :ensure => :present,
+      :content => template(File.join(File.dirname(__FILE__), 'templates', 'passenger.vhost.erb')),
+      :notify => service("apache2"),
+      :alias => "passenger_vhost",
+      :require => exec("a2enmod passenger")
+
+    a2dissite '000-default', :require => file("passenger_vhost")
+    a2ensite configuration[:application], :require => file("passenger_vhost")
+  end
+
+  def passenger_configure_gem_path
+    configure(:passenger => {})
+    return configuration[:passenger][:path] if configuration[:passenger][:path]
+    version = begin
+      configuration[:passenger][:version] || Gem::SourceIndex.from_installed_gems.find_name("passenger").last.version.to_s
+    rescue
+      `gem install passenger --no-ri --no-rdoc`
+      `passenger-config --version`.chomp
+    end
+    configure(:passenger => { :path => "#{Gem.dir}/gems/passenger-#{version}" })
+  end
+
+private
+
+  def passenger_config_boolean(key)
+    if key.nil?
+      nil
+    elsif key == 'Off' || (!!key) == false
+      'Off'
+    else
+      'On'
+    end
+  end
+
+end

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

@@ -0,0 +1,83 @@
+# To use PostgreSQL, add the following recipes calls to your manifest:
+#
+#    recipe :postgresql_server, :postgresql_gem, :postgresql_user, :postgresql_database
+#
+module Moonshine::Manifest::Rails::Postgresql
+
+  # Installs <tt>postgresql</tt> from apt and enables the <tt>postgresql</tt>
+  # service.
+  def postgresql_server
+    package 'postgresql', :ensure => :installed
+    package 'postgresql-client', :ensure => :installed
+    package 'postgresql-contrib', :ensure => :installed
+    package 'libpq-dev', :ensure => :installed
+    service 'postgresql-8.3',
+      :ensure     => :running,
+      :hasstatus  => true,
+      :require    => [
+        package('postgresql'),
+        package('postgres'),
+        package('pg')
+      ]
+    #ensure the postgresql key is present on the configuration hash
+    configure(:postgresql => {})
+    file '/etc/postgresql/8.3/main/pg_hba.conf',
+      :ensure  => :present,
+      :content => template(File.join(File.dirname(__FILE__), 'templates', 'pg_hba.conf.erb')),
+      :require => package('postgresql'),
+      :mode    => '600',
+      :owner   => 'postgres',
+      :group   => 'postgres',
+      :notify  => service('postgresql-8.3')
+    file '/etc/postgresql/8.3/main/postgresql.conf',
+      :ensure  => :present,
+      :content => template(File.join(File.dirname(__FILE__), 'templates', 'postgresql.conf.erb')),
+      :require => package('postgresql'),
+      :mode    => '600',
+      :owner   => 'postgres',
+      :group   => 'postgres',
+      :notify  => service('postgresql-8.3')
+  end
+
+  # Install the <tt>pg</tt> rubygem and dependencies
+  def postgresql_gem
+    gem 'pg'
+    gem 'postgres'
+  end
+
+  # Grant the database user specified in the current <tt>database_environment</tt>
+  # permisson to access the database with the supplied password
+  def postgresql_user
+    psql "CREATE USER #{database_environment[:username]} WITH PASSWORD '#{database_environment[:password]}'",
+      :alias    => "postgresql_user",
+      :unless   => psql_query('\\\\du') + "| grep #{database_environment[:username]}",
+      :require  => service('postgresql-8.3')
+  end
+
+  # Create the database from the current <tt>database_environment</tt>
+  def postgresql_database
+    exec "postgresql_database",
+      :command  => "/usr/bin/createdb -O #{database_environment[:username]} #{database_environment[:database]}",
+      :unless   => "/usr/bin/psql -l | grep #{database_environment[:database]}",
+      :user     => 'postgres',
+      :require  => exec('postgresql_user'),
+      :before   => exec('rake tasks'),
+      :notify   => exec('rails_bootstrap')
+  end
+
+private
+
+  def psql(query, options = {})
+    name = "psql #{query}"
+    hash = {
+      :command => psql_query(query),
+      :user => 'postgres'
+    }.merge(options)
+    exec(name,hash)
+  end
+
+  def psql_query(sql)
+    "/usr/bin/psql -c \"#{sql}\""
+  end
+
+end

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

@@ -0,0 +1,237 @@
+module Moonshine::Manifest::Rails::Rails
+
+  # Attempt to bootstrap your application. Calls <tt>rake moonshine:bootstrap</tt>
+  # which runs:
+  #
+  #   rake db:schema:load (if db/schema.rb exists)
+  #   rake db:migrate (if db/migrate exists)
+  #
+  # We then run a task to load bootstrap fixtures from <tt>db/bootstrap</tt>
+  # (if it exists). These fixtures may be created with the included
+  # <tt>moonshine:db:bootstrap:dump</tt> rake task.
+  #
+  #   rake moonshine:db:bootstrap
+  #
+  # We then run the following task:
+  #
+  #   rake moonshine:app:bootstrap
+  #
+  # The <tt>moonshine:app:bootstrap</tt> task does nothing by default. If
+  # you'd like to have your application preform any logic on it's first deploy,
+  # overwrite this task in your <tt>Rakefile</tt>:
+  #
+  #   namespace :moonshine do
+  #     namespace :app do
+  #       desc "Overwrite this task in your app if you have any bootstrap tasks that need to be run"
+  #       task :bootstrap do
+  #         #
+  #       end
+  #     end
+  #   end
+  #
+  # All of this assumes one things. That your application can run 'rake
+  # environment' with an empty database. Please ensure your application can do
+  # so!
+  def rails_bootstrap
+    rake 'moonshine:bootstrap',
+      :alias => 'rails_bootstrap',
+      :refreshonly => true,
+      :before => exec('rake db:migrate')
+  end
+
+  # Runs Rails migrations. These are run on each deploy to ensure consistency!
+  # No more 500s when you forget to <tt>cap deploy:migrations</tt>
+  def rails_migrations
+    rake 'db:migrate'
+  end
+
+  # Rotates the logs for this rails app
+  def rails_logrotate
+    configure(:rails_logrotate => {})
+    logrotate("#{configuration[:deploy_to]}/shared/log/*.log", {
+      :options => configuration[:rails_logrotate][:options] || %w(daily missingok compress delaycompress sharedscripts),
+      :postrotate => configuration[:rails_logrotate][:postrotate] || "touch #{configuration[:deploy_to]}/current/tmp/restart.txt"
+    })
+    file "/etc/logrotate.d/#{configuration[:deploy_to].gsub('/','')}sharedlog.conf", :ensure => :absent
+  end
+
+  # This task ensures Rake is installed and that <tt>rake environment</tt>
+  # executes without error in your <tt>rails_root</tt>.
+  def rails_rake_environment
+    package 'rake', :provider => :gem, :ensure => :installed
+    file '/var/log/moonshine_rake.log',
+      :ensure   => :present,
+      :owner    => configuration[:user],
+      :group    => configuration[:group] || configuration[:user],
+      :mode     => '775',
+      :content  => ' '
+    exec 'rake tasks',
+      :command => 'rake environment >> /var/log/moonshine_rake.log 2>&1',
+      :user => configuration[:user],
+      :cwd => rails_root,
+      :environment => "RAILS_ENV=#{ENV['RAILS_ENV']}",
+      :require => [
+        exec('rails_gems'),
+        package('rake'),
+        file('/var/log/moonshine_rake.log')
+      ]
+  end
+
+  # Automatically install all gems needed specified in the array at
+  # <tt>configuration[:gems]</tt>. This loads gems from
+  # <tt>config/gems.yml</tt>, which can be generated from by running
+  # <tt>rake moonshine:gems</tt> locally.
+  def rails_gems
+    gemrc = {
+      :verbose => true,
+      :gem => "--no-ri --no-rdoc",
+      :update_sources => true,
+      :sources => [
+        'http://gems.rubyforge.org',
+        'http://gems.github.com',
+      ]
+    }
+    gemrc.merge!(configuration[:rubygems]) if configuration[:rubygems]
+    file '/etc/gemrc',
+      :ensure   => :present,
+      :mode     => '744',
+      :owner    => 'root',
+      :group    => 'root',
+      :content  => gemrc.to_yaml
+    #stub for dependencies
+    exec 'rails_gems', :command => 'true'
+    return unless configuration[:gems]
+    configuration[:gems].each do |gem|
+      gem.delete(:source) if gem[:source] && gem[:source] =~ /gems.github.com/
+      gem(gem[:name], {
+        :version => gem[:version],
+        :source => gem[:source]
+      })
+    end
+  end
+
+  # Essentially replicates the deploy:setup command from capistrano, but sets
+  # up permissions correctly.
+  def rails_directories
+    deploy_to_array = configuration[:deploy_to].split('/').split('/')
+    deploy_to_array.each_with_index do |dir, index|
+      next if index == 0 || index >= (deploy_to_array.size-1)
+      file '/'+deploy_to_array[1..index].join('/'), :ensure => :directory
+    end
+    dirs = [
+      "#{configuration[:deploy_to]}",
+      "#{configuration[:deploy_to]}/shared",
+      "#{configuration[:deploy_to]}/releases"
+    ]
+    if configuration[:shared_children].is_a?(Array)
+      shared_dirs = configuration[:shared_children].map { |d| "#{configuration[:deploy_to]}/shared/#{d}" }
+      dirs += shared_dirs
+    end
+    if configuration[:app_symlinks].is_a?(Array)
+      dirs += ["#{configuration[:deploy_to]}/shared/public"]
+      symlink_dirs = configuration[:app_symlinks].map { |d| "#{configuration[:deploy_to]}/shared/public/#{d}" }
+      dirs += symlink_dirs
+    end
+    dirs.each do |dir|
+      file dir,
+      :ensure => :directory,
+      :owner => configuration[:user],
+      :group => configuration[:group] || configuration[:user],
+      :mode => '775'
+    end
+  end
+
+private
+  # Creates package("#{name}") with <tt>:provider</tt> set to <tt>:gem</tt>.
+  # The given <tt>options[:version]</tt> requirement is tweaked to ensure
+  # gems aren't reinstalled on each run. <tt>options[:source]</tt> does what
+  # you'd expect, as well.
+  #
+  # === Gem Package Dependencies
+  #
+  # System dependencies are loaded if any exist for the gem or any of it's
+  # gem dependencies in <tt>apt_gems.yml</tt>. For example, calling
+  # <tt>gem('webrat')</tt> knows to install <tt>libxml2-dev</tt> and
+  # <tt>libxslt1-dev</tt> because those are defined as dependencies for
+  # <tt>nokogiri</tt>.
+  #
+  # To define system dependencies not include in moonshine:
+  #
+  #   class UrManifest < ShadowPuppet::Manifest
+  #     configure(:apt_gems => {
+  #       :fakegem => [
+  #         'package1',
+  #         'package2
+  #       ]
+  #     })
+  #   end
+  #
+  # If you were then to require the installation of <tt>fakegem</tt> <strong>
+  # or any gem that depends on <tt>fakegem</tt></strong>, <tt>package1</tt>
+  # and <tt>package2</tt> would be installed first via apt.
+  def gem(name, options = {})
+    hash = {
+      :provider => :gem,
+      :before   => exec('rails_gems'),
+      :require  => file('/etc/gemrc')
+    }
+    hash.merge!(:source => options[:source]) if options[:source]
+    #fixup the version required
+    exact_dep = Gem::Dependency.new(name, options[:version] || '>0')
+    matches = Gem.source_index.search(exact_dep)
+    installed_spec = matches.first
+    if installed_spec
+      #it's already loaded, let's just specify that we want it installed
+      hash.merge!(:ensure => :installed)
+    else
+      if options[:version]
+        #if it's not installed and version specified, we require that version
+        hash.merge!(:ensure => options[:version])
+      else
+        #otherwise we don't care
+        hash.merge!(:ensure => :installed)
+      end
+      hash = append_system_dependecies(exact_dep, hash)
+    end
+    hash.delete(:version)
+    package(name, hash)
+  end
+
+  def append_system_dependecies(exact_dep, hash) #:nodoc:
+    #fixup the requires key to be an array
+    if hash[:require] && !hash[:require].is_a?(Array)
+      hash[:require] = [hash[:require]]
+    end
+    hash[:require] = [] unless hash[:require]
+    # load this gems' dependencies. we don't create packages for em, we just
+    # check them against the system dependency map
+    specs = Gem::SpecFetcher.fetcher.fetch exact_dep
+    spec = specs.first.first
+    deps = spec.dependencies
+    deps << exact_dep
+    deps.each do |dep|
+      (configuration[:apt_gems][dep.name.to_sym] || []).each do |apt|
+        package apt, :ensure => :installed
+        hash[:require] << package(apt)
+      end
+    end
+    hash.delete(:require) if hash[:require] == []
+    hash
+  rescue
+    hash
+  end
+
+  # Creates exec("rake #name") that runs in <tt>rails root</tt> of the rails
+  # app, with RAILS_ENV properly set
+  def rake(name, options = {})
+    exec("rake #{name}", {
+      :command => "rake #{name} >> /var/log/moonshine_rake.log 2>&1",
+      :user => configuration[:user],
+      :cwd => rails_root,
+      :environment => "RAILS_ENV=#{ENV['RAILS_ENV']}",
+      :require => exec('rake tasks')
+    }.merge(options)
+  )
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Moonshine::Manifest::Rails::Sqlite3
+
+  # Install the sqlite3 gem and it's dependencies
+  def sqlite3
+    gem 'sqlite3-ruby', :before => exec('rails_gems')
+  end
+
+end

data/lib/moonshine/manifest/rails/templates/innodb.cnf.erb

@@ -0,0 +1,6 @@
+# set the log_file_size before mysqld is started to ensure logs are created
+# correctly the first time
+[mysqld]
+innodb_log_buffer_size            = <%= configuration[:mysql][:innodb_log_buffer_size] || '64M' %>
+innodb_log_file_size              = <%= configuration[:mysql][:innodb_log_file_size] || '80M' %>
+innodb_log_files_in_group         = <%= configuration[:mysql][:innodb_log_files_in_group] || '3' %>

data/lib/moonshine/manifest/rails/templates/logrotate.conf.erb

@@ -0,0 +1,15 @@
+<%= log_or_glob %> {
+  <% options[:options].each do |o| %>
+  <%= o %>
+  <% end %>
+  <% unless options[:postrotate].nil? %>
+  postrotate
+    <%= options[:postrotate] %>
+  endscript
+  <% end %>
+  <% unless options[:prerotate].nil? %>
+  prerotate
+    <%= options[:prerotate] %>
+  endscript
+  <% end %>
+}