pawnee 0.0.5

data/lib/pawnee/pawnee/actions/user.rb

@@ -0,0 +1,116 @@
+require 'pawnee/actions/base_model'
+
+module Pawnee
+  module Actions
+    def create_user(attributes)
+      User.new(self, attributes).save
+    end
+    
+    def delete_user(login)
+      User.new(self, {:login => login}).destroy
+    end
+    
+    
+    
+    # The user class handles creating, updating, and deleting users.  Users are tied to the
+    # login attribute and all other attributes will update based on that login.
+    #
+    # === Passwords
+    # Instead of putting passwords in code, you should either:
+    # 
+    # 1) not use a password (which is fine for system users)
+    # or
+    # 2) Set the password value to an encryped password.  You can generated an encryped password
+    # with the following ruby command:
+    # 
+    #   ruby -e "puts 'password'.crypt('passphrase')"
+    #
+    #
+    class User < BaseModel
+      define_attribute_methods [:login, :uid, :gid, :groups, :comment, :shell, :password]
+      change_attr_accessor [:login, :uid, :gid, :groups, :comment, :shell, :password]
+
+      attr_accessor :base
+      
+      def initialize(base, attributes)
+        @base = base
+        
+        if attributes[:login]
+          self.login = attributes[:login]
+          # Read the current attributes from the system
+          read_from_system()
+        end
+        
+        # Set the attributes, track what changed
+        update_attributes(attributes)
+      end
+      
+      def exec(*args)
+        return base.exec(*args)
+      end
+      
+      def run(*args)
+        return base.run(*args)
+      end
+      
+      # Pull in the current (starting) state of the attributes 
+      # for the User model
+      def read_from_system
+        @uid, stderr, exit_code, _ = exec("id -u #{login}", true)
+        @uid = @uid.strip
+        if exit_code == 0
+          # The login exists, load in more data
+          @gid = exec("id -g #{login}").strip
+          @groups = exec("groups #{login}").gsub(/^[^:]+[:]/, '').strip.split(/ /)
+          self.new_record = false
+
+          # Reject any ones we just changed, so its as if we did a find with these
+          @changed_attributes = @changed_attributes.reject {|k,v| [:uid, :gid, :groups, :login].include?(k.to_sym) }
+        else
+          # No user
+          @uid = nil
+          self.new_record = true
+        end
+      end
+
+      # Write any changes out
+      def save
+        if changed?
+          raise "A login must be specified" unless login
+          
+          if new_record?
+            # Just create a new user
+            command = ["useradd"]
+            base.say_status :create_user, login
+          else
+            # Modify an existing user
+            command = ["usermod"]
+            base.say_status :update_user, login
+          end
+          
+          # Set options
+          command << "-u #{uid}" if uid && uid_changed?
+          command << "-g #{gid}" if gid && gid_changed?
+          command << "-G #{groups.join(',')}" if groups && groups_changed?
+          command << "-c #{comment.inspect}" if comment && comment_changed?
+          command << "-s #{shell.inspect}" if shell && shell_changed?
+          command << "-p #{password.inspect}" if password && password_changed?
+          command << login
+          
+          base.as_root do
+            base.exec(command.join(' '))
+          end
+        else
+          base.say_status :user_exists, login, :blue
+        end
+      end
+      
+      def destroy
+        self.new_record = true
+        base.as_root do
+          base.exec("userdel #{login}")
+        end
+      end
+    end
+  end
+end

data/lib/pawnee/pawnee/actions.rb

@@ -0,0 +1,29 @@
+require 'pawnee/actions/package'
+require 'pawnee/actions/compile'
+require 'pawnee/actions/user'
+
+module Pawnee
+  # The pawnee gem provides the Pawnee::Base class which includes Thor::Actions,
+  # ThorSsh::Actions.  Pawnee::Base also adds in its own actions from the pawnee
+  # gem
+  module Actions
+    # This is copied in from thor/actions.rb#initialize, 
+    # we can't extend from a module, so we just move this setup
+    # to a method
+    def pawnee_setup_actions(args=[], options={}, config={})
+      self.behavior = case config[:behavior].to_s
+        when "force", "skip"
+          _cleanup_options_and_set(options, config[:behavior])
+          :invoke
+        when "revoke"
+          :revoke
+        else
+          :invoke
+      end
+      
+      yield
+      self.destination_root = config[:destination_root]
+    end
+  end
+end
+    

data/lib/pawnee/pawnee/base.rb

@@ -0,0 +1,265 @@
+require 'net/ssh'
+require 'thor'
+require 'thor-ssh'
+require "pawnee/setup"
+require "pawnee/version"
+require 'pawnee/actions'
+require 'pawnee/parser/options'
+require 'active_support/core_ext/hash/deep_merge'
+require 'pawnee/roles'
+require 'pawnee/invocation'
+
+module Pawnee
+  # The pawnee gem provides the Pawnee::Base class, which includes actions
+  # from the thor gem, thor-ssh gem, and the pawnee gem its self.  Any class
+  # that inherits from Pawnee::Base will automatically be registered as a
+  # recipe.
+  class Base < Thor
+    include Thor::Actions
+    include ThorSsh::Actions
+    include Pawnee::Actions
+    include Pawnee::Invocation
+    include Roles
+    
+    attr_accessor :server
+    
+    # Calls the thor initializers, then if :server is passed in as 
+    # an option, it will set it up
+    #
+    # ==== Parameters
+    # args<Array[Object]>:: An array of objects. The objects are applied to their
+    #                       respective accessors declared with <tt>argument</tt>.
+    #
+    # options<Hash>:: An options hash that will be available as self.options.
+    #                 The hash given is converted to a hash with indifferent
+    #                 access, magic predicates (options.skip?) and then frozen.
+    #
+    # config<Hash>:: Configuration for this Thor class.
+    #    def initialize(*args)
+    #
+    # ==== Options
+    #  :server  -  This can be:
+    #                1) a connected ssh connection (created by Net::SSH.start)
+    #                2) an Array of options to pass to Net::SSH.start
+    #                3) a domain name for the first argument to Net::SSH.start
+    def initialize(args=[], options={}, config={})
+      pawnee_setup_invocations(args, options, config)
+
+      pawnee_setup_actions(args, options, config) do
+        
+        # We need to change Thor::Options to use Pawnee::Options on 
+        # invoke so we can include the defaults from the config file,
+        # so here we copy in the initialize from thor/base.rb#initialize
+        parse_options = self.class.class_options
+      
+        # The start method splits inbound arguments at the first argument
+        # that looks like an option (starts with - or --). It then calls
+        # new, passing in the two halves of the arguments Array as the
+        # first two parameters.
+      
+        if options.is_a?(Array)
+          task_options  = config.delete(:task_options) # hook for start
+          parse_options = parse_options.merge(task_options) if task_options
+          array_options, hash_options = options, {}
+        else
+          # Handle the case where the class was explicitly instantiated
+          # with pre-parsed options.
+          array_options, hash_options = [], options
+        end
+      
+        # Let Thor::Options parse the options first, so it can remove
+        # declared options from the array. This will leave us with
+        # a list of arguments that weren't declared.
+        # --- We change Thor::Options to Pawnee::Options to pull in
+        # the config default's
+        opts = Pawnee::Options.new(parse_options, hash_options)
+        self.options = opts.parse(array_options)
+      
+        # If unknown options are disallowed, make sure that none of the
+        # remaining arguments looks like an option.
+        opts.check_unknown! if self.class.check_unknown_options?(config)
+      
+        # Add the remaining arguments from the options parser to the
+        # arguments passed in to initialize. Then remove any positional
+        # arguments declared using #argument (this is primarily used
+        # by Thor::Group). Tis will leave us with the remaining
+        # positional arguments.
+        thor_args = Thor::Arguments.new(self.class.arguments)
+        thor_args.parse(args + opts.remaining).each { |k,v| send("#{k}=", v) }
+        args = thor_args.remaining
+      
+        @args = args
+        #-- end copy from thor/base.rb#initialize
+      end
+    end
+    
+    
+    
+    desc "setup", 'setup on the destination server'
+    # All recipies should subclass Pawnee::Base and implement setup to
+    # install everything needed for the gem
+    # setup should be able to be called multiple times
+    def setup
+      raise 'this gem does not implement the setup method'
+    end
+    
+    desc "teardown", 'teardown on the destination server'
+    # All recipies should also implement teardown to uninstall anything
+    # that gets installed
+    def teardown
+      raise 'this gem does not implement the teardown method'
+    end
+
+    # Guess the gem name based on the class name
+    def self.gem_name
+      self.name.gsub(/[:][:][^:]+$/, '').gsub(/^[^:]+[:][:]/, '').gsub('::', '-').downcase
+    end
+    
+    no_tasks {
+      
+      # # Invoke the given task if the given args.
+      def invoke_task(task, *args) #:nodoc:
+        current = @_invocations[self.class]
+
+        unless current.include?(task.name)
+          current << task.name
+
+          # Setup the server connections before we run the task
+          servers = options[:servers] || options['servers']
+
+          if !servers || self.class == Pawnee::CLI
+            # No servers, just run locally
+            task.run(self, *args)
+          else
+            # Run the setup task, setting up the needed connections
+            servers.each do |server|
+              # Only run on this server if the server supports the current recipe's
+              # role.
+              next unless server.is_a?(String) || (server['roles'] && server['roles'].include?(self.class.class_role))
+
+              # Set the server for this call
+              self.server = server.is_a?(String) ? server : server['domain']
+
+              # Run the task
+              task.run(self, *args)
+
+              # Remove the server
+              self.server = nil
+
+              # Close the connection
+              if self.destination_connection
+                self.destination_connection.close
+                self.destination_connection = nil
+              end
+            end
+          end
+        end
+      end
+
+      # Whenever say is used, also print out the server name
+      def say(*args)
+        text = args[0]
+        text = "[#{server}]:\t" + text
+        super(text, *args[1..-1])
+      end
+    }
+    
+    private
+      def self.global_options
+        @global_options = true
+        yield
+        @global_options = false
+      end
+      
+      def self.check_unknown_options?(config)
+        false
+      end
+    
+    
+      # Add options to create global method_options, otherwise
+      # they are now prefixed by the recipe name by default
+      def self.method_option(name, options={})
+        scope = if options[:for]
+          find_and_refresh_task(options[:for]).options
+        else
+          method_options
+        end
+
+        unless @global_options
+          prefix = self.gem_name.gsub('-', '_')
+          name = "#{prefix}_#{name}".to_sym
+        end
+
+        build_option(name, options, scope)
+      end
+      
+
+      # Inherited is called when a class inherits from Pawnee::Base, it then
+      # sets up the class in the pawnee command cli, and sets up the namespace.
+      # It also registeres the recipe so that it can be accessed later
+      def self.inherited(subclass)
+        super(subclass)
+        
+        # Make sure cli has been loaded at this point
+        require 'pawnee/cli'
+        
+        # Skip the main CLI class
+        return if subclass == Pawnee::CLI
+        
+        # Get the name of the parent module, which should what we want to register
+        # this class unser
+        class_name = subclass.gem_name
+        subclass.namespace(class_name)
+        
+        # Register the class with the namespace
+        Pawnee::CLI.register subclass, class_name.to_sym, class_name, "Setup #{class_name} on the remote server"
+        
+        @recipes ||= []
+        @recipes << subclass
+        
+        # Assign the default role (can be overridden by 'role :something' in the class)
+        subclass.role(class_name)
+      end
+      
+      def self.recipes
+        @recipes
+      end
+
+      # Pulls in the configuration options from the local path (relative to the Gemfile)
+      # Usually this is also the rails config directory
+      def self.config_options
+        return @config_options if @config_options
+        if defined?(Bundler)
+          @config_options = {}
+          require 'psych' rescue nil
+          require 'yaml'
+          
+          config_file = File.join(File.dirname(Bundler.default_gemfile), '/config/pawnee.yml')
+          if File.exists?(config_file)
+            options = YAML.load(File.read(config_file))
+            # Change keys to sym's
+            options = options.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo }
+            
+            @config_options.deep_merge!(options)
+          end
+        end
+        
+        return @config_options
+      end
+      
+      # Fire this callback whenever a method is added. Added methods are
+      # tracked as tasks by invoking the create_task method.
+      def self.method_added(meth)
+        super
+        
+        # Take all of the setup options and copy them to the main 
+        # CLI setup task
+        meth = meth.to_s
+        if meth != 'gem' && Pawnee::CLI.tasks[meth]
+          Pawnee::CLI.tasks[meth].options.merge!(self.tasks[meth].options)
+        end
+      end
+      
+
+  end
+end

data/lib/pawnee/pawnee/cli.rb

@@ -0,0 +1,72 @@
+require 'pawnee/base'
+require 'thor'
+require 'thor-ssh'
+
+# thor/group does not get correctly included in thor
+require 'thor/group'
+
+module Pawnee
+  class CLI < Pawnee::Base    
+    # Set blank namespace
+    namespace ''
+
+    desc "setup", "calls setup for each pawnee gem in bundler"
+    global_options do
+      method_option :roles, :type => :array, :default => :all
+    end
+    def setup
+      Pawnee::Base.invoke_roles(:setup, self.options[:roles], self.options)
+    end
+
+
+    desc "teardown", "calls teardown for each pawnee gem in bundler"
+    global_options do
+      method_option :roles, :type => :array, :default => :all
+    end
+    def teardown
+      Pawnee::Base.invoke_roles(:setup, self.options[:roles], self.options)
+    end
+
+
+    # Create a new gem (pulled from bundler and modified - MIT LICENSE)
+    desc "gem GEM", "Creates a skeleton recipie"
+    method_option :bin, :type => :boolean, :default => false, :aliases => '-b', :banner => "Generate a binary for your library."
+    def gem(name)
+      # Prefix all gems with pawnee-
+      name = 'pawnee-' + name.chomp("/") # remove trailing slash if present
+      folder_name = name.gsub('-', '/')
+      target = File.join(Dir.pwd, name)
+      constant_name = name.split('_').map{|p| p[0..0].upcase + p[1..-1] }.join
+      constant_name = constant_name.split('-').map{|q| q[0..0].upcase + q[1..-1] }.join('::') if constant_name =~ /-/
+      constant_array = constant_name.split('::')
+      git_user_name = `git config user.name`.chomp
+      git_user_email = `git config user.email`.chomp
+      opts = {
+        # Don't require the pawnee- when requring though
+        :name           => name.gsub(/^pawnee[-]/, ''),
+        :constant_name  => constant_name,
+        :constant_array => constant_array,
+        :author         => git_user_name.empty? ? "TODO: Write your name" : git_user_name,
+        :email          => git_user_email.empty? ? "TODO: Write your email address" : git_user_email
+      }
+      template(File.join("newgem/Gemfile.tt"),               File.join(target, "Gemfile"),                opts)
+      template(File.join("newgem/Rakefile.tt"),              File.join(target, "Rakefile"),               opts)
+      template(File.join("newgem/LICENSE.tt"),               File.join(target, "LICENSE"),                opts)
+      template(File.join("newgem/README.md.tt"),             File.join(target, "README.md"),              opts)
+      template(File.join("newgem/gitignore.tt"),             File.join(target, ".gitignore"),             opts)
+      template(File.join("newgem/newgem.gemspec.tt"),        File.join(target, "#{name}.gemspec"),        opts)
+      template(File.join("newgem/lib/pawnee/newgem.rb.tt"), File.join(target, "lib/pawnee/#{name}.rb"),         opts)
+      template(File.join("newgem/lib/pawnee/newgem/version.rb.tt"), File.join(target, "lib/#{folder_name}/version.rb"), opts)
+      template(File.join("newgem/lib/pawnee/newgem/base.rb.tt"), File.join(target, "lib/#{folder_name}/base.rb"), opts)
+      if options[:bin]
+        template(File.join("newgem/bin/newgem.tt"),          File.join(target, 'bin', name),              opts)
+      end
+      Bundler.ui.info "Initializating git repo in #{target}"
+      Dir.chdir(target) { `git init`; `git add .` }
+    end
+
+    def self.source_root
+      File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    end
+  end
+end

data/lib/pawnee/pawnee/invocation.rb

@@ -0,0 +1,13 @@
+module Pawnee
+  module Invocation
+    # This is copied in from thor/invocation.rb#initialize, 
+    # we can't extend from a module, so we just move this setup
+    # to a method
+    def pawnee_setup_invocations(args=[], options={}, config={}) #:nodoc:
+      # TODO: This may be also called as Thor::Invocation since we're calling
+      # super in the main initialize
+      @_invocations = config[:invocations] || Hash.new { |h,k| h[k] = [] }
+      @_initializer = [ args, options, config ]
+    end
+  end
+end

data/lib/pawnee/pawnee/parser/options.rb

@@ -0,0 +1,55 @@
+module Pawnee
+  class Options < Thor::Options
+
+    # Add the config options in as defaults first
+    def initialize(hash_options={}, defaults={})
+      # TODO: Add options to flatten from yaml
+      Pawnee::Base.config_options.each_pair do |key,value|
+        unless defaults[key]
+          defaults[key] = value
+        end
+      end
+      
+      super(hash_options, defaults)
+    end
+
+    # Change the option parsing so it does not freeze the hash
+    def parse(args)
+      @pile = args.dup
+
+      while peek
+        match, is_switch = current_is_switch?
+        shifted = shift
+
+        if is_switch
+          case shifted
+            when SHORT_SQ_RE
+              unshift($1.split('').map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+          end
+
+          switch = normalize_switch(switch)
+          option = switch_option(switch)
+          @assigns[option.human_name] = parse_peek(switch, option)
+        elsif match
+          @extra << shifted
+          @extra << shift while peek && peek !~ /^-/
+        else
+          @extra << shifted
+        end
+      end
+
+      check_requirement!
+
+      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
+      # assigns.freeze
+      assigns
+    end
+    
+  end
+end

data/lib/pawnee/pawnee/railtie.rb

@@ -0,0 +1,23 @@
+# This railtie is for bootstrapping the pawnee gem only
+# It adds the config/pawnee directory to the loadpath
+if defined?(Rails)
+  module Pawnee
+    class Railtie < Rails::Railtie
+      initializer "pawnee.configure_rails_initialization" do
+        puts "INITIALIZE1"
+      
+        path = (Rails.root + 'config/pawnee').to_s
+        puts path
+        unless $LOAD_PATH.include?(path)
+          $LOAD_PATH.unshift(path)
+        end
+      
+        puts "Require: pawnee/base"
+        require 'pawnee/base'
+
+      end
+    end
+  end
+else
+  require 'pawnee/base'
+end

data/lib/pawnee/pawnee/roles.rb

@@ -0,0 +1,79 @@
+module Pawnee
+  class Base
+    module Roles
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+      
+      module ClassMethods
+        # Assigns the role for this class
+        def role(role_name)
+          @role = role_name
+        end
+
+        def class_role
+          @role.to_s
+        end      
+
+        # Returns the recipe classes in order based on the Gemfile order
+        def ordered_recipes
+          return @ordered_recipes if @ordered_recipes
+          names = Bundler.load.dependencies.map(&:name)
+
+          # Setup a hash with the recipe name and the recipe class
+          recipe_pool = recipes.dup.inject({}) {|memo,recipe| memo[recipe.gem_name] = recipe ; memo }
+
+          # Go through the gems in the order they are in the Gemfile, then
+          # add them to the ordered list
+          @ordered_recipes = []
+          names.each do |name|
+            if recipe_pool[name]
+              @ordered_recipes << recipe_pool[name]
+              recipe_pool.delete(name)
+            end
+          end
+
+          # Add the remaining recipes (load them after everything else)
+          @ordered_recipes += recipe_pool.values
+
+          return @ordered_recipes
+        end
+
+        # Returns the list of classes that match the current list of roles
+        # in the correct run order
+        def recipe_classes_with_roles(roles)
+          # Check to make sure some recipes have been added
+          if ordered_recipes.size == 0
+            raise Thor::InvocationError, 'no recipes have been defined'
+          end
+          if (roles.is_a?(Array) && roles.size == 0) || roles == :all
+            # Use all classes
+            role_classes = ordered_recipes
+          else
+            # Remove classes that don't fit the roles being used
+            role_classes = ordered_recipes.reject do |recipe_class|
+              ![roles].flatten.map(&:to_s).include?(recipe_class.class_role)
+            end
+          end        
+        end
+
+        # Invokes all recipes that implement the passed in role
+        def invoke_roles(task_name, roles, options={})   
+          role_classes = self.recipe_classes_with_roles(roles)
+
+          # Run the taks on each role class
+          role_classes.each do |recipe_class|
+            # This class matches the role, so we should run it
+            recipe = recipe_class.new([], options)
+
+            task = recipe_class.tasks[task_name.to_s]
+            recipe.invoke_task(task)
+            
+            # Copy back and updated options
+            options = recipe.options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pawnee/pawnee/setup.rb

@@ -0,0 +1,23 @@
+require 'thor'
+
+# Add setup to the base class
+module Pawnee
+  class Base < Thor
+    if defined?(Rails)
+      class Railtie < Rails::Railtie  
+      end
+    end
+
+    def self.setup(gem_name)
+      # Setup the railtie
+      require "#{gem_name.gsub(/^pawnee[-]/, '')}/base"
+      
+      if defined?(Rails)
+        Railtie.initializer "#{gem_name}.configure_rails_initialization" do
+          gem_recipie_name = gem_name.gsub(/^pawnee[-]/, '')
+          require "#{gem_recipie_name}/base"
+        end
+      end
+    end
+  end
+end

data/lib/pawnee/pawnee/templates/newgem/Gemfile.tt

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in <%=config[:name]%>.gemspec
+gemspec