knife-topo 1.1.2 → 2.0.1

data/lib/chef/knife/topo_export.rb

@@ -17,160 +17,135 @@
 #
 
 require 'chef/knife'
+require 'chef/knife/topo/loader'
+require 'chef/knife/topo/consts'
+require 'chef/knife/topo/command_helper'
+require 'chef/knife/topo/consts'
 
-require_relative 'topology_helper'
+# NOTE: This command exports to stdout
 
-# NOTE: This command exports to stdout 
-
-class Chef
-  class Knife
-    class TopoExport < Chef::Knife
+module KnifeTopo
+  # knife topo export
+  class TopoExport < Chef::Knife
+    deps do
+    end
 
-      deps do
+    banner 'knife topo export [ NODE ... ] (options)'
+
+    option(
+      :data_bag,
+      short: '-D DATA_BAG',
+      long: '--data-bag DATA_BAG',
+      description: 'The data bag the topologies are stored in'
+    )
+
+    option(
+      :min_priority,
+      long: '--min-priority PRIORITY',
+      default: 'default',
+      description: 'Export attributes with this priority or above'
+    )
+
+    option(
+      :topo,
+      long: '--topo TOPOLOGY',
+      description: 'Name to use for the topology',
+      default: 'topo1'
+    )
+
+    include KnifeTopo::Loader
+    include KnifeTopo::CommandHelper
+
+    def run
+      unless KnifeTopo::PRIORITIES.include?(config[:min_priority])
+        ui.warn('--min-priority should be one of ' \
+          "#{KnifeTopo::PRIORITIES.join(', ')}")
       end
+      @topo_name = config[:topo]
+      @node_names = @name_args
+      output(Chef::JSONCompat.to_json_pretty(load_or_initialize_topo))
+    end
 
-      banner "knife topo export [ TOPOLOGY [ NODE ... ]] (options)"
-
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag the topologies are stored in"
-      
-      option :min_priority,
-      :long => "--min-priority PRIORITY",
-      :default => "default",
-      :description => "Export attributes with this priority or above"
-      
-      option :topo,
-      :long => "--topo TOPOLOGY",
-      :description => "Name to use for the topology",
-      :default => "topo1"
-      
-      option :all,
-      :long => "--all",
-      :description => "Export all topologies",
-      :boolean => true,
-      :default => false
-
-      def most_common (vals)
-        vals.group_by do |val|
-          val
-        end.values.max_by(&:size).first
+    def load_or_initialize_topo
+      topo = load_topo_from_server(@topo_name)
+      if topo
+        export = topo.raw_data
+        update_nodes!(export['nodes'])
+      else
+        export = new_topo
       end
-      
-      def run
-
-        @bag_name = topo_bag_name(config[:data_bag])
+      export
+    end
 
-        @topo_name = config[:topo] unless config[:all]
-        @node_names = @name_args
-        
-        unless ['default', 'normal', 'override'].include?(config[:min_priority])
-          ui.warn("--min-priority should be one of 'default', 'normal' or 'override'")
-        end
-        
-        if @topo_name
-          if topo = load_from_server(@bag_name, @topo_name)
-            export = topo.raw_data
-          else
-            export = empty_topology
-            export['nodes'].push(empty_node("node1")) if @node_names.length == 0
-          end
-
-          # merge in data for nodes that user explicitly specified
-          @node_names.each do |node_name|
-            merge_node_properties!(export['nodes'], node_name)
-          end
-          
-          # if a new topo, pick an topo environment based on the nodes
-          if !topo && @node_names.length != 0
-            envs = []
-            export['nodes'].each do |node| 
-              envs << node['chef_environment'] if node['chef_environment']
-            end
-            export['chef_environment'] = most_common(envs) if envs.length > 0
-          end
+    def new_topo
+      topo = empty_topology
+      update_nodes!(topo['nodes'])
 
-        else
-          # export all topologies
-          export = []
-          if dbag = load_from_server(@bag_name)
-            dbag.keys.each do |topo_name|
-               if topo = load_from_server(@bag_name, topo_name)
-                export << topo.raw_data
-              end
-            end
-          end
-        end
+      # pick an topo environment based on the nodes
+      return topo if @node_names.length == 0
+      env = pick_env(topo['nodes'])
+      topo['chef_environment'] = env if env
+      topo
+    end
 
-        output(Chef::JSONCompat.to_json_pretty(export))
+    def pick_env(nodes)
+      envs = []
+      nodes.each do |node|
+        envs << node['chef_environment'] if node['chef_environment']
       end
+      most_common(envs)
+    end
 
-      # give user a template to get started
-      def empty_topology
-        {
-          "id" => @topo_name || "topo1",
-          "name" => @topo_name || "topo1",
-          "chef_environment" => "_default",
-          "tags" => [ ],
-          "nodes" => [ ],
-          "cookbook_attributes" => [{
-            "cookbook" =>  @topo_name || "topo1",
-            "filename" => "topology"
-          }]
-        }
-      end
+    # give user a template to get started
+    def empty_topology
+      {
+        'id' => @topo_name || 'topo1',
+        'name' => @topo_name || 'topo1',
+        'chef_environment' => '_default',
+        'tags' => [],
+        'strategy' => 'via_cookbook',
+        'strategy_data' => default_strategy_data,
+        'nodes' => @node_names.length == 0 ? [empty_node('node1')] : []
+      }
+    end
 
-      def empty_node(name)
-        {
-          "name" => name,
-          "run_list" => [],
-          "ssh_host" => name,
-          "ssh_port" => "22",
-          "normal" => {},
-          "tags" => []
-        }
-      end
+    def default_strategy_data
+      {
+        'cookbook' =>  @topo_name || 'topo1',
+        'filename' => 'topology'
+      }
+    end
 
-      # get actual node properties for export
-      def node_export (node_name)
-
-        node_data = {}
-
-        begin
-          node = Chef::Node.load(node_name)
-          
-          node_data['name'] = node.name
-          node_data['tags'] = node.tags
-          node_data['chef_environment'] = node.chef_environment
-          node_data['run_list'] = node.run_list
-
-          pri = config[:min_priority]
-          node_data['default'] = node.default if pri == "default"
-          node_data['normal'] = node.normal if pri == "default" || pri == "normal"
-          node_data['override'] = node.override
-          
-        rescue Net::HTTPServerException => e
-          raise unless e.to_s =~ /^404/
-          node_data = empty_node(node_name)
-        end
-        
-        node_data
-      end
+    def empty_node(name)
+      {
+        'name' => name,
+        'run_list' => [],
+        'ssh_host' => name,
+        'ssh_port' => '22',
+        'normal' => {},
+        'tags' => []
+      }
+    end
+
+    # get actual node properties for export
+    def node_export(node_name)
+      load_node_data(node_name, config[:min_priority])
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^404/
+      empty_node(node_name)
+    end
 
-      # merge hash properties with the actual node properties
-      def merge_node_properties!(nodes, node_name)
+    # put node details in node array, overwriting existing details
+    def update_nodes!(nodes)
+      @node_names.each do |node_name|
         # find out if the node is already in the array
-        found = nodes.index{|n| n["name"] == node_name }
+        found = nodes.index { |n| n['name'] == node_name }
         if found.nil?
           nodes.push(node_export(node_name))
         else
           nodes[found] = node_export(node_name)
         end
       end
-
-      include Chef::Knife::TopologyHelper
-
     end
   end
 end

data/lib/chef/knife/topo_import.rb

@@ -17,92 +17,78 @@
 #
 
 require 'chef/knife'
+require 'chef/knife/cookbook_create'
+require 'chef/knife/topo/command_helper'
+require 'chef/knife/topo/loader'
 
-require_relative 'topology_helper'
-require_relative 'topo_cookbook_create'
+module KnifeTopo
+  # knife topo import
+  class TopoImport < Chef::Knife
+    deps do
+      require 'chef/knife/topo/processor'
+    end
 
-class Chef
-  class Knife
-    class TopoImport < Chef::Knife
+    banner 'knife topo import [ TOPOLOGY_FILE ] (options)'
 
-      deps do
-        Chef::Knife::TopoCookbookCreate.load_deps
-      end
+    option(
+      :data_bag,
+      short: '-D DATA_BAG',
+      long: '--data-bag DATA_BAG',
+      description: 'The data bag to store the topologies in'
+    )
+    option(
+      :input_format,
+      long: '--input-format FORMAT',
+      description: 'The format to convert from (e.g. topo_v1)'
+    )
 
-      banner "knife topo import [ TOPOLOGY_FILE [ TOPOLOGY ... ]] (options)"
-      
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag to store the topologies in"
+    # Make called command options available
+    orig_opts = KnifeTopo::TopoImport.options
+    self.options = Chef::Knife::CookbookCreate.options.merge(orig_opts)
 
-      # Make called command options available
-      self.options = Chef::Knife::TopoCookbookCreate.options.merge(self.options)
-      
-      def initialize (args)
-        super
-        @topo_cookbook_args = initialize_cmd_args(args, [ 'topo', 'cookbook', '', '' ])
+    include KnifeTopo::CommandHelper
+    include KnifeTopo::Loader
 
-        # All called commands need to accept union of options
-        Chef::Knife::TopoCookbookCreate.options = options
-      end
+    def initialize(args)
+      super
+      @args = args
+      @topo_file = @name_args[0] || 'topology.json'
+    end
 
-      def run
-        
-        # load data from the topologies file
-        topo_file = @name_args[0] || 'topology.json'
-        topologies = load_topologies(topo_file)
-        bag_name = topo_bag_name(config[:data_bag])
-        topo_names = @name_args[1..-1] if @name_args[1]
-        
-        # make sure the topology bag directory exists
-        path = File.join(topologies_path, bag_name)
-        FileUtils.mkdir_p(path)
+    def run
+      @topo = load_topo_from_file_or_exit(@topo_file, config[:input_format])
+      @processor = KnifeTopo::Processor.for_topo(@topo)
+      create_topo_bag_dir
+      import_topo
+    end
 
-        topologies.each do |topo_data|
-        
-          topo_name = topo_data['name'] || topo_data['id']
-          topo_data['id'] ||= topo_name
-          topo_data['name'] ||= topo_name
-            
-          if (!topo_name)
-            ui.error "Could not find a topology name - #{topo_file} does not appear to be a valid topology JSON file"
-            exit(1)
-          end
-          
-          # check against specific topology list
-          if topo_names
-            if topo_names.include?(topo_name)
-              topo_names.delete(topo_name)
-            else
-              next
-            end
-          end
-          
-          # write the databag for this topology
-          path = File.join(topologies_path, bag_name, topo_name  + '.json')
-          File.open(path,"w") do |f|
-            f.write(Chef::JSONCompat.to_json_pretty(topo_data))
-            f.close()
-            ui.info "Created topology data bag in  #{path}"
-          end
-          
-          # run topo cookbook to generate the cookbooks for this topology
-          @topo_cookbook_args[2] = topo_name
-          @topo_cookbook_args[3] = topo_file
-          run_cmd(Chef::Knife::TopoCookbookCreate, @topo_cookbook_args)
-          ui.info "Imported topology #{display_name(topo_data)}"
-          ui.info("Build information: " + topo_data['buildstamp']) if topo_data['buildstamp']
-       
-        end
-            
-        ui.info "Did not find topologies #{topo_names.join(', ')} in the topology json file"  if topo_names && topo_names.length > 0
-        ui.info "Import finished"
-        
+    def create_topo_bag_dir
+      # make sure the topology bag directory exists
+      path = File.join(topologies_path, topo_bag_name)
+      FileUtils.mkdir_p(path)
+    end
+
+    def import_topo
+      write_topo_to_file
+      do_create_artifacts
+
+      ui.info "Imported topology: #{@topo.display_info}"
+    end
+
+    def write_topo_to_file
+      path = File.join(topologies_path, topo_bag_name, @topo['name'] + '.json')
+      File.open(path, 'w') do |f|
+        f.write(Chef::JSONCompat.to_json_pretty(@topo.raw_data))
+        f.close
+        ui.info "Created topology data bag: #{path}"
       end
-      
-      include Chef::Knife::TopologyHelper
+    end
 
+    def do_create_artifacts
+      @processor.generate_artifacts(
+        'cmd_args' => @args,
+        'cmd' => self
+      )
     end
   end
 end

data/lib/chef/knife/topo_list.rb

@@ -17,36 +17,29 @@
 #
 
 require 'chef/knife'
-require_relative 'topology_helper'
+require 'chef/knife/topo/loader'
 
-class Chef
-  class Knife
-    class TopoList < Chef::Knife
-
-      deps do
-        require 'chef/data_bag'
-      end
-
-      banner "knife topo list (options)"
+module KnifeTopo
+  # knife topo list
+  class TopoList < Chef::Knife
+    deps do
+    end
 
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag the topologies are stored in"
- 
+    banner 'knife topo list (options)'
 
-      def run
+    option(
+      :data_bag,
+      short: '-D DATA_BAG',
+      long: '--data-bag DATA_BAG',
+      description: 'The data bag the topologies are stored in'
+    )
 
-        begin
-          topo_bag = topo_bag_name(config[:data_bag])
-          output(format_list_for_display(Chef::DataBag.load(topo_bag)))
-        rescue Net::HTTPServerException => e
-          raise unless e.to_s =~ /^404/
-        end
+    include KnifeTopo::Loader
 
-      end
-      
-      include Chef::Knife::TopologyHelper
+    def run
+      output(format_list_for_display(list_topo_bag))
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^404/
     end
   end
 end