plow 0.1.0

data/lib/plow/strategy/ubuntu_hardy/user_home_web_app.rb

@@ -0,0 +1,304 @@
+# encoding: UTF-8
+
+class Plow
+  class Strategy
+    class UbuntuHardy
+      
+      ##
+      # Plowing strategy, compatible with the Linux Ubuntu Hardy Heron distribution, for generating
+      # a web-site within a user home directory.
+      class UserHomeWebApp
+        attr_reader :context, :users_file_path, :vhost_file_name, :vhost_file_path, :vhost_template_file_path
+        attr_reader :user_home_path, :sites_home_path, :app_root_path, :app_public_path, :app_log_path
+        
+        ##
+        # @param [Plow::Generator] context A context reference to the generator controller. (i.e. Strategy pattern)
+        #
+        # @example
+        #   class Plow
+        #     class Generator
+        #       def initialize
+        #         @strategy = Plow::Strategy::UbuntuHardy::UserHomeWebApp.new(self)
+        #       end
+        #     end
+        #   end
+        def initialize(context)
+          @context         = context
+          @users_file_path = "/etc/passwd"
+          @vhost_file_name = "#{context.site_name}.conf"
+          @vhost_file_path = "/etc/apache2/sites-available/#{vhost_file_name}"
+          
+          @vhost_template_file_path = "#{File.dirname(__FILE__)}/templates/apache2-vhost.conf"
+        end
+        
+        ##
+        # Begins executing this strategy.  In addition to the following exceptions, this method may
+        #   also raise exceptions found in private methods of this class.
+        #
+        # @raise [Plow::AppRootAlreadyExistsError] Raised if the web-app root path directory
+        #   aleady exists
+        # @raise [Plow::ConfigFileAlreadyExistsError] Raised if a apache2 vhost configuration file
+        #   cannot be found
+        def execute
+          if user_exists?
+            say "existing #{context.user_name} user"
+          else
+            say "creating #{context.user_name} user"
+            create_user
+          end
+          
+          if user_home_exists?
+            say "existing #{user_home_path}"
+          else
+            say "creating #{user_home_path}"
+            create_user_home
+          end
+          
+          if sites_home_exists?
+            say "existing #{sites_home_path}"
+          else
+            say "creating #{sites_home_path}"
+            create_sites_home
+          end
+          
+          if app_root_exists?
+            raise(Plow::AppRootAlreadyExistsError, app_root_path)
+          else
+            say "creating #{app_root_path}"
+            create_app_root
+          end
+          
+          @app_public_path = "#{app_root_path}/public"
+          say "creating #{@app_public_path}"
+          create_app_public
+          
+          @app_log_path = "#{app_root_path}/log"
+          say "creating #{app_log_path}"
+          create_app_logs
+          
+          if vhost_config_exists?
+            raise(Plow::ConfigFileAlreadyExistsError, vhost_file_path)
+          else
+            say "creating #{vhost_file_path}"
+            create_vhost_config
+          end
+          
+          say "installing #{vhost_file_path}"
+          install_vhost_config
+        end
+        
+        ############################################################################################################
+        
+        private
+        
+        ##
+        # Proxy method to +Plow::Generator#say+
+        # @param [String] message A user output message
+        def say(message)
+          context.say(message)
+        end
+        
+        ##
+        # Proxy method to +Plow::Generator#shell+
+        # @param [String] commands Shell commands with multi-line support.
+        def shell(commands)
+          context.shell(commands)
+        end
+        
+        ##
+        # Reads the file at +users_file_path+ and yields each user iteratively.
+        #
+        #
+        # @yield [Hash] Each user account
+        # @example
+        #   users do |user|
+        #     user[:name]        #=> [String] The name
+        #     user[:password]    #=> [String] The bogus password
+        #     user[:id]          #=> [Number] The uid number
+        #     user[:group_ip]    #=> [Number] The gid number
+        #     user[:info]        #=> [String] General account info
+        #     user[:home_path]   #=> [String] The path to the home directory
+        #     user[:shell_path]  #=> [String] The path to the default shell
+        #   end
+        def users(&block)
+          File.readlines(users_file_path).each do |user_line|
+            user_line = user_line.chomp.split(':')
+            user = {
+              :name       => user_line[0],
+              :password   => user_line[1],
+              :id         => user_line[2].to_i,
+              :group_id   => user_line[3].to_i,
+              :info       => user_line[4],
+              :home_path  => user_line[5],
+              :shell_path => user_line[6]
+            }
+            yield user
+          end
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Determines if the context.user_name already exists or not
+        # 
+        # @return [Boolean] +true+ if found otherwise +false+
+        # @raise [Plow::ReservedSystemUserNameError] Raised if the +context.user_name+ is a reserved
+        #   system user name
+        def user_exists?
+          users do |user|
+            if user[:name] == context.user_name
+              unless user[:id] >= 1000 && user[:id] != 65534
+                raise(Plow::ReservedSystemUserNameError, context.user_name)
+              end
+              return true
+            end
+          end
+          
+          return false
+        end
+        
+        ##
+        # Creates a system user account for +context.user_name+
+        def create_user
+          shell "adduser #{context.user_name}"
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Determines if a home path for the +context.user_name+ already exists
+        #
+        # @return [Boolean] +true+ if the path already exists, otherwise +false+
+        # @raise [Plow::SystemUserNameNotFoundError] Raised if the +context.user_name+ is not found 
+        #   even after it has been created
+        def user_home_exists?
+          users do |user|
+            if user[:name] == context.user_name
+              @user_home_path = user[:home_path]
+              return Dir.exists?(user[:home_path])
+            end
+          end
+          
+          raise(Plow::SystemUserNameNotFoundError, context.user_name)
+        end
+        
+        ##
+        # Creates a +user_home_path+
+        def create_user_home
+          shell <<-RUN
+            mkdir #{user_home_path}
+            chown #{context.user_name}:#{context.user_name} #{user_home_path}
+          RUN
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Determines if the +sites_home_path+ already exists.  As a side-effect, also correctly
+        #   sets the +@sites_home_path+ variable.
+        # @return [Boolean] +true+ if the path already exists, otherwise +false+
+        def sites_home_exists?
+          @sites_home_path = "#{user_home_path}/sites"
+          Dir.exists?(sites_home_path)
+        end
+        
+        ##
+        # Creates the +site_home_path+
+        def create_sites_home
+          shell <<-RUN
+            mkdir #{sites_home_path}
+            chown #{context.user_name}:#{context.user_name} #{sites_home_path}
+          RUN
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Determines if the +app_root_path+ already exists.  As a side-effect, also correctly
+        #   sets the +@app_root_path+ variable.
+        # @return [Boolean] +true+ if the path exists, otherwise +false+
+        def app_root_exists?
+          @app_root_path = "#{sites_home_path}/#{context.site_name}"
+          Dir.exists?(app_root_path)
+        end
+        
+        ##
+        # Creates the +app_root_path+
+        def create_app_root
+          shell <<-RUN
+            mkdir #{app_root_path}
+            chown #{context.user_name}:#{context.user_name} #{app_root_path}
+          RUN
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Creates the app public structure at +app_public_path+
+        def create_app_public
+          shell <<-RUN
+            mkdir #{app_public_path}
+            touch #{app_public_path}/index.html
+            chown -R #{context.user_name}:#{context.user_name} #{app_public_path}
+          RUN
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Creates the app log structure at +app_log_path+
+        def create_app_logs
+          shell <<-RUN
+            mkdir #{app_log_path}
+            mkdir #{app_log_path}/apache2
+            chmod 750 #{app_log_path}/apache2
+            
+            touch #{app_log_path}/apache2/access.log
+            touch #{app_log_path}/apache2/error.log
+            
+            chmod 640 #{app_log_path}/apache2/*.log
+            chown -R #{context.user_name}:#{context.user_name} #{app_log_path}
+            chown root -R #{app_log_path}/apache2
+          RUN
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Determines if the apache2 vhost config file already exists
+        # @return [Boolean] +true+ if the file exists, otherwise +false+
+        def vhost_config_exists?
+          Dir.exists?(vhost_file_path)
+        end
+        
+        ##
+        # Creates an apache2 vhost config file from a template file to a +vhost_file_path+
+        def create_vhost_config
+          File.open(vhost_file_path, 'wt') do |file|
+            template_context = {
+              :site_name       => context.site_name,
+              :site_aliases    => context.site_aliases,
+              :app_public_path => app_public_path,
+              :app_log_path    => app_log_path
+            }
+            
+            config = context.evaluate_template(vhost_template_file_path, template_context)
+            file.write(config)
+          end
+        end
+        
+        ############################################################################################################
+        
+        ##
+        # Installs the apache2 vhost config file by enabling the site and restarting the web server
+        def install_vhost_config
+          shell <<-RUN
+            a2ensite #{vhost_file_name}
+            apache2ctl graceful
+          RUN
+        end
+      end
+      
+    end
+  end
+end

data/lib/plow.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+unless RUBY_VERSION >= '1.9.1'
+  abort <<-ERROR
+Incompatible ruby version error in #{__FILE__} near line #{__LINE__}
+This library requires at least ruby v1.9.1 but you're using ruby v#{RUBY_VERSION}
+Please see http://www.ruby-lang.org/
+  ERROR
+end
+
+require 'plow/core_ext/object'
+
+require 'plow/errors'
+require 'plow/application'
+
+class Plow
+  VERSION = "0.1.0"
+end

data/spec/fixtures/passwd.txt

@@ -0,0 +1,27 @@
+root:x:0:0:root:/root:/bin/bash
+daemon:x:1:1:daemon:/usr/sbin:/bin/sh
+bin:x:2:2:bin:/bin:/bin/sh
+sys:x:3:3:sys:/dev:/bin/sh
+sync:x:4:65534:sync:/bin:/bin/sync
+games:x:5:60:games:/usr/games:/bin/sh
+man:x:6:12:man:/var/cache/man:/bin/sh
+lp:x:7:7:lp:/var/spool/lpd:/bin/sh
+mail:x:8:8:mail:/var/mail:/bin/sh
+news:x:9:9:news:/var/spool/news:/bin/sh
+uucp:x:10:10:uucp:/var/spool/uucp:/bin/sh
+proxy:x:13:13:proxy:/bin:/bin/sh
+www-data:x:33:33:www-data:/var/www:/bin/sh
+backup:x:34:34:backup:/var/backups:/bin/sh
+list:x:38:38:Mailing List Manager:/var/list:/bin/sh
+irc:x:39:39:ircd:/var/run/ircd:/bin/sh
+gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/bin/sh
+nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
+libuuid:x:100:101::/var/lib/libuuid:/bin/sh
+dhcp:x:101:102::/nonexistent:/bin/false
+syslog:x:102:103::/home/syslog:/bin/false
+klog:x:103:104::/home/klog:/bin/false
+sshd:x:104:65534::/var/run/sshd:/usr/sbin/nologin
+Debian-exim:x:105:109::/var/spool/exim4:/bin/false
+sadmin:x:1000:1000:,,,:/home/sadmin:/bin/bash
+mysql:x:106:111:MySQL Server,,,:/var/lib/mysql:/bin/false
+steve:x:1001:1001:,,,:/home/steve:/bin/bash

data/spec/fixtures/vhost.conf

@@ -0,0 +1,3 @@
+<VirtualHost *:80>
+  ServerName <%= @site_name %>
+</VirtualHost>

data/spec/plow/application_spec.rb

@@ -0,0 +1,241 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Plow::Application do
+  
+  before(:each) do
+    @expected_version_stamp = "Plow v0.1.0. Copyright (c) 2009 Ryan Sobol. Licensed under the MIT license."
+  end
+  
+  ##################################################################################################
+  
+  describe ".version_stamp" do
+    it "should create a version stamp as a String" do
+      Plow::Application.send(:version_stamp).should == @expected_version_stamp
+    end
+  end
+  
+  ##################################################################################################
+  
+  describe ".launch when failing" do
+    before(:each) do
+      @expected_message = <<MESSAGE
+Usage: plow USER_NAME SITE_NAME [SITE_ALIAS ...]
+
+  Arguments:
+    USER_NAME       Name of a Linux system account user (e.g. steve)
+    SITE_NAME       Name of the web-site (e.g. www.apple.com)
+    SITE_ALIAS      (Optional) List of alias names of the web-site (e.g. apple.com)
+
+  Summary:
+    Plows the fertile soil of your filesystem into neatly organized plots of web-site templates
+
+  Description:
+    1. Sharpens it's blade by ensuring that both a Linux system user account and it's home path exist
+    2. Penetrates the soil by forming the web-site root path within the user home
+    3. Seeds the web-site with an index page and web server log files
+    4. Fertilizes the web-site by installing a virtual host configuration into the web server
+
+  Example:
+    plow steve www.apple.com apple.com
+MESSAGE
+      $stdout = StringIO.new
+      $stderr = StringIO.new
+    end
+    
+    after(:each) do
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+    
+    it "should output the version stamp" do
+      lambda { Plow::Application.launch }.should raise_error
+      $stdout.string.should == @expected_version_stamp + "\n"
+    end
+    
+    it "should abort with usage message with 0 arguments" do
+      lambda { Plow::Application.launch }.should raise_error(SystemExit, @expected_message)
+    end
+    
+    it "should abort with usage message with 1 argument" do
+      lambda { Plow::Application.launch('marco') }.should raise_error(SystemExit, @expected_message)
+    end
+  end
+
+  ##################################################################################################
+
+  describe ".launch when passing" do
+    before(:each) do
+      $stdout = StringIO.new
+    end
+    
+    after(:each) do
+      $stdout = STDOUT
+    end
+    
+    it "should output the version stamp" do
+      argv      = ['steve', 'www.apple.com']
+      generator = mock('generator')
+      
+      Plow::Generator.should_receive(:new)
+        .with(*argv)
+        .and_return(generator)
+      generator.should_receive(:run!)
+      
+      Plow::Application.launch(*argv)
+      
+      $stdout.string.should == @expected_version_stamp + "\n"
+    end
+    
+    it "should start the generator with 2 arguments" do
+      argv      = ['steve', 'www.apple.com']
+      generator = mock('generator')
+      
+      Plow::Generator.should_receive(:new)
+        .with(*argv)
+        .and_return(generator)
+      generator.should_receive(:run!)
+      
+      Plow::Application.launch(*argv).should == 0
+    end
+    
+    it "should start the generator with 3 arguments" do
+      argv      = ['marco-polo', 'www.marcopolo.com', 'marcopolo.com']
+      generator = mock('generator')
+      
+      Plow::Generator.should_receive(:new)
+        .with(*argv)
+        .and_return(generator)
+      generator.should_receive(:run!)
+      
+      Plow::Application.launch(*argv).should == 0
+    end
+    
+    it "should start the generator with 4 arguments" do
+      argv      = ['marco-polo', 'www.marcopolo.com', 'marcopolo.com', 'asia.marcopolo.com']
+      generator = mock('generator')
+      
+      Plow::Generator.should_receive(:new)
+        .with(*argv)
+        .and_return(generator)
+      generator.should_receive(:run!)
+      
+      Plow::Application.launch(*argv).should == 0
+    end
+  end
+
+  ##################################################################################################
+  
+  describe "when handling errors from Plow::Generator.new" do
+    before(:each) do
+      @bad_argv = ['bad user name', 'bad site name', 'bad site alias']
+      $stdout   = StringIO.new
+      $stderr   = StringIO.new
+    end
+    
+    after(:each) do
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+    
+    it "should render error message to the user for raised Plow::InvalidSystemUserNameError" do
+      expected_error = Plow::InvalidSystemUserNameError.new(@bad_argv[0])
+      Plow::Generator.should_receive(:new).and_raise(expected_error)
+
+      expected_message = "ERROR: #{@bad_argv[0]} is an invalid system user name"
+      lambda { Plow::Application.launch(*@bad_argv) }.should raise_error(SystemExit, expected_message)
+    end
+    
+    it "should render error message to the user for raised Plow::InvalidWebSiteNameError" do
+      expected_error = Plow::InvalidWebSiteNameError.new(@bad_argv[1])
+      Plow::Generator.should_receive(:new).and_raise(expected_error)
+      
+      expected_message = "ERROR: #{@bad_argv[1]} is an invalid web-site name"
+      lambda { Plow::Application.launch(*@bad_argv) }.should raise_error(SystemExit, expected_message)
+    end
+    
+    it "should render error message to the user for raised Plow::InvalidWebSiteAliasError" do
+      expected_error = Plow::InvalidWebSiteAliasError.new(@bad_argv[2])
+      Plow::Generator.should_receive(:new).and_raise(expected_error)
+      
+      expected_message = "ERROR: #{@bad_argv[2]} is an invalid web-site alias"
+      lambda { Plow::Application.launch(*@bad_argv) }.should raise_error(SystemExit, expected_message)
+    end
+  end
+  
+  describe "when handing errors from Plow::Generator.run!" do
+    before(:each) do
+      $stdout    = StringIO.new
+      $stderr    = StringIO.new
+      @argv      = ['steve', 'www.apple.com', 'apple.com']
+      @generator = mock('generator')
+    end
+    
+    after(:each) do
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+    
+    it "should render error message to the user for raised Plow::NonRootProcessOwnerError" do
+      expected_error = Plow::NonRootProcessOwnerError
+      
+      Plow::Generator.should_receive(:new)
+        .with(*@argv)
+        .and_return(@generator)
+      @generator.should_receive(:run!).and_raise(expected_error)
+      
+      expected_message = "ERROR: This process must be owned or executed by root"
+      lambda { Plow::Application.launch(*@argv) }.should raise_error(SystemExit, expected_message)
+    end
+    
+    it "should render error message to the user for raised Plow::ReservedSystemUserNameError" do
+      expected_error = Plow::ReservedSystemUserNameError.new(@argv[0])
+      
+      Plow::Generator.should_receive(:new)
+        .with(*@argv)
+        .and_return(@generator)
+      @generator.should_receive(:run!).and_raise(expected_error)
+      
+      expected_message = "ERROR: #{@argv[0]} is a reserved system user name"
+      lambda { Plow::Application.launch(*@argv) }.should raise_error(SystemExit, expected_message)
+    end
+    
+    it "should render error message to the user for raised Plow::SystemUserNameNotFoundError" do
+      expected_error = Plow::SystemUserNameNotFoundError.new(@argv[0])
+      
+      Plow::Generator.should_receive(:new)
+        .with(*@argv)
+        .and_return(@generator)
+      @generator.should_receive(:run!).and_raise(expected_error)
+      
+      expected_message = "ERROR: System user name #{@argv[0]} cannot be found when it should exist"
+      lambda { Plow::Application.launch(*@argv) }.should raise_error(SystemExit, expected_message)
+    end
+    
+    it "should render error message to the user for raised Plow::AppRootAlreadyExistsError" do
+      app_home_path = "/home/#{@argv[0]}/sites/#{@argv[1]}"
+      expected_error = Plow::AppRootAlreadyExistsError.new(app_home_path)
+      
+      Plow::Generator.should_receive(:new)
+        .with(*@argv)
+        .and_return(@generator)
+      @generator.should_receive(:run!).and_raise(expected_error)
+      
+      expected_message = "ERROR: Application root path #{app_home_path} already exists"
+      lambda { Plow::Application.launch(*@argv) }.should raise_error(SystemExit, expected_message)
+    end
+    
+    it "should render error message to the user for raised Plow::AppRootAlreadyExistsError" do
+      config_file_path = '/etc/apache2/sites_available/vhost.conf'
+      expected_error = Plow::ConfigFileAlreadyExistsError.new(config_file_path)
+      
+      Plow::Generator.should_receive(:new)
+        .with(*@argv)
+        .and_return(@generator)
+      @generator.should_receive(:run!).and_raise(expected_error)
+      
+      expected_message = "ERROR: Configuration file #{config_file_path} already exists"
+      lambda { Plow::Application.launch(*@argv) }.should raise_error(SystemExit, expected_message)
+    end
+  end
+end

data/spec/plow/binding_struct_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Plow::BindingStruct do
+  
+  before(:each) do
+    @arguments = { first_name: 'Carl', last_name: 'Sagan' }
+    @struct    = Plow::BindingStruct.new(@arguments)
+  end
+  
+  ##################################################################################################
+  
+  describe ".new" do
+    it "should create instance variables for all keys of a parameter Hash" do
+      @struct.instance_variables.sort.should == @arguments.keys.sort.map { |key| "@#{key}".to_sym }
+    end
+    
+    it "should initialze all instance variables with the values of a parameter Hash" do
+      @struct.instance_variables.each do |ivar|
+        @struct.instance_variable_get(ivar).should == @arguments[ivar.to_s.gsub("@", '').to_sym]
+      end
+    end
+  end
+  
+  ##################################################################################################
+  
+  describe "\#get_binding" do
+    it "should return a Binding object of the instance" do
+      ivars = @arguments.keys.sort.map { |key| "@#{key}".to_sym }
+      ivars.each do |ivar|
+        actual = eval(ivar.to_s, @struct.get_binding)
+        actual.should == @arguments[ivar.to_s.gsub("@", '').to_sym]
+        actual.should == @struct.instance_variable_get(ivar)
+      end
+    end
+  end
+end

data/spec/plow/errors_spec.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Custom Application Errors" do
+  it "Plow::NonRootProcessOwnerError should be a kind of StandardError" do
+    Plow::NonRootProcessOwnerError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::InvalidSystemUserNameError should be a kind of StandardError" do
+    Plow::InvalidSystemUserNameError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::InvalidWebSiteNameError should be a kind of StandardError" do
+    Plow::InvalidWebSiteNameError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::InvalidWebSiteAliasError should be a kind of StandardError" do
+    Plow::InvalidWebSiteAliasError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::ReservedSystemUserNameError should be a kind of StandardError" do
+    Plow::ReservedSystemUserNameError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::SystemUserNameNotFoundError should be a kind of StandardError" do
+    Plow::SystemUserNameNotFoundError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::AppRootAlreadyExistsError should be a kind of StandardError" do
+    Plow::AppRootAlreadyExistsError.new.should be_a_kind_of(StandardError)
+  end
+  
+  it "Plow::ConfigFileAlreadyExistsError should be a kind of StandardError" do
+    Plow::ConfigFileAlreadyExistsError.new.should be_a_kind_of(StandardError)
+  end
+end