knife-topo 1.1.2 → 2.0.1

data/knife-topo.gemspec

@@ -4,17 +4,17 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'chef/knife/topo/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "knife-topo"
-  spec.version       = Knife::Topo::VERSION
-  spec.authors       = ["Christine Draper"]
-  spec.email         = ["christine_draper@thirdwaveinsights.com"]
-  spec.summary       = "Knife plugin to manage topologies of nodes"
-  spec.description   = "Knife-topo uses a JSON file to capture a topology of nodes, which can be loaded into Chef and bootstrapped"
-  spec.homepage      = "https://github.com/christinedraper/knife-topo"
-  spec.license       = "Apache License (2.0)"
-    
-  spec.files         = Dir.glob("{lib}/**/*")  +
-    ['LICENSE', 'README.md', __FILE__]
-  spec.require_paths = ["lib"]
+  spec.name          = 'knife-topo'
+  spec.version       = KnifeTopo::VERSION
+  spec.authors       = ['Christine Draper']
+  spec.email         = ['christine_draper@thirdwaveinsights.com']
+  spec.summary       = 'Knife plugin to manage topologies of nodes'
+  spec.description   = 'Knife-topo uses a JSON file to capture a topology '\
+    'of nodes, which can be loaded into Chef and bootstrapped'
+  spec.homepage      = 'https://github.com/christinedraper/knife-topo'
+  spec.license       = 'Apache License (2.0)'
 
+  spec.files         = Dir.glob('{lib}/**/*') +
+    ['LICENSE', 'README.md', __FILE__]
+  spec.require_paths = ['lib']
 end

data/lib/chef/knife/topo/bootstrap_helper.rb

@@ -0,0 +1,75 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2014 ThirdWave Insights LLC
+# 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 'chef/rest'
+require 'chef/knife/topo/command_helper'
+
+module KnifeTopo
+  # Node update helper for knife topo
+  module BootstrapHelper
+    include KnifeTopo::CommandHelper
+
+    # Setup the bootstrap args and run the bootstrap command
+    def run_bootstrap(data, bootstrap_args, overwrite = false)
+      node_name = data['name']
+      args = setup_bootstrap_args(bootstrap_args, data)
+      delete_client_node(node_name) if overwrite
+
+      ui.info "Bootstrapping node #{node_name}"
+      run_cmd(Chef::Knife::Bootstrap, args)
+    rescue StandardError => e
+      raise if Chef::Config[:verbosity] == 2
+      ui.warn "bootstrap of node #{node_name} exited with error"
+      humanize_exception(e)
+      false
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def setup_bootstrap_args(args, data)
+      # We need to remove the --bootstrap option, if it exists
+      args -= ['--bootstrap']
+      args[1] = data['ssh_host']
+
+      # And set up the node-specific data but ONLY if defined
+      args += ['-N', data['name']] if data['name']
+      args += ['-E', data['chef_environment']] if data['chef_environment']
+      args += ['--ssh-port', data['ssh_port']] if data['ssh_port']
+      args += ['--run-list', data['run_list'].join(',')] if data['run_list']
+      attrs = attributes_for_bootstrap(data)
+      args += ['--json-attributes', attrs.to_json] unless attrs.empty?
+      args
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # for bootstrap, attributes have to include tags
+    def attributes_for_bootstrap(data)
+      attrs = data['normal'] || {}
+      attrs['tags'] = data['tags'] if data['tags']
+      attrs
+    end
+
+    def delete_client_node(node_name)
+      ui.info("Node #{node_name} exists and will be overwritten")
+      # delete node first so vault refresh does not pick up existing node
+      rest.delete("nodes/#{node_name}")
+      rest.delete("clients/#{node_name}")
+    rescue Net::HTTPServerException => e
+      raise unless e.response.code == '404'
+    end
+  end
+end

data/lib/chef/knife/topo/command_helper.rb

@@ -0,0 +1,71 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2014 ThirdWave Insights LLC
+# 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 'chef/environment'
+
+module KnifeTopo
+  # Knife topo helpers
+  module CommandHelper
+    # initialize args for another knife command
+    def initialize_cmd_args(args, name_args, new_name_args)
+      args = args.dup
+      args.shift(2 + name_args.length)
+      new_name_args + args
+    end
+
+    # run another knife command
+    def run_cmd(command_class, args)
+      command = command_class.new(args)
+      command.config[:config_file] = config[:config_file]
+      command.configure_chef
+      command_class.load_deps
+      command.run
+
+      command
+    end
+
+    # check if resource exists
+    def resource_exists?(relative_path)
+      rest.get_rest(relative_path)
+      true
+    rescue Net::HTTPServerException => e
+      raise unless e.response.code == '404'
+      false
+    end
+
+    # make sure the chef environment exists
+    def check_chef_env(chef_env_name)
+      return unless chef_env_name
+      Chef::Environment.load(chef_env_name) if chef_env_name
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^404/
+      ui.info 'Creating chef environment ' + chef_env_name
+      chef_env = Chef::Environment.new
+      chef_env.name(chef_env_name)
+      chef_env.create
+      chef_env
+    end
+
+    def most_common(vals)
+      return if vals.length == 0
+      vals.group_by do |val|
+        val
+      end.values.max_by(&:size).first
+    end
+  end
+end

data/lib/chef/knife/topo/consts.rb

@@ -0,0 +1,4 @@
+# constants
+module KnifeTopo
+  PRIORITIES = %w(default force_default normal override force_override)
+end

data/lib/chef/knife/topo/loader.rb

@@ -0,0 +1,137 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2014 ThirdWave Insights LLC
+# 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 'chef/topology'
+require 'chef/knife/core/object_loader'
+require 'chef/data_bag'
+require 'chef/data_bag_item'
+require 'chef/knife'
+
+module KnifeTopo
+  # Topology loaders
+  module Loader
+    attr_reader :ui, :loader
+
+    # Loader to get data bag items from file
+    def loader
+      @loader ||= Chef::Knife::Core::ObjectLoader.new(Chef::DataBagItem, ui)
+    end
+
+    def load_local_topo_or_exit(topo_name)
+      filepath = get_local_topo_path(topo_name)
+      msg = "Topology file #{filepath} not found - use " \
+        "'knife topo import' first"
+      check_file(filepath, msg)
+      load_topo_from_file_or_exit(filepath)
+    end
+
+    def load_topo_from_file_or_exit(filepath, format = nil)
+      check_file(filepath)
+      data = loader.object_from_file(filepath)
+      format ||= auto_detect_format(data)
+      topo = Chef::Topology.convert_from(format, data)
+      topo.data_bag(topo_bag_name)
+      topo
+    end
+
+    def check_file(filepath, msg = nil)
+      return if loader.file_exists_and_is_readable?(filepath)
+      msg ||= "Topology file #{filepath} not found"
+      ui.fatal(msg)
+      exit(1)
+    end
+
+    def auto_detect_format(data)
+      return 'topo_v1' if data['cookbook_attributes']
+      'default'
+    end
+
+    def get_local_topo_path(topo_name)
+      File.join(
+        Dir.pwd,
+        topologies_path,
+        topo_bag_name,
+        topo_name + '.json'
+      )
+    end
+
+    def load_topo_from_server(topo_name)
+      Chef::Topology.load(topo_bag_name, topo_name)
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^404/
+    end
+
+    def load_topo_from_server_or_exit(topo_name)
+      topo = load_topo_from_server(topo_name)
+      unless topo
+        ui.fatal("Topology #{topo_bag_name}/#{@topo_name} does not exist " \
+          "on the server - use 'knife topo create' first")
+        exit(1)
+      end
+      topo
+    end
+
+    # Name of the topology bag
+    def topo_bag_name
+      @topo_bag_name ||= config[:data_bag]
+      @topo_bag_name ||= 'topologies'
+    end
+
+    # Path for the topologies data bags.
+    # For now, use the standard data_bags path for our topologies bags
+    def topologies_path
+      @topologies_path ||= 'data_bags'
+    end
+
+    def create_topo_bag
+      data_bag = Chef::DataBag.new
+      data_bag.name(topo_bag_name)
+      data_bag.create
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^409/
+    end
+
+    def list_topo_bag
+      Chef::DataBag.load(topo_bag_name)
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^404/
+    end
+
+    def load_node_data(node_name, min_priority = 'default')
+      node_data = {}
+      node = Chef::Node.load(node_name)
+      %w(name tags chef_environment run_list).each do |key|
+        node_data[key] = node.send(key)
+      end
+      node_data = node_data.merge(priority_attrs(node, min_priority))
+    end
+
+    def priority_attrs(node, min_priority = 'default')
+      attrs = {}
+      p = KnifeTopo::PRIORITIES
+      min_index = p.index(min_priority)
+      p.each_index do |index|
+        next if index < min_index
+        key = p[index]
+        attrs[key] = node.send(key)
+        attrs.delete(key) if attrs[key].empty?
+      end
+      attrs
+    end
+  end
+end

data/lib/chef/knife/topo/node_update_helper.rb

@@ -0,0 +1,111 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2014 ThirdWave Insights LLC
+# 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 'chef/node'
+require 'chef/run_list'
+require 'chef/mixin/deep_merge'
+require 'chef/rest'
+
+module KnifeTopo
+  # Node update helper for knife topo
+  module NodeUpdateHelper
+    # Update an existing node
+    def update_node(node_updates)
+      config[:disable_editing] = true
+
+      begin
+        # load then update and save the node
+        node = Chef::Node.load(node_updates['name'])
+
+        env = node_updates['chef_environment']
+        check_chef_env(env) unless env == node['chef_environment']
+        do_node_updates(node, node_updates)
+
+      rescue Net::HTTPServerException => e
+        raise unless e.to_s =~ /^404/
+        # Node has not been created
+      end
+
+      node
+    end
+
+    def do_node_updates(node, node_updates)
+      updated = update_node_with_values(node, node_updates)
+      if updated
+        ui.info "Updating #{updated.join(', ')} on node #{node.name}"
+        node.save
+        ui.output(format_for_display(node)) if config[:print_after]
+      else
+        ui.info "No updates found for node #{node.name}"
+      end
+    end
+
+    # Update original node, return list of updated properties.
+    def update_node_with_values(node, updates)
+      updated = []
+
+      # merge the normal attributes (but not tags)
+      updated << 'normal' if update_attrs(node, updates['normal'])
+
+      # update runlist
+      updated << 'run_list' if update_runlist(node, updates['run_list'])
+
+      # update chef env
+      if update_chef_env(node, updates['chef_environment'])
+        updated << 'chef_environment'
+      end
+
+      # merge tags
+      updated << 'tags' if update_tags(node, updates['tags'])
+
+      # return false if no updates, else return array of property names
+      updated.length > 0 && updated
+    end
+
+    # Update methods all return true if an actual update is made
+    def update_attrs(node, attrs)
+      return false unless attrs
+      attrs.delete('tags')
+      original = node.normal.clone
+      node.normal = Chef::Mixin::DeepMerge.merge(node.normal, attrs)
+      original != node.normal
+    end
+
+    def update_runlist(node, runlist)
+      # node.run_list MUST be lhs of != to use override operator
+      return false unless runlist && node.run_list != runlist
+      updated_run_list = Chef::RunList.new
+      runlist.each { |e| updated_run_list << e }
+      node.run_list(*updated_run_list)
+      true
+    end
+
+    def update_chef_env(node, env)
+      return false unless env && env != node.chef_environment
+      node.chef_environment(env)
+      true
+    end
+
+    def update_tags(node, tags)
+      return false unless tags
+      orig_num_tags = node.tags.length
+      node.tag(*tags)
+      node.tags.length > orig_num_tags
+    end
+  end
+end

data/lib/chef/knife/topo/processor.rb

@@ -0,0 +1,76 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# 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.
+#
+
+#
+# The processor class converts a topology into node data and artifacts,
+# based on the strategy
+#
+
+require 'chef/mixin/deep_merge'
+module KnifeTopo
+  # Base processor
+  class Processor
+    # rubocop:disable Style/ClassVars
+    @@processor_classes = {}
+
+    def self.register_processor(strategy, class_name)
+      @@processor_classes[strategy] = class_name
+    end
+
+    # Get the right processor
+    def self.processor(topo)
+      strategy = topo.strategy
+      processor_class = @@processor_classes[strategy]
+      processor_class = load_processor(strategy) unless processor_class
+
+      Object.const_get(processor_class).new(topo)
+    end
+
+    def self.load_processor(strategy)
+      require "chef/knife/topo/processor/#{strategy}"
+      @@processor_classes[strategy]
+    rescue LoadError
+      STDERR.puts("#{strategy} is not a known strategy")
+      exit(1)
+    end
+
+    def self.for_topo(topo)
+      processor(topo)
+    end
+
+    attr_accessor :input
+
+    def initialize(topo)
+      @topo = topo
+    end
+
+    # Other processors should override the following methods
+    register_processor('direct_to_node', name)
+
+    def generate_nodes
+      @topo.merged_nodes
+    end
+
+    def generate_artifacts(_context = {})
+      {}
+    end
+
+    def upload_artifacts(_context = {})
+    end
+  end
+end