knife-topo 1.1.2 → 2.0.1

data/lib/chef/knife/topo_cookbook_upload.rb

@@ -17,71 +17,57 @@
 #
 
 require 'chef/knife'
-require_relative 'topology_helper'
+require 'chef/knife/topo/loader'
+require 'chef/knife/cookbook_upload' unless defined? Chef::Knife::CookbookUpload
 
-## only require if not already defined (to prevent warning about already initialized constants)
-require 'chef/knife/cookbook_upload' if !defined? Chef::Knife::CookbookUpload
+module KnifeTopo
+  # knife topo cookbook upload
+  class TopoCookbookUpload < Chef::Knife
+    deps do
+      require 'chef/knife/topo/processor'
+    end
 
-class Chef
-  class Knife
-    class TopoCookbookUpload < Chef::Knife
-      
-      deps do
-        Chef::Knife::CookbookUpload.load_deps
-      end
+    banner 'knife topo cookbook upload TOPOLOGY (options)'
 
-      banner "knife topo cookbook upload [ TOPOLOGY ] (options)"
+    option(
+      :data_bag,
+      short: '-D DATA_BAG',
+      long: '--data-bag DATA_BAG',
+      description: 'The data bag the topologies are stored in'
+    )
 
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag the topologies are stored in"
+    # Make called command options available
+    self.options = (Chef::Knife::CookbookUpload.options).merge(
+      TopoCookbookUpload.options)
 
-      # Make called command options available
-      self.options = (Chef::Knife::CookbookUpload.options).merge(self.options)
+    include KnifeTopo::Loader
 
-      def initialize (args)
-        super
-        @topo_upload_args  = initialize_cmd_args(args, [ 'cookbook', 'upload' ])
+    def initialize(args)
+      super
+      @args  = args
 
-        # All called commands need to accept union of options
-        Chef::Knife::CookbookUpload.options = options
-      end
-      
-      def run
-        if !@name_args[0]
-          show_usage
-          ui.fatal("You must specify the name of a topology")
-          exit 1
-        end
+      # All called commands need to accept union of options
+      Chef::Knife::CookbookUpload.options = options
+    end
 
-        bag_name = topo_bag_name(config[:data_bag])
-        topo_name = @name_args[0]
+    def run
+      validate_args
 
-        # Load the topology data 
-        unless topo = load_from_file(bag_name, topo_name )
-          ui.fatal("Topology file #{topologies_path}/#{bag_name}/#{topo_name}.json not found - use 'knife topo import' first")
-          exit(1)
-        end
-        
-        # Run cookbook upload command on the topology cookbooks
-        cookbook_names = []
-        if topo['cookbook_attributes'] && topo['cookbook_attributes'].length > 0
-          argPos = 2
-          topo['cookbook_attributes'].each do |entry|
-            cookbook_name = entry['cookbook']
-            @topo_upload_args[argPos] = cookbook_name unless cookbook_names.include?(cookbook_name)
-            cookbook_names << cookbook_name  
-            argPos += 1
-          end
-          run_cmd(Chef::Knife::CookbookUpload, @topo_upload_args)
-        else
-          ui.info("No cookbooks found for topology #{display_name(topo)}")
-        end                      
-      end
+      # Load the topology data
+      @topo = load_local_topo_or_exit(@topo_name)
 
-      include Chef::Knife::TopologyHelper
+      # Run cookbook upload command on the topology cookbook
+      @processor = KnifeTopo::Processor.for_topo(@topo)
+      @processor.upload_artifacts('cmd' => self, 'cmd_args' => @args)
+    end
 
+    def validate_args
+      unless @name_args[0]
+        show_usage
+        ui.fatal('You must specify the name of a topology')
+        exit 1
+      end
+      @topo_name = @name_args[0]
     end
   end
 end

data/lib/chef/knife/topo_create.rb

@@ -17,146 +17,134 @@
 #
 
 require 'chef/knife'
-require_relative 'topology_helper'
-require_relative 'topo_bootstrap'
-require_relative 'topo_cookbook_upload'
-
-class Chef
-  class Knife
-    class TopoCreate < Chef::Knife
-      
-      deps do
-        Chef::Knife::TopoCookbookUpload.load_deps
-        Chef::Knife::Bootstrap.load_deps
-      end
+require 'chef/knife/topo_bootstrap'
+require 'chef/knife/cookbook_upload' unless defined? Chef::Knife::CookbookUpload
+require 'chef/knife/topo/loader'
+require 'chef/knife/topo/command_helper'
+require 'chef/knife/topo/node_update_helper'
 
-      banner "knife topo create TOPOLOGY (options)"
-
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag the topologies are stored in"
-
-      option :bootstrap,
-      :long => "--bootstrap",
-      :description => "Whether to bootstrap newly created nodes",
-      :boolean => true
-
-      option :disable_upload,
-      :long => "--disable-upload",
-      :description => "Do not upload topo cookbooks",
-      :boolean => true
-      
-      option :overwrite,
-      :long => "--overwrite",
-      :description => "Whether to overwrite existing nodes",
-      :boolean => true
-            
-      # Make called command options available
-      opts = self.options
-      self.options = (Chef::Knife::Bootstrap.options).merge(Chef::Knife::TopoCookbookUpload.options)
-      self.options.merge!(opts)
-
-      def initialize (args)
-        super
-        @bootstrap_args  = initialize_cmd_args(args, [ 'bootstrap', '' ])
-        @topo_upload_args  = initialize_cmd_args(args, [ 'topo', 'cookbook', 'upload', @name_args[0] ])
-
-        # All called commands need to accept union of options
-        Chef::Knife::Bootstrap.options = options
-        Chef::Knife::TopoCookbookUpload.options = options
-      end
-      
-      def run
-        if !@name_args[0]
-          show_usage
-          ui.fatal("You must specify the name of a topology")
-          exit 1
-        end
+module KnifeTopo
+  # knife topo create
+  class TopoCreate < KnifeTopo::TopoBootstrap
+    deps do
+      require 'chef/knife/topo/processor'
+      KnifeTopo::TopoBootstrap.load_deps
+    end
 
-        bag_name = topo_bag_name(config[:data_bag])
-        topo_name = @name_args[0]
+    banner 'knife topo create TOPOLOGY (options)'
 
-        # Load the topology data & create the topology bag
-        unless topo = load_from_file(bag_name, topo_name )
-          ui.fatal("Topology file #{topologies_path}/#{bag_name}/#{topo_name}.json not found - use 'knife topo import' first")
-          exit(1)
-        end
-        @data_bag = create_bag(bag_name)
-        
-        # Add topology item to the data bag on the server
-        begin
-          topo.create
-         rescue Net::HTTPServerException => e
-          raise unless e.to_s =~ /^409/
-          msg = "Topology #{topo_name} already exists - do you want to update it"
-          msg = msg + " to version " + format_topo_version(topo) if topo['version']
-          ui.confirm(msg, true, false)
-          topo.save
-        end
+    option(
+      :bootstrap,
+      long: '--bootstrap',
+      description: 'Whether to bootstrap newly created nodes',
+      boolean: true
+    )
+
+    option(
+      :disable_upload,
+      long: '--disable-upload',
+      description: 'Do not upload topo cookbooks',
+      boolean: true
+    )
+
+    # Make called command options available
+    orig_opts = KnifeTopo::TopoCreate.options
+    upload_opts = Chef::Knife::CookbookUpload.options
+    merged_opts = (KnifeTopo::TopoBootstrap.options).merge(upload_opts)
+    self.options = merged_opts.merge(orig_opts)
+
+    include KnifeTopo::CommandHelper
+    include KnifeTopo::NodeUpdateHelper
+    include KnifeTopo::Loader
+
+    def initialize(args)
+      super
+      @args  = args
+    end
+
+    def bootstrap_msgs
+      msgs = super.dup
+      msgs[:existed] = 'Updated but did not bootstrap %{num} existing nodes '\
+      "[ %{list} ].\n Specify --overwrite to re-bootstrap existing nodes. \n"
+      msgs
+    end
+
+    def non_bootstrap_msgs
+      {
+        existed: 'Applied updates (if any) to %{num} nodes [ %{list} ]',
+        skipped_ssh: 'Unexpected error skipped_ssh',
+        skipped: 'Skipped %{num} nodes [ %{list} ] because they do not exist',
+        bootstrapped: 'Unexpected error bootstrapped',
+        failed: 'Unexpected error failed'
+      }
+    end
+
+    def run
+      validate_args
+      create_or_update_topo
+
+      # make sure env and cookbooks are in place
+      check_chef_env(@topo['chef_environment'])
+      upload_artifacts unless config[:disable_upload]
+      update_nodes
 
-        # make sure env and cookbooks are in place
-        check_chef_env(topo['chef_environment']) if topo['chef_environment']
-        upload_cookbooks(@topo_upload_args) if (!config[:disable_upload])  
-
-        # update any existing nodes
-        topo_hash = topo.raw_data
-        nodes = merge_topo_properties(topo_hash['nodes'], topo_hash)
-        config[:disable_editing] = true
-        
-        bootstrapped = []
-        updated = []
-        skipped = []
-        failed = [] 
-        
-        if nodes && nodes.length > 0
-                 
-          nodes.each do |node_data|
-            node_name = node_data['name']
-            
-            exists = resource_exists?("nodes/#{node_name}") 
-            if(node_data['ssh_host'] && config[:bootstrap] && (config[:overwrite] || !exists))
-              if run_bootstrap(node_data, @bootstrap_args, exists)
-                bootstrapped << node_name
-              else
-                failed << node_name
-              end
-            else
-              if(exists)
-                updated << node_name
-                node = update_node(node_data)                  
-              else
-                skipped << node_name
-              end
-            end
-          end
-  
-          ui.info("Topology #{display_name(topo_hash)} created, containing #{nodes.length} nodes")
-          ui.info("Build information: " + topo_hash['buildstamp']) if topo_hash['buildstamp']
-          
-          if(config[:bootstrap])
-            ui.info("Bootstrapped #{bootstrapped.length} nodes [ #{bootstrapped.join(', ')} ]")
-            if updated.length > 0
-              ui.info("Updated #{updated.length} nodes [ #{updated.join(', ')} ] because they already exist. " +
-                "Specify --overwrite to re-bootstrap existing nodes. " +
-                "If you are using Chef Vault, you may need to use --bootstrap-vault options in this case.")
-            end
-            ui.info("Skipped #{skipped.length} nodes [ #{skipped.join(', ')} ] because they had no ssh_host information") if skipped.length > 0
-          else
-            ui.info("Updated #{updated.length} nodes [ #{updated.join(', ')} ]")
-            ui.info("Skipped #{skipped.length} nodes [ #{skipped.join(', ')} ] because they do not exist") if skipped.length > 0
-          end
-          
-          ui.warn("#{failed.length} nodes [ #{failed.join(', ')} ] failed to bootstrap due to errors") if failed.length > 0
-               
+      report
+    end
+
+    def processor
+      @processor ||= KnifeTopo::Processor.for_topo(@topo)
+    end
+
+    def validate_args
+      super
+      @bootstrap = config[:bootstrap]
+      @msgs = @bootstrap ? bootstrap_msgs : non_bootstrap_msgs
+      config[:disable_editing] = true
+    end
+
+    def create_or_update_topo
+      # Load the topology data & create the topology bag
+      @topo = load_local_topo_or_exit(@topo_name)
+      create_topo_bag
+
+      # Add topology item to the data bag on the server
+      @topo.create
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^409/
+      confirm_and_update_topo
+    end
+
+    def update_nodes
+      nodes = processor.generate_nodes
+      nodes.each do |node_data|
+        bootstrap_or_update_node(node_data)
+      end
+    end
+
+    def confirm_and_update_topo
+      version = @topo.topo_version
+      to_version_str = " to version #{version}"
+      msg = "Topology #{@topo_name} already exists - do you want to " \
+        "update it#{to_version_str  if version}"
+      ui.confirm(msg, true, false)
+      @topo.save
+    end
+
+    def bootstrap_or_update_node(node_data)
+      node_name = node_data['name']
+      if @bootstrap
+        update_node(node_data) unless node_bootstrap(node_data)
+      else
+        if update_node(node_data)
+          @results[:existed] << node_name
         else
-          ui.info "No nodes found for topology #{display_name(topo_hash)}"
+          @results[:skipped] << node_name
         end
-             
       end
+    end
 
-      include Chef::Knife::TopologyHelper      
-
+    def upload_artifacts
+      processor.upload_artifacts('cmd' => self, 'cmd_args' => @args)
     end
   end
 end

data/lib/chef/knife/topo_delete.rb

@@ -17,80 +17,82 @@
 #
 
 require 'chef/knife'
-require_relative 'topology_helper'
+require 'chef/knife/topo/loader'
+require 'chef/knife/topo/command_helper'
 
-class Chef
-  class Knife
-    class TopoDelete < Chef::Knife
+module KnifeTopo
+  # knife topo delete
+  class TopoDelete < Chef::Knife
+    deps do
+      require 'chef/node'
+    end
+
+    banner 'knife topo delete TOPOLOGY (options)'
+
+    option(
+      :data_bag,
+      short: '-D DATA_BAG',
+      long: '--data-bag DATA_BAG',
+      description: 'The data bag the topologies are stored in'
+    )
 
-      deps do
-        require 'chef/data_bag'
+    include KnifeTopo::CommandHelper
+    include KnifeTopo::Loader
+
+    def run
+      validate_args
+      config[:disable_editing] = true
+
+      # remove each node
+      @topo = load_topo_from_server(@topo_name)
+      unless @topo
+        ui.info "Topology #{topo_bag_name}/#{@topo_name} does not " \
+          'exist on server'
+        exit(0)
       end
 
-      banner "knife topo delete TOPOLOGY (options)"
+      confirm_and_delete_nodes
+      delete_topo
+    end
 
-      option :data_bag,
-      :short => '-D DATA_BAG',
-      :long => "--data-bag DATA_BAG",
-      :description => "The data bag the topologies are stored in"
- 
+    def validate_args
+      unless @name_args[0]
+        show_usage
+        ui.fatal('You must specify the name of a topology')
+        exit 1
+      end
+      @topo_name = @name_args[0]
+    end
 
-      def run
+    def confirm_and_delete_nodes
+      confirm("Do you want to delete topology #{@topo_name} - " \
+        'this does not delete nodes')
+      @topo['nodes'].each do |node|
+        remove_node_from_topology(node['name'])
+      end if @topo['nodes']
+    end
+
+    def delete_topo
+      @topo.destroy(topo_bag_name, @topo_name)
+      ui.info "Deleted topology #{@topo_name}"
+    end
 
-        topo_bag = topo_bag_name(config[:data_bag])
-        @topo_name = @name_args[0]
-          
-        if @name_args.length == 1
-          
-          # remove each node
-          
-          unless topo = load_from_server(topo_bag, @topo_name)
-            ui.info "Topology #{topo_bag}/#{@topo_name} does not exist on server"
-            exit(0)
-          end
-          
-          confirm("Do you want to delete topology #{@topo_name} - this does not delete nodes")
-          
-          topo['nodes'].each do | node |
-            remove_node_from_topology(node['name'])
-          end if topo['nodes']
-          
-          # delete the data bag item
-          topo.destroy(topo_bag, @topo_name)
+    # Remove the topo name attribute from all nodes, so topo search
+    # knows they are not in the topology
+    def remove_node_from_topology(node_name)
+      # load then update and save the node
+      node = Chef::Node.load(node_name)
 
-          ui.info "Deleted topology #{@topo_name}"
-        else
-          show_usage
-          ui.fatal("You must specify a topology name")
-          exit 1
-        end
-       end
-       
-      # Remove the topo name attribute from all nodes, so topo search knows they are not in the topology
-      def remove_node_from_topology(node_name)
-      
-        config[:disable_editing] = true      
-        begin
-          
-          # load then update and save the node
-          node = Chef::Node.load(node_name)
-          
-          if node['topo'] && node['topo']['name'] == @topo_name
-            node.rm('topo','name') 
-            ui.info "Removing node #{node.name} from topology"
-            node.save
-          end
-  
-        rescue Net::HTTPServerException => e
-          raise unless e.to_s =~ /^404/
-          # Node has not been created
-        end
-        
-        return node
+      if node['topo'] && node['topo']['name'] == @topo_name
+        node.rm('topo', 'name')
+        ui.info "Removing node #{node.name} from topology"
+        node.save
       end
-      
-      include Chef::Knife::TopologyHelper
+      node
 
+    rescue Net::HTTPServerException => e
+      raise unless e.to_s =~ /^404/
+      # Node has not been created
     end
   end
-end
+end