radiant-vhost-extension 2.1.0

data/lib/bootstrap_with_site_id.rb

@@ -0,0 +1,50 @@
+module BootstrapWithSiteId
+  def load_database_template_with_site_id(filename)
+    template = nil
+    if filename
+      name = find_template_in_path(filename)
+      unless name
+        announce "Invalid template name: #{filename}"
+        filename = nil
+      else
+        template = load_template_file(name)
+      end
+    end
+    unless filename
+      templates = find_and_load_templates("#{RAILS_ROOT}/vendor/extensions/vhost/db/templates/*.yml")
+      templates.concat find_and_load_templates("#{RADIANT_ROOT}/config/extensions/vhost/db/templates/*.yml")
+      templates.concat find_and_load_templates("#{RAILS_ROOT}/db/templates/*.yml") if RADIANT_ROOT != RAILS_ROOT
+      choose do |menu|
+        menu.header = "\nSelect a database template"
+        menu.prompt = "[1-#{templates.size}]: "
+        menu.select_by = :index
+        templates.each { |t| menu.choice(t['name']) { template = t } }
+      end
+    end
+    # If there are sites defined create them first as there are many to many
+    # relationships from users to sites that need to be created and will fail
+    # if the site isn't created first.
+    if !template['records']['Sites'].nil?
+      site_template = {}
+      site_template['records'] = {}
+      site_template['records']['Sites'] = template['records']['Sites']
+      create_records(site_template)
+      site_template['records'].delete('Sites')
+    end
+    create_records(template)
+  end
+
+  def find_template_in_path_with_site_id(filename)
+        [
+          filename,
+          "#{RAILS_ROOT}/vendor/extensions/vhost/db/templates/#{filename}",
+          "#{RADIANT_ROOT}/config/extensions/vhost/db/templates/#{filename}",
+          "#{RADIANT_ROOT}/#{filename}",
+          "#{RADIANT_ROOT}/db/templates/#{filename}",
+          "#{RAILS_ROOT}/#{filename}",
+          "#{RAILS_ROOT}/db/templates/#{filename}",
+          "#{Dir.pwd}/#{filename}",
+          "#{Dir.pwd}/db/templates/#{filename}",
+        ].find { |name| File.file?(name) }
+  end
+end

data/lib/site_scope.rb

@@ -0,0 +1,65 @@
+module SiteScope
+  
+  def self.included(base)
+    base.send :helper_method, :current_site
+  end
+  
+  def current_site
+    return @current_site unless @current_site.nil?
+    # For testing we won't have a request.host so we're going to use a class 
+    # variable (VhostExtension.HOST) in those cases.
+    host ||= VhostExtension.HOST || request.host
+    # Remove the 'www.' from the site so we don't have to always include a www. 
+    # in addition to the regular domain name.
+    host.gsub!(/^www\./, '')
+    @current_site ||=  Site.find_by_hostname(host) || Site.find_by_hostname('*') || Site.find(:first, :conditions => ["hostname LIKE ?", "%#{host}%"])
+    raise "No site found to match #{host}." unless @current_site
+    Thread.current[:current_site_id] = @current_site.id
+    @current_site
+  end
+
+  protected
+  # This is the key method that forks in the additional conditions that will
+  # be used to fetch the site-scoped models. It also defines how the site-scoped
+  # models will be saved with a site_id.
+  def site_scope
+    @site_scope ||= {
+      :find => { :conditions => ["site_id = ?", current_site.id]},
+      :create => { :site_id => current_site.id }
+    }
+  end
+
+  def users_site_scope
+    @users_site_scope = {}
+    # Only do the user site scoping if it's a site_admin. We don't want the admin to be restricted.
+    if current_user && current_user.site_admin?
+      @users_site_scope = {
+        :find => { :joins => "JOIN sites_users AS scoped_sites_users ON scoped_sites_users.user_id = id", :conditions => ["scoped_sites_users.site_id = ?", current_site.id]},
+        # Make sure admin is always false - wouldn't want someone trying to set it to true through some html magic
+        :create => { :site_ids => [current_site.id], :site_admin => false }
+      }
+    end
+    return @users_site_scope
+  end
+
+  # Should this really be here? Shouldn't we be calling this regardless of if we go
+  # through the ApplicationControllers :before_filter?
+  def set_site_scope_in_models
+    set_model_current_site = lambda {|model|
+      model.constantize.send :cattr_accessor, :current_site
+      model.constantize.current_site = self.current_site
+    }
+    VhostExtension.MODELS.each do |model|
+      model_config = VhostExtension.read_config[:model_uniqueness_validations][model]
+      if model_config['sti_classes']
+        model_config['sti_classes'].each do |klass|
+          set_model_current_site.call(klass)
+        end
+      end
+      set_model_current_site.call(model)
+    end
+    Site.send :cattr_accessor, :current_site
+    Site.current_site = self.current_site
+  end
+  
+end

data/lib/tasks/add_site_columns.rb

@@ -0,0 +1,44 @@
+class AddSiteColumns < ActiveRecord::Migration
+  
+  config = VhostExtension.read_config
+
+  MODELS = config[:models]
+  
+  # Declare the models so we can use them.
+  MODELS.each do |model|
+    eval "class #{model} < ActiveRecord::Base; end"
+  end
+  
+  def self.up
+    MODELS.each do |model|
+      begin
+        add_column model.tableize, :site_id, :integer
+        model.constantize.update_all "site_id = 1"
+        # Special case for Snippets to add a proper index
+        if model == 'Snippet'
+          add_index :snippets, [:name, :site_id], :unique => true
+        end
+      rescue
+        # Ignore errors here, they're going to happen when the user
+        # does a 'remigrate'
+      end
+    end
+    add_index :snippets, [:name, :site_id] rescue nil
+  end
+
+  def self.down
+    MODELS.each do |model|
+      begin
+        # Special case for Snippets to remove index
+        if model == 'Snippet'
+          remove_index :snippets, [:name, :site_id]
+        end
+        remove_column model.tableize, :site_id
+      rescue
+        # Ignore errors here, they're going to happen when the user
+        # does a 'remigrate'
+      end
+    end
+    remove_index :snippets, :column => [:name, :site_id] rescue nil
+  end
+end

data/lib/tasks/vhost_extension_tasks.rake

@@ -0,0 +1,115 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :vhost do
+      
+      desc "Prepares your database for Vhost"
+      task :install => [:environment, :migrate, :apply_site_scoping]
+      
+      desc "Runs the migration of the Vhost extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          VhostExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          VhostExtension.migrator.migrate
+        end
+      end
+
+      
+      # @todo the following method should accept a direction. We should also
+      # rename it something like 'apply_site_scoping' and 'reset_site_scoping' 
+      # or something...
+      desc "Initializes site scoping. "
+      task :apply_site_scoping => :environment do
+        require "#{File.dirname(__FILE__)}/add_site_columns"
+        AddSiteColumns.up
+      end
+      
+      desc "Reinitializes site scoping in the event a new model needs to be site scoped."
+      task :destroy_site_scoping => :environment do
+        require 'highline/import'
+        if agree("This task will destroy any model to site relationships in the database. Are you sure \nyou want to continue? [yn] ")
+          AddSiteColumns.up
+          AddSiteColumns.down
+        end
+      end
+    
+    end
+  end
+end
+
+Rake::TaskManager.class_eval do
+  def remove_task(task_name)
+    @tasks.delete(task_name.to_s)
+  end
+end
+ 
+def remove_task(task_name)
+  Rake.application.remove_task(task_name)
+end
+
+# We need the bootstrap task to use site_ids
+remove_task "db:bootstrap"
+remove_task "db:remigrate"
+namespace :db do  
+  desc "Bootstrap your database for Radiant."
+  task :bootstrap => :remigrate do
+    require 'radiant/setup'
+    require File.join(File.dirname(__FILE__), '../bootstrap_with_site_id')
+    Radiant::Setup.send :include, BootstrapWithSiteId
+    Radiant::Setup.send :alias_method_chain, :load_database_template, :site_id
+    Radiant::Setup.send :alias_method_chain, :find_template_in_path, :site_id
+    
+    Radiant::Setup.bootstrap(
+      :admin_name => ENV['ADMIN_NAME'],
+      :admin_username => ENV['ADMIN_USERNAME'],
+      :admin_password => ENV['ADMIN_PASSWORD'],
+      :database_template => ENV['DATABASE_TEMPLATE']
+    )
+
+    Rake::Task["radiant:extensions:vhost:apply_site_scoping"].invoke
+
+  end
+  
+  desc "Migrate schema to version 0 and back up again. WARNING: Destroys all data in tables!!"
+  task :remigrate => :environment do
+    require 'highline/import'
+    require 'radiant/extension_migrator'
+    if ENV['OVERWRITE'].to_s.downcase == 'true' or
+      agree("This task will destroy any data in the database. Are you sure you want to \ncontinue? [yn] ")
+      
+      # Migrate extensions downward
+      Radiant::ExtensionLoader.instance.extensions.each do |ext|
+        # The first time you bootstrap you'll always encounter exceptions
+        # so be sure to ignore them here.
+        begin
+          ext.migrator.migrate(0)
+        rescue
+          puts "An error occurred while migrating the #{ext} extension downward: #{$!}"
+        end
+      end
+      
+      # Migrate downward
+      ActiveRecord::Migrator.migrate("#{RADIANT_ROOT}/db/migrate/", 0)
+
+      # Migrate upward 
+      Rake::Task["db:migrate"].invoke
+      
+      # Migrate extensions upward
+      Radiant::ExtensionLoader.instance.extensions.each do |ext|
+        # The first time you bootstrap you'll always encounter exceptions
+        # so be sure to ignore them here.
+        ext.migrator.migrate
+      end
+
+      # Remigrate the extensions to catch any new site scoped extensions added
+      Rake::Task["radiant:extensions:vhost:apply_site_scoping"].invoke
+      
+      # Dump the schema
+      Rake::Task["db:schema:dump"].invoke
+    else
+      say "Task cancelled."
+      exit
+    end
+  end
+end

data/lib/vhost/admin_users_controller_extensions.rb

@@ -0,0 +1,22 @@
+module Vhost::AdminUsersControllerExtensions
+  def self.included(receiver)
+    receiver.send  :only_allow_access_to, :index, :show, :new, :create, :edit, :update, :remove, :destroy,
+      :when => [:admin, :site_admin], 
+      :denied_url => { :controller => 'pages', :action => 'index' },
+      :denied_message => 'You must have administrative privileges to perform this action.'
+
+    receiver.class_eval {
+      def load_model
+        self.model = if params[:id]
+          model_class.find(params[:id], :readonly => false)
+        else
+          model_class.new
+        end
+      end
+      
+      def load_models
+        self.models = current_site.users.paginate(pagination_parameters)
+      end
+    }
+  end
+end

data/lib/vhost/admin_users_helper_extensions.rb

@@ -0,0 +1,17 @@
+module Vhost::AdminUsersHelperExtensions
+  def self.included(receiver)
+    receiver.send :alias_method_chain, :roles, :site_admin
+    receiver.send :define_method, :sites do |user|
+      sites = user.sites.collect{|site| site.hostname}
+      sites.join("<br/>")
+    end
+  end
+  
+  def roles_with_site_admin(user)
+    roles = []
+    roles << 'Admin' if user.admin?
+    roles << 'Site Admin' if user.site_admin?
+    roles << 'Designer' if user.designer?
+    roles.join(', ')
+  end
+end

data/lib/vhost/application_controller_extensions.rb

@@ -0,0 +1,36 @@
+module Vhost::ApplicationControllerExtensions
+  def self.included(base)
+    base.class_eval {
+      prepend_before_filter :redirect_to_primary_site
+
+      helper_method :primary_site_url
+      
+      def redirect_to_primary_site
+        if VhostExtension.REDIRECT_TO_PRIMARY_SITE
+          site = current_site
+          return if site.nil? || site.hostname.include?("*")
+          primary_host = site.hostname.split(',')[0].strip
+          redirect_to(primary_site_url + request.request_uri) if request.host != primary_host
+        end
+      end
+
+      def primary_site_url
+          site = current_site
+          return nil if site.nil? || site.hostname.include?("*")
+
+          # Rebuild the current URL. Check if it matches the URL of the
+          # primary site and redirect if it does not.
+          prefix = request.ssl? ? "https://" : "http://"
+          host = request.host
+          port = request.port_string
+
+          # Primary site is the first site
+          primary_host = site.hostname.split(',')[0].strip
+          
+          # Return the concatenation
+          prefix+primary_host+port
+      end
+    }
+  end
+end
+

data/lib/vhost/application_helper_extensions.rb

@@ -0,0 +1,15 @@
+module Vhost::ApplicationHelperExtensions
+  def self.included(receiver)
+    # This swaps out the 'subtitle' method for the 'site_hostname'
+    # method to show the hostname in the subtitle in admin...
+    receiver.send :alias_method_chain, :subtitle, :site_hostname
+    
+    receiver.send :define_method, :site_admin? do
+      current_user and current_user.site_admin?
+    end
+  end
+  
+  def subtitle_with_site_hostname
+    current_site.hostname
+  end
+end

data/lib/vhost/controller_access_extensions.rb

@@ -0,0 +1,16 @@
+module Vhost::ControllerAccessExtensions
+  def self.included(receiver)
+    receiver.send :before_filter, :ensure_user_has_site_access
+  end
+  
+  def ensure_user_has_site_access
+    unless current_site.allow_access_for(current_user)
+      cookies[:session_token] = { :expires => 1.day.ago }
+      self.current_user.forget_me if self.current_user
+      self.current_user = nil
+      flash[:error] = 'Access denied.'
+      redirect_to login_url
+    end
+  end
+end
+

data/lib/vhost/pages_controller_extensions.rb

@@ -0,0 +1,11 @@
+module Vhost::PagesControllerExtensions
+  def self.included(receiver)
+    receiver.send :alias_method_chain, :clear_model_cache, :site_specificity
+  end
+  
+  def clear_model_cache_with_site_specificity
+    url_to_expire = "#{request.host}#{@page.url}"
+    Radiant::Cache.clear(url_to_expire) if defined?(Radiant::Cache)
+  end
+end
+

data/lib/vhost/radiant_cache_extensions.rb

@@ -0,0 +1,53 @@
+# Alter Radiant's site controller to add the domain to the cache files.
+# Also store requests for later use.
+# See radiant/app/controllers/site_controller.rb
+module Vhost::RadiantCacheExtensions
+  module RadiantCache
+    def self.included(base)
+      base.class_eval {
+        # This sets up the cache - the entitystore and metastore 'cache/entity' and 'cache/meta' sets up the folder
+        # structure for storing the cache items.
+        def self.new(app, options={})
+          self.use_x_sendfile = options.delete(:use_x_sendfile) if options[:use_x_sendfile]
+          self.use_x_accel_redirect = options.delete(:use_x_accel_redirect) if options[:use_x_accel_redirect]
+          Rack::Cache.new(app, {
+              :entitystore => "radiant:tmp/cache/entity", 
+              :metastore => "radiant:tmp/cache/meta",
+              :verbose => false}.merge(options))
+        end
+        def self.clear(host_and_url = nil)
+          meta_stores.each {|ms| ms.clear(host_and_url) }
+          entity_stores.each {|es| es.clear }
+        end
+      }
+    end
+  end
+
+  module MetaStore
+    def self.included(base)
+      base.class_eval {
+        def initialize(root="#{Rails.root}/tmp/cache/meta")
+          super
+          Radiant::Cache.meta_stores << self
+        end
+  
+        def clear(host_and_url = nil)
+          if host_and_url.nil?
+            Dir[File.join(self.root, "*")].each {|file| FileUtils.rm_rf(file) }
+          else
+            FileUtils.rm_rf(key_path("#{host_and_url}"))
+          end
+        end
+  
+        # cache_key should, by default, include the host as well the query string
+        # def cache_key(request)
+        #   "#{request.host}#{request.path_info}"
+        # end
+      }
+    end    
+  end
+
+  # FIXME - Add support for EntityStore - MetaStore is the most important caching
+  # mechanism to be able to clear by site but EntityStore would be great too.
+
+end

data/lib/vhost/site_scoped_model_extensions.rb

@@ -0,0 +1,46 @@
+require 'yaml'
+module Vhost::SiteScopedModelExtensions
+  module InstanceMethods
+    def self.included(base)
+      base.class_eval {
+        Rails.logger.debug("Applying SiteScope to '"+self.name+"'")
+      
+        self.clear_callbacks_by_calling_method_name(:validate, :validates_uniqueness_of)
+        validates_presence_of :site_id
+        belongs_to :site
+
+        # Parse the model_uniqueness_validations config and set any necessary validations
+        # If the current class name matches an entry in the config then process it
+        config = VhostExtension.MODEL_UNIQUENESS_VALIDATIONS[self.name]
+        unless config.nil?
+          config.each_pair do |attr, params|
+            unless attr == 'sti_classes'
+              validates_uniqueness_of attr.to_sym, params.symbolize_keys
+            end
+          end
+        end
+      }
+    end
+  end
+  module ClassMethods
+    def clear_callbacks_by_calling_method_name(kind, calling_method_name)
+      calling_method_name = calling_method_name.to_s
+      # Callbacks are stored by kind as instance variables named @<kind>_callbacks. 
+      # Fetch them so we can kick out the matching items.
+      callback_chain = eval("@#{kind.to_s}_callbacks")
+      unless callback_chain.nil?
+        callback_chain.reject! do |callback|
+          method = callback.method
+          if method.is_a?(Proc)
+            # Returns the symbol for the method the proc was declared in
+            current_calling_method_name = eval("caller[0] =~ /`([^']*)'/ and $1", method.binding).to_s rescue nil
+            current_calling_method_name == calling_method_name
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vhost_default_config.yml

@@ -0,0 +1,22 @@
+redirect_to_primary_site: false
+models:
+ Layout:
+   name: 
+     message:
+       'name already in use'
+     scope:
+       site_id
+ Page:
+   slug:
+     scope: 
+       - parent_id
+       - site_id
+     message:
+       'slug already in use for child of parent'
+ Snippet:
+   name:
+     message:
+       'name already in use'
+     scope:
+       site_id
+