knife-topo 1.1.2 → 2.0.1

data/lib/chef/knife/topo_search.rb

@@ -15,79 +15,79 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-require_relative 'topology_helper'
 require 'chef/knife/search'
+require 'chef/knife/topo/command_helper'
 
-class Chef
-  class Knife
-    class TopoSearch < Chef::Knife::Search
+module KnifeTopo
+  # knife topo search
+  class TopoSearch < Chef::Knife::Search
+    deps do
+    end
 
-      banner "knife topo search [ QUERY ] (options)"
-      
-      option :topo,
-      :long => "--topo TOPOLOGY",
-      :description => "Restrict search to nodes in the specified topology"
-      
-      option :no_topo,
-      :long => "--no-topo",
-      :description => "Restrict search to nodes that are not in any topology",
-      :boolean => true,
-      :default => true
+    banner 'knife topo search [ QUERY ] (options)'
 
-      # Make the base search options available on topo search
-      self.options = (Chef::Knife::Search.options).merge(self.options)
+    option(
+      :topo,
+      long: '--topo TOPOLOGY',
+      description: 'Restrict search to nodes in the specified topology'
+    )
 
-      def initialize (args)
-        super
-        topo_query = constrain_query(@name_args[0] || config[:query], config[:topo], !config[:no_topo].nil?)
+    option(
+      :no_topo,
+      long: '--no-topo',
+      description: 'Restrict search to nodes that are not in any topology',
+      boolean: true
+    )
 
-        # force a node search
-        @name_args[0] = "node"
+    # Make the base search options available on topo search
+    orig_opts = KnifeTopo::TopoSearch.options
+    self.options = (Chef::Knife::Search.options).merge(orig_opts)
 
-        # override any query 
-        if config[:query]
-          config[:query] = topo_query
-        else
-          @name_args[1] = topo_query          
-        end
+    include KnifeTopo::CommandHelper
 
-      end
+    def run
+      setup_query
+      super
+    rescue StandardError => e
+      raise if Chef::Config[:verbosity] == 2
+      ui.error "Topology search for \"#{@query}\" exited with error"
+      humanize_exception(e)
+    end
+
+    def setup_query
+      query_str = @name_args[0] || config[:query]
+      topo_query = constrain_query(query_str, config[:topo])
 
-      def run
-        begin
-          super
-        rescue Exception => e
-          raise if Chef::Config[:verbosity] == 2
-          ui.error "Topology search for \"#{@query}\" exited with error"
-          humanize_exception(e)
-        end
+      # force a node search
+      @name_args[0] = 'node'
+
+      # override any query
+      if config[:query]
+        config[:query] = topo_query
+      else
+        @name_args[1] = topo_query
       end
+    end
+
+    def constrain_query(query, topo_name)
+      # group existing query workaround for strange behavior with
+      # NOTs and invalid query if put brackets round them
+      group_query = query && !query.start_with?('NOT') ? "(#{query})" : query
 
-      private
+      # search specific topologies or all/none
+      constraint = (topo_name) ? 'topo_name:' + topo_name : 'topo_name:*'
+
+      # combine the grouped query and constraint
+      combine(query, group_query, constraint)
+    end
 
-      include Chef::Knife::TopologyHelper
-      
-      def constrain_query(query, topo_name, no_topo)
-        
-        # group existing query
-        # workaround for strange behavior with NOTs and invalid query if put brackets round them
-        group_query = query && !query.start_with?("NOT") ? "(#{query})" : query
-        
-        # search specific topologies or all/none
-        constraint = (topo_name) ? "topo_name:" + topo_name : "topo_name:*" 
-        
-        # combine the grouped query and constraint
-        if no_topo
-          result = query ? "#{group_query} NOT #{constraint}" : "NOT #{constraint}"
-        else
-          result = query ? "#{constraint} AND #{group_query}" : constraint
-        end
-        
-        result
+    def combine(query, group_query, constraint)
+      find_in_topo = config[:topo] || config[:no_topo].nil?
+      if find_in_topo
+        query ? "#{constraint} AND #{group_query}" : constraint
+      else
+        query ? "#{group_query} NOT #{constraint}" : "NOT #{constraint}"
       end
-      
-       
     end
   end
-end
+end

data/lib/chef/knife/topo_update.rb

@@ -17,122 +17,37 @@
 #
 
 require 'chef/knife'
-require_relative 'topo_cookbook_upload'
+require 'chef/knife/topo_create'
 
-class Chef
-  class Knife
-    class TopoUpdate < Chef::Knife
-
-      deps do
-        Chef::Knife::TopoCookbookUpload.load_deps
-      end
-
-      banner "knife topo update [ TOPOLOGY ] (options)"
-
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag the topologies are stored in"
-
-      option :disable_upload,
-      :long => "--disable-upload",
-      :description => "Do not upload topo cookbooks",
-      :boolean => true
- 
-      # Make called command options available
-      self.options = Chef::Knife::TopoCookbookUpload.options.merge(self.options)
-
-      def initialize (args)
-        super
-        @topo_upload_args  = initialize_cmd_args(args, [ 'topo', 'cookbook', 'upload', '' ])
-
-        # All called commands need to accept union of options
-        Chef::Knife::TopoCookbookUpload.options = options
-      end
-
-      def run
-
-        bag_name = topo_bag_name(config[:data_bag])
-
-        if !@name_args[0]
-             ui.confirm("Do you want to update all topologies in the #{bag_name} data bag", true, true)
-        end
-
-        topo_name = @name_args[0]
-        
-        if topo_name
-          # update a specific topo
-          
-          unless current_topo = load_from_server(bag_name, topo_name)
-            ui.fatal "Topology #{bag_name}/#{topo_name} does not exist on server - use 'knife topo create' first"
-            exit(1)
-          end
-          
-          unless topo = load_from_file(bag_name, topo_name)
-            ui.info "No topology found in #{topologies_path}/#{bag_name}/#{topo_name}.json - exiting  without action"
-            exit(0)
-          end
-                    
-          msg = "Updating topology #{display_name(current_topo)}"
-          msg = msg + " to version " + format_topo_version(topo) if topo['version']
-          ui.info msg
-
-          update_topo(topo)
-          
-          ui.info "Updated topology " + display_name(topo)
-          ui.info("Build information: " + topo['buildstamp']) if topo['buildstamp']
-
-        else
-          # find all topologies from server then update them from file, skipping any that have no file
-          ui.info "Updating all topologies in data bag: #{bag_name}"
-
-          unless dbag = load_from_server(bag_name)
-            ui.fatal "Data bag #{bag_name} does not exist on server - use 'knife topo create' first"
-            exit(1)
-          end
-
-          dbag.keys.each do |topo_name|
+module KnifeTopo
+  # knife topo update
+  class TopoUpdate < KnifeTopo::TopoCreate
+    deps do
+      KnifeTopo::TopoCreate.load_deps
+    end
+    banner 'knife topo update TOPOLOGY (options)'
 
-            topo = load_from_file(bag_name, topo_name)
-            if !topo
-              # do not update topologies that are not in the local workspace
-              ui.info("No topology file found in #{topologies_path}/#{bag_name}/#{topo_name}.json - skipping")
-            else
-              msg = "Updating topology " + topo_name
-              msg = msg + " to version " + format_topo_version(topo) if topo['version']
-              ui.info msg
-              ui.info("Build information: " + topo['buildstamp']) if topo['buildstamp']
-              update_topo(topo)
-            end
-          end
-          ui.info "Updated topologies"
+    # Make called command options available
+    orig_opts = KnifeTopo::TopoCreate.options
+    bootstrap_opts = KnifeTopo::TopoBootstrap.options
+    self.options = bootstrap_opts.merge(orig_opts)
 
-        end
- 
-      end
+    def run
+      validate_args
+      load_topo_from_server_or_exit(@topo_name)
+      update_topo
 
-      def update_topo(topo)
-        topo.save
-        @topo_upload_args[3] = topo['name']
-        upload_cookbooks(@topo_upload_args) if (!config[:disable_upload]) 
+      check_chef_env(@topo['chef_environment'])
+      upload_artifacts unless config[:disable_upload]
+      update_nodes
 
-        topo_hash = topo.raw_data
-        nodes = merge_topo_properties(topo_hash['nodes'], topo_hash)
-        config[:disable_editing] = true
-        
-        if nodes && nodes.length > 0
-          nodes.each do |updates|
-            node_name = updates['name']
-            node = update_node(updates)
-            ui.info "Node #{node_name} does not exist - skipping update" if (!node)
-          end
-        else
-          ui.info "No nodes found for topology #{topo_hash['name']}"
-        end
-      end
+      report
+    end
 
-      include Chef::Knife::TopologyHelper
-      
+    def update_topo
+      # Load the topology data & update the topology bag
+      @topo = load_local_topo_or_exit(@topo_name)
+      @topo.save
     end
   end
 end

data/lib/chef/topo/converter.rb

@@ -0,0 +1,75 @@
+#
+# 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 converter class converts data in a given format into "topo" format data
+#
+
+class Chef
+  module Topo
+    # Base converter
+    class Converter
+      # rubocop:disable Style/ClassVars
+      # Converters for each format
+      @@converter_classes = {}
+
+      def self.register_converter(format, class_name)
+        @@converter_classes[format] = class_name
+      end
+
+      # Get the right converter for the input format
+      def self.converter(format)
+        converter_class = @@converter_classes[format]
+        converter_class = load_converter(format) unless converter_class
+
+        Object.const_get(converter_class).new(format)
+      end
+
+      def self.load_converter(format)
+        require "chef/topo/converter/#{format}"
+        @@converter_classes[format]
+      rescue LoadError
+        STDERR.puts("#{format} is not a known format for the topology file")
+        exit(1)
+      end
+
+      def self.convert(format, data)
+        converter = self.converter(format)
+        converter.convert(data)
+      end
+
+      attr_accessor :input
+
+      def initialize(format, data = nil)
+        @format = format
+        @input = data
+        @output = { 'nodes' => [] }
+      end
+
+      # Other format converters should override the following methods
+      register_converter('default', name)
+      register_converter('topo', name)
+
+      def convert(data = nil)
+        @input = data if data
+        @output = @input
+        @output
+      end
+    end
+  end
+end

data/lib/chef/topo/converter/topo_v1.rb

@@ -0,0 +1,123 @@
+#
+# 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.
+#
+
+#
+# Converts data in a given format into V2 topo JSON format
+#
+require 'chef/mixin/deep_merge'
+require 'chef/topo/converter'
+
+class Chef
+  module Topo
+    # Convert V1 topology JSON to V2
+    class TopoV1Converter < Chef::Topo::Converter
+      PRIORITIES = %w(default force_default normal override force_override)
+
+      register_converter('topo_v1', name)
+
+      def convert(data = nil)
+        @input = data if data
+        @output = @input.dup
+        determine_strategy
+        @output['nodes'] = []
+        @input['nodes'].each do |n|
+          @output['nodes'] << convert_node(n)
+        end
+        cleanup_output
+      end
+
+      def convert_node(n)
+        combined = merge_cookbook_attrs(n)
+        type = node_type(n)
+        combined['node_type'] ||= type if type
+        combined
+      end
+
+      def determine_strategy
+        @output['strategy'] = 'direct_to_node'
+        cookbooks = @input['cookbook_attributes']
+        return unless cookbooks && cookbooks.length > 0
+
+        cookbooks.each do |cb|
+          cond = cb['conditional'] || []
+          next unless !cond.empty? || PRIORITIES.any? { |k| cb.key?(k) }
+          via_cookbook_strategy(cb)
+          break
+        end
+      end
+
+      def via_cookbook_strategy(cb)
+        @output['strategy'] = 'via_cookbook'
+        @output['strategy_data'] = {
+          'cookbook' => cb['cookbook'] || @output['name'],
+          'filename' => cb['filename'] || 'attributes'
+        }
+      end
+
+      # move source[p] contents and merge into dest[p]
+      def merge_copy(dest, source)
+        PRIORITIES.reverse_each do |p|
+          if source.key?(p)
+            dest[p] = Chef::Mixin::DeepMerge.merge(source[p], dest[p])
+          end
+        end
+      end
+
+      # Combine cookbook attributes into node
+      def merge_cookbook_attrs(node)
+        cb_attr_array = @input['cookbook_attributes']
+        combined = node.dup
+        return combined unless cb_attr_array
+
+        # merge unqualified attributes into node
+        cb_attr_array.each do |cb_attrs|
+          merge_copy(combined, cb_attrs)
+
+          # find qualified attributes for node
+          cond = cb_attrs['conditional']
+          next unless cond
+
+          merge_copy_cond_attrs(combined, cond)
+        end
+
+        combined
+      end
+
+      def merge_copy_cond_attrs(combined, cond)
+        topo = (combined['normal'] || {})['topo'] || {}
+        cond.each do |cond_attrs|
+          if topo[cond_attrs['qualifier']] == cond_attrs['value']
+            merge_copy(combined, cond_attrs)
+          end
+        end
+        combined
+      end
+
+      def node_type(node)
+        return node['node_type'] if node['node_type']
+        return nil unless node['normal'] && node['normal']['topo']
+        node['normal']['topo']['node_type']
+      end
+
+      def cleanup_output
+        @output.delete('cookbook_attributes')
+        @output
+      end
+    end
+  end
+end