kknife 0.1.1

data/lib/kknife/knifecmd.rb

@@ -0,0 +1,210 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'kknife/dbg'
+require 'kknife/lookup'
+require 'chef/knife'
+require 'chef/application/knife'
+
+### Knifecmd 
+# Used as the base for the knife command. 
+# Stories information about the run and the 
+# Command tree
+
+class Knifecmd
+
+  include Dbg
+
+  attr_accessor :shortcuts, :ambiguities, :commands, :cmd_found, :cmd_left, :knife_commands
+
+  def initialize( argopts = {} )
+
+    # Root command is k.. or knife
+    @root = 'knife'
+
+    opts = {
+      :commands     => ARGV.dup.freeze,
+      :cmd_found    => [],
+      :cmd_left     => ARGV.dup,
+      :shortcuts    => {},
+      :ambiguities  => {},
+      :config_build => '~/.chef/.kknife.built.config',
+      :config_user  => '~/.chef/.kknife.user.config',
+    }.merge argopts
+
+    @commands     = opts[:commands]
+    @cmd_found    = opts[:cmd_found]
+    @cmd_left     = opts[:cmd_left]
+    @shortcuts    = opts[:shortcuts]
+    @ambiguities  = opts[:ambiguities]
+    @config_build = File.expand_path opts[:config_build]
+    @config_user  = File.expand_path opts[:config_user]
+
+    @cmd_root = Command.new( @root, :controller => self )
+    
+    # Instead of trawling for chef files each time we can load a previous config
+    lookup_files unless lookup_config
+
+    # Now process the knife commands into a tree of Command
+    load_commands
+
+    # Then setup to find commands
+    reset_found
+  end
+
+
+  # Look up the knife commands from a prebuilt kknife config
+  def lookup_config
+    # pull in a config if it exists
+    return false unless File.exists? @config_build
+
+    @knife_commands = JSON.parse File.open( @config_build, 'r' ){|f| f.read }
+  end
+
+
+  # Look up the knife commands from knife library files
+  def lookup_files
+    # pull in the standard knife files
+    Chef::Knife.load_commands
+    @knife_commands = Chef::Knife.subcommands_by_category
+  end
+
+
+  # Write out a built config file
+  def write_config
+    raise "No directory [#{File.dirname( @config_build )}]" unless Dir.exists? File.dirname( @config_build )
+    File.open( @config_build, 'w' ){|f| f.write @knife_commands.to_json }
+  end
+
+
+  # Remove a built config file
+  def clear_config
+    FileUtils.rm @config_build if File.exists? @config_build
+  end
+
+
+  # Turn the knife command arrays into a Command tree
+  def load_commands
+    # loop over the commands, put them into Command
+    @knife_commands.each do |category,command_arr|
+      dbg 'category', category
+      command_arr.each do |command|
+        dbg 'command', command
+        commands = command.split( /_/ )
+        @cmd_root.add_command commands
+      end
+    end
+  end
+
+
+  # Start with out root Command and print the command tree
+  def print_tree
+    @cmd_root.pp
+  end
+  def print
+    @cmd_root.pp_single
+  end
+
+  # Start at the root command and go down the tree
+  # looking for each command
+  def lookup( commands = @commands )
+    dbg 'lookup', commands
+    reset_found commands 
+
+    begin
+      @cmd_root.process_lookup commands
+
+    rescue Command::AmbiguousCommand => e
+      raise "error [#{commands.to_s}] #{e}"
+      
+    rescue Command::NotFoundCommand => e
+      raise "error [#{commands.to_s}] #{e}"
+
+    rescue Command::NoMoreSubCommands
+      dbg "end of knife lookups", @cmd_found.join(','), @cmd_left.join(',')
+
+    rescue Command::NoMoreSuppliedCommands
+      dbg "end of argv lookups", @cmd_found.join(','), @cmd_left.join(',')
+
+    end
+
+    @cmd_found
+  end
+
+  
+  # if the Command lookup needs to split a command
+  # remove the command from what's left and split it 
+  # into the componenets
+  def cmd_split( split_command_array )
+    # first remove the previous entry with _
+    @cmd_left.shift
+
+    # then prefix the new split entires
+    @cmd_left.unshift *split_command_array
+  end
+
+
+  # if the Command lookup find a command, add it to found
+  # and take it away from whats left 
+  def found_cmd( command )
+    dbg 'found_cmd b4 ', command, @cmd_found.join(','), '|', @cmd_left.join(',')
+    @cmd_found.push command
+    @cmd_left.shift
+    dbg 'found_cmd aft', command, @cmd_found.join(','), '|', @cmd_left.join(',')
+  end
+
+
+  # if the Command lookup hits a shortcut, adjust local 
+  # variables to match
+  def found_shortcut( shortcut )
+    dbg 'found_shortcut b4 ', shortcut.join(','), '|', @cmd_left.join(',')
+    @cmd_left.shift
+    @cmd_left.unshift *shortcut
+    dbg 'found_shortcut aft', shortcut.join(','), '|', @cmd_left.join(',')
+  end
+
+
+  # reset the command found instance variables
+  def reset_found( commands = [] )
+    @cmd_found = []
+    @cmd_left  = commands.dup
+  end
+
+
+  # return the found command as a space seperated string
+  def found_string
+    ([ @root ] + @cmd_found ).join(' ')
+  end
+
+
+  # resolve a list of commands into real commands
+  def resolve( commands )
+    lookup commands
+    @cmd_found + @cmd_left
+  end
+
+  # Run the knife command
+  def run( commands = ARGV )
+
+    # mess with argv
+    ARGV.replace resolve( commands )
+
+    # Run knife directly 
+    Chef::Application::Knife.new.run
+
+  end
+
+end

data/lib/kknife/log.rb

@@ -0,0 +1,56 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'logger'
+
+### Log - a global logger instance for classes 
+
+# Allows you to call a single logger instance easily from your classes
+
+# ```
+# class Yours
+#   include Log
+#   def method
+#     log.info 'something'
+#   end
+# end
+# ```
+
+module Log
+
+  DefaultIO = STDOUT
+
+  def log
+    Logging.log
+  end
+
+  def self.replace( io )
+    l = Logger.new io
+    l.level = @log.level
+    @log = l
+  end
+
+  def self.create
+    l = Logger.new DefaultIO
+    l.level = Logger::INFO
+    l
+  end
+
+  def self.log
+    @log ||= create
+  end
+
+end

data/lib/kknife/lookup.rb

@@ -0,0 +1,50 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+### Lookup
+
+# Provides some lookups commands not based on knife commands
+# Ambiguities are helpers in the case of an ambiguous "find"
+# Shortcuts will be used if all other command lookups fail
+
+module Lookup
+
+  Shortcuts = {
+    'ff' => [ 'from', 'file' ],
+    'db' => [ 'data', 'bag' ],
+    'cs' => [ 'cookbook', 'site' ],
+    'bd' => [ 'bulk', 'delete' ],
+    'ne' => [ 'node', 'edit' ],
+    'ns' => [ 'node', 'show' ],
+    'rl' => [ 'run', 'list' ],
+  }
+
+  Ambiguities = {
+    'd' => ['download'],
+    'e' => ['environment'],
+    'r' => ['role'],
+    'c' => ['cookbook'],
+  }
+
+  def self.shortcut( key )
+    Shortcuts[key] if Shortcuts.has_key? key
+  end
+
+  def self.ambiguity( key )
+    Ambiguities[key] if Ambiguities.has_key? key
+  end
+
+end

data/lib/kknife/version.rb

@@ -0,0 +1,3 @@
+module Kknife
+  VERSION = '0.1.1'
+end

data/lib/kknife.rb

@@ -0,0 +1,71 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'kknife/command'
+require 'kknife/knifecmd'
+require 'kknife/dbg'
+require 'trollop'
+
+
+class Kknife
+
+  include Dbg
+
+  def run( commands = ARGV )
+
+    # Trollop argv parsing
+    opts = Trollop::options do
+      version "kknife 0.1.1 (c) 2013 Matt Hoyle. Deployable Ltd."
+      banner <<-EOS
+    kknife - chef knife command shortcuts
+
+    Usage:  k [options] <knife sub commands>
+
+    Where [options] are:
+    EOS
+      #opt :config, "User command shortcuts and ambiguities"
+      opt :test,     "Test lookup, don't execute knife"
+      opt :debug,    "Turn on debug output"
+      opt :list,     "List commands"
+      stop_on_unknown()
+    end
+
+    debug_logger.level = Logger::DEBUG if opts[:debug]
+
+    # Create the knife controller
+    k = Knifecmd.new( :argv => ARGV )
+
+    # Do the optional bits
+    #k.user_config if opts[:config]
+    k.print if opts[:debug]
+
+    # Then run what we've been asked to
+    if opts[:list]
+      # Print the list of commands
+      k.print unless opts[:debug]
+
+    elsif opts[:test]
+      # Don't run knife, just print what would have been run
+      printf "%s\n", k.resolve( ARGV ).join(' ')
+
+    else
+      # Otherwise run knife directly with the lookedup ARGV
+      k.run
+    end
+
+  end
+
+end

data/spec/command_spec.rb

@@ -0,0 +1,26 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+ 
+describe Command do
+ 
+  before :each do
+    @c = Command.new
+  end
+
+
+end

data/spec/helpers.rb

@@ -0,0 +1,82 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Helpers
+
+  # path current executing ruby bin
+  RUBY = File.join( 
+      RbConfig::CONFIG['bindir'], 
+      RbConfig::CONFIG['ruby_install_name']
+  ).sub(/.*\s.*/m, '"\&"')
+
+
+  def self.runner( command )
+      i,o,e,t = Open3.popen3( "#{command}" )
+      i.close
+      out = o.read
+      err = e.read
+      return [out,err,t]
+  end
+
+  def self.krunner( commands )
+      lib = File.expand_path( '../lib', File.dirname(__FILE__) )
+      bin = File.expand_path( '../bin/k', File.dirname(__FILE__) )
+      arg = commands.join(' ')
+      runner "#{RUBY} -I#{lib} #{bin} #{arg}"
+  end
+
+
+  require 'rest_client'
+  require 'chef_zero/server'
+
+  def self.create_chef_server( host = 'localhost', port = 80, env = 'test', node = 'nodeo'  )
+
+    server = ChefZero::Server.new( host: 'localhost', port: 4000 )
+    scheme = 'http'
+    uri    = "#{scheme}://#{host}:#{port}"
+    server.start_background
+
+    env_obj = {
+      :name                => env,
+      :description         => "descenv",
+      :cookbook_versions   => {},
+      :json_class          => "Chef::Environment",
+      :chef_type           => "environment",
+      :default_attributes  => {},
+      :override_attributes => {},
+    }
+
+    er = RestClient.post "#{uri}/environments", 
+      env_obj.to_json, :content_type => :json, :accept => :json
+    puts er.code unless er.code == 200 or er.code == 201
+
+    node_obj = {
+      :chef_type  => "node",
+      :json_class => "Chef::Node",
+      :name       => node,
+      :chef_environment => env,
+      :run_list   => []
+    }
+    #printf "%s %s\n", r.code, r.to_str
+
+    nr = RestClient.post "#{uri}/nodes", 
+      node_obj.to_json, :content_type => :json, :accept => :json
+    puts nr.code unless nr.code == 200 or nr.code == 201
+
+    return server
+  end
+
+end

data/spec/k_spec.rb

@@ -0,0 +1,116 @@
+# Author: Matt Hoyle (<matt@deployable.co>)
+# Copyright: Copyright (c) 2013 Deployable Ltd.
+# License: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+require './spec/helpers'
+
+RSpec.configure do |c|
+  c.include Helpers
+end
+
+
+describe "k command" do
+ 
+
+
+  ListString = 'knife user show'
+  Helpers.create_chef_server( 'localhost', 4000 )
+
+
+  it "outputs debug with -d" do
+    ARGV.replace %w( -d list )
+  
+    Chef::Application::Knife.any_instance.stub(:run).and_return( true )
+
+    # replace the debug STDERR logger with our testable
+    output = StringIO.new
+    Dbg.replace output
+    
+    expect { Kknife.new.run }.to match_stdout( ListString )
+    expect( output.string ).to match( /end of knife lookups \[list\] \[\]/ )
+
+  end
+
+
+  it "lists command with -l" do
+    ARGV.replace %w( -l )
+
+    expect { Kknife.new.run }.to match_stdout( ListString )
+  end
+
+
+  it "only dumps command when using test option" do
+    ARGV.replace %w( -t node list )
+
+    expect { Kknife.new.run }.to stdout( "node list\n" )
+  end
+
+
+  it "display the options in help" do
+    ARGV.replace %w( -h )
+    
+    expect{ 
+      begin
+        Kknife.new.run   
+      rescue SystemExit
+      end
+    }.to match_stdout( /-t.*-d.*-l/m )
+
+  end
+
+
+  it "display correct version with -v " do
+
+    ARGV.replace %w( -v )
+
+    expect{ 
+      begin
+        Kknife.new.run   
+      rescue SystemExit
+      end
+    }.to stdout( "kknife 0.1.1 (c) 2013 Matt Hoyle. Deployable Ltd.\n" )
+
+  end
+
+
+  it "runs a knife command correctly" do
+
+    o,e,t = Helpers.krunner %w( environment show test )
+
+    expect( o ).to match( /^name:\s+test$/ )
+
+  end
+
+
+  it "passes options onto knife correctly" do
+
+    o,e,t = Helpers.krunner %w( environment show test -F json )
+
+    expect( o ).to match( /"name": "test"/ )
+
+  end
+
+
+  it "runs a knife command search correctly" do
+
+    o,e,t = Helpers.krunner %w( n s nodeo )
+
+    expect( o ).to match( /Node Name:   nodeo/ )
+    expect( o ).to match( /Environment: test/ )
+  end
+
+
+end