fhcap-cli 0.3.0

data/lib/fhcap/provider.rb

@@ -0,0 +1,41 @@
+require 'thor'
+require 'fhcap/thor_base'
+
+module Fhcap
+  module CLI
+    class Provider < Fhcap::ThorBase
+
+      add_shared_option :verbose, :aliases => "-v", :desc => "Verbose output", :type => :boolean, :required => false, :default => false
+      add_shared_option :interactive, :aliases => "-i", :desc => "Interactive mode (Stops for input)", :type => :boolean, :required => false, :default => false
+      add_shared_option :name, :type => :string, :required => true, :desc => "Provider Name"
+      add_shared_option :type, :type => :string, :required => true, :desc => "Provider Type", :enum => %w{aws openstack}
+      add_shared_option :credentials, :type => :hash, :desc => "Provider specific credentials"
+
+      desc "add", "Add a provider"
+
+      shared_options :verbose, :name, :type, :credentials, :interactive
+
+      def add
+        require "fhcap/tasks/provider/add"
+        Tasks::Provider::Add.new(task_options(options.dup)).run
+      end
+
+      desc "remove", "Remove a provider"
+
+      shared_options :verbose, :name, :type
+
+      def remove
+        require "fhcap/tasks/provider/remove"
+        Tasks::Provider::Remove.new(task_options(options.dup)).run
+      end
+
+      desc "list", "List configured providers"
+
+      def list
+        require "fhcap/tasks/provider/list"
+        Tasks::Provider::List.new(task_options(options.dup)).run
+      end
+
+    end
+  end
+end

data/lib/fhcap/providers_helper.rb

@@ -0,0 +1,60 @@
+module Fhcap
+  module ProvidersHelper
+
+    def providers_config
+      config.exists? && config[:providers] ? config[:providers] : {}
+    end
+
+    def provider_names
+      providers_config.collect do |provider, cfg|
+        cfg.collect do |id, pcfg|
+          "#{provider}:#{id}"
+        end
+      end.flatten
+    end
+
+    def provider_type(id)
+      provider_type, provider_id = id.split(':')
+      provider_type
+    end
+
+    def provider_config(id)
+      provider_type, provider_id = id.split(':')
+      providers_config[provider_type.to_sym][provider_id.to_sym]
+    end
+
+    def provider_credentials(id)
+      provider_config(id)[:credentials]
+    end
+
+    def provider_regions(id)
+      provider_config(id)[:regions] || {}
+    end
+
+    def provider_availability_zones(id, region)
+      return [] unless region && provider_regions(id)[region.to_sym]
+      provider_regions(id)[region.to_sym][:availability_zones] || []
+    end
+
+    def provider_names_for(service)
+      providers_config.collect do |provider, cfg|
+        cfg.reject do |id, pcfg|
+          !pcfg[:provides] || !pcfg[:provides].include?(service)
+        end.collect do |id, pcfg|
+          "#{provider}:#{id}"
+        end
+      end.flatten
+    end
+
+    def provider_for(domain)
+      providers_config.collect do |provider, cfg|
+        cfg.reject do |id, pcfg|
+          !pcfg[:provides] || !pcfg[:provides].include?('dns') || !pcfg[:domains].include?(domain)
+        end.collect do |id, pcfg|
+          "#{provider}:#{id}"
+        end
+      end.flatten.first
+    end
+
+  end
+end

data/lib/fhcap/repo.rb

@@ -0,0 +1,52 @@
+require 'thor'
+require 'fhcap/thor_base'
+
+module Fhcap
+  module CLI
+    class Repo < Fhcap::ThorBase
+
+      add_shared_option :verbose, :aliases => "-v", :desc => "Verbose output", :type => :boolean, :required => false, :default => false
+      add_shared_option :name, :type => :string, :required => true, :desc => "Repo name i.e. fhcap-dev"
+      add_shared_option :interactive, :aliases => "-i", :desc => "Interactive mode (Stops for input)", :type => :boolean, :required => false, :default => false
+
+      desc "add", "Add an fhcap repo"
+
+      shared_options :verbose, :name, :interactive
+      method_option 'url', :type => :string, :desc => "Repo url i.e. git@github.com:fheng/fhcap-dev.git"
+      method_option 'clusters-dir', :type => :string, :default => 'clusters', :desc => "Directlory in repo where cluster configs are stored i.e. organisations"
+
+      def add
+        require "fhcap/tasks/repo/add"
+        Tasks::Repo::Add.new(task_options(options.dup)).run
+      end
+
+      desc "remove", "Remove an fhcap repo"
+
+      shared_options :verbose, :name
+
+      def remove
+        require "fhcap/tasks/repo/remove"
+        Tasks::Repo::Remove.new(task_options(options.dup)).run
+      end
+
+      desc "checkout", "Checkout a configured repo"
+
+      shared_options :verbose, :name
+      method_option 'git-ref', :type => :string, :desc => "fhcap git ref, can be a branch, tag or commit hash"
+      method_option 'remote', :type => :string, :default => 'origin', :desc => "Git remote to pull from"
+
+      def checkout
+        require 'fhcap/tasks/repo/checkout'
+        Tasks::Repo::Checkout.new(task_options(options.dup)).run
+      end
+
+      desc "list", "List configured repos"
+
+      def list
+        require 'fhcap/tasks/repo/list'
+        Tasks::Repo::List.new(task_options(options.dup)).run
+      end
+
+    end
+  end
+end

data/lib/fhcap/repos_helper.rb

@@ -0,0 +1,217 @@
+module Fhcap
+  module ReposHelper
+
+    def repos_config
+      config.exists? && config[:repos] ? config[:repos] : {}
+    end
+
+    def repos_dir
+      config[:repos_dir] || config.default_dir
+    end
+
+    def repo_dir(name)
+      name = name.to_sym
+      if repos_config[name]
+        File.join(repos_dir, name.to_s)
+      end
+    end
+
+    def repo_cfg(name)
+      name = name.to_sym
+      repos_config[name]
+    end
+
+    def repo_paths
+      repos_config.collect do |name, cfg|
+        repo_dir(name)
+      end
+    end
+
+    def repo_names
+      repos_config.collect do |name, cfg|
+        name.to_s
+      end
+    end
+
+    def repo_clusters_dir(name)
+      name = name.to_sym
+      if repos_config[name]
+        repos_config[name][:clusters_dir] || 'clusters'
+      end
+    end
+
+    def run_inside_repo_dir(repo_dir, cmd)
+      status = -1
+      thor.inside(repo_dir) do
+        thor.run(cmd, :capture => !@verbose)
+        status = $?.exitstatus
+      end
+      status == 0
+    end
+
+    def find_data_bag(data_bag_name)
+      find_repo_item('data_bags', data_bag_name).first
+    end
+
+    def find_data_bag_item(data_bag_name, data_bag_item)
+      find_repo_item('data_bags', data_bag_name, ensure_json_extension(data_bag_item)).first
+    end
+
+    def find_environment(environment)
+      find_repo_item('environments', ensure_json_extension(environment)).first
+    end
+
+    def find_role(role)
+      find_repo_item('roles', ensure_json_extension(role)).first
+    end
+
+    def find_cluster(name)
+      find_cluster_with_repo(name).first
+    end
+
+    def find_cluster_with_repo(name)
+      find_repo_item('clusters', ensure_json_extension(name)) || []
+    end
+
+    def find_cluster_pwds(name)
+      find_cluster_pwds_with_repo(name).first
+    end
+
+    def find_cluster_pwds_with_repo(name)
+      name = "#{name}_passwords"
+      find_repo_item('clusters', ensure_json_extension(name)) || []
+    end
+
+    def find_repo_item(*args)
+      repo_names.each do |repo|
+        repo_args = args.dup
+        repo_item_dir_method = :"repo_#{repo_args.first}_dir"
+        repo_args[0] = respond_to?(repo_item_dir_method) ? send(repo_item_dir_method, repo) : repo_args.first
+        item_path = File.join(repo_dir(repo), repo_args)
+        if Dir.exists?(item_path) || File.exists?(item_path)
+          return item_path, repo
+        end
+      end
+      nil
+    end
+
+    def repo_cookbook_paths(dir_query='cookbooks')
+      @repo_cookbook_paths = {} unless @repo_cookbook_paths
+      unless @repo_cookbook_paths[dir_query]
+        @repo_cookbook_paths[dir_query] = []
+        repo_paths.each do |repo_dir|
+          thor.inside(repo_dir) do
+            Dir.glob('*').each do |f|
+              if f && File.directory?(f) && f =~ /#{dir_query}/
+                @repo_cookbook_paths[dir_query] << File.join(repo_dir, f)
+              end
+            end
+          end
+        end
+      end
+      @repo_cookbook_paths[dir_query]
+    end
+
+    def get_cookbook_versions(options)
+      cookbook_versions = {}
+      get_cookbooks(options).each do |name|
+        version = get_cookbook_meta(name).version
+        cookbook_versions[name] = version
+        yield name, version if block_given?
+      end
+      cookbook_versions
+    end
+
+    def get_cookbooks(options, default=nil, paths=repo_cookbook_paths)
+      if options[:modified]
+        get_modified_cookbooks(options, paths)
+      else
+        options[:cookbooks] || (default || cookbook_loader(paths).cookbook_names)
+      end
+    end
+
+    def get_modified_cookbooks(options, paths=repo_cookbook_paths)
+      modified = []
+      cookbook_loader(paths).cookbook_names.each do |name|
+        cookbook_dir = cookbook_loader.cookbooks_by_name[name].root_dir
+        modified << name if modified?(cookbook_dir)
+      end
+      modified
+    end
+
+    def get_cookbook_meta(name, paths=repo_cookbook_paths)
+      cookbook_loader(paths).metadata[name]
+    end
+
+    def get_cookbook_deps(name, dependencies, options)
+      unless dependencies[name]
+        require_chef_deps
+        Dir.chdir(cookbook_loader.cookbooks_by_name[name].root_dir) do
+          ::Chef::Knife::Deps.load_deps
+          knife_deps = ::Chef::Knife::Deps.new(["."])
+          knife_deps.configure_chef
+          Chef::Config[:cookbook_path] = repo_cookbook_paths
+
+          entries = ::Chef::ChefFS::FileSystem.list(knife_deps.local_fs, ::Chef::ChefFS::FilePattern.new("/cookbooks/#{name}/."))
+          entries.each do |entry|
+            get_entry_dependencies(entry, dependencies, knife_deps, options)
+          end
+        end
+      end
+      dependencies
+    end
+
+    def get_entry_dependencies(entry, dependencies, knife_deps, options)
+      unless dependencies[entry.name]
+        cwd = Pathname.new(options[:cwd] || Dir.pwd)
+        dependencies[entry.name] = Pathname.new(entry.file_path).relative_path_from(cwd)
+        child_deps = knife_deps.get_dependencies(entry)
+        child_deps.each do |child|
+          child_entry = ::Chef::ChefFS::FileSystem.resolve_path(knife_deps.local_fs, child)
+          get_entry_dependencies(child_entry, dependencies, knife_deps, options)
+        end
+      end
+    end
+
+    def modified?(path, since='origin/master')
+      stat = Dir.chdir(path) do
+        `git diff #{since} -- #{path}`
+      end
+      !stat.empty?
+    end
+
+    def is_dirty?(file)
+      stat = Dir.chdir(File.dirname(file)) do
+        `git status #{file} --porcelain`
+      end
+      !stat.empty?
+    end
+
+    private
+
+    def cookbook_loader(paths=repo_cookbook_paths)
+      @cookbook_loader = {} unless @cookbook_loader
+      unless @cookbook_loader[paths]
+        require_chef_deps
+        @cookbook_loader[paths] = ::Chef::CookbookLoader.new(paths)
+        @cookbook_loader[paths].load_cookbooks
+      end
+      @cookbook_loader[paths]
+    end
+
+    def ensure_json_extension(item)
+      "#{item.split('.').first}.json"
+    end
+
+    def require_chef_deps
+      unless @chef_deps_loaded
+        require 'chef/knife'
+        require 'chef/knife/deps'
+        require 'chef/chef_fs/config'
+        require 'chef/cookbook_loader'
+        @chef_deps_loaded = true
+      end
+    end
+
+  end
+end

data/lib/fhcap/tasks/chef/chef_task_base.rb

@@ -0,0 +1,82 @@
+require 'fhcap/tasks/task_base'
+require 'chef'
+require 'chef/knife'
+
+module Fhcap
+  module Tasks
+    module Chef
+      class ChefTaskBase < TaskBase
+
+        def select_chef_server(environment, chef_server, fail_on_missing=true)
+          #ToDo Look at a better way of doing this rather than using a global variable
+          $selected_chef_server = {} unless $selected_chef_server
+          unless $selected_chef_server[environment]
+            if chef_server
+              $selected_chef_server[environment] = chef_server
+            else
+              chef_servers = chef_servers_for_environment(environment)
+              if chef_servers.empty?
+                exit_with_error("Unable to locate chef server for #{environment}") if fail_on_missing
+              elsif chef_servers.length == 1
+                $selected_chef_server[environment] = chef_servers.first
+              else
+                server = thor.ask("Multiple servers configured for environment '#{environment}'. Which one should be used?", {:limited_to => chef_servers})
+                $selected_chef_server[environment] = server
+              end
+            end
+          end
+          $selected_chef_server[environment]
+        end
+
+        def chef_servers_for_environment(environment)
+          chef_server_environments.collect do |server, environments|
+            server.to_s if environments.include? environment
+          end.compact
+        end
+
+        def chef_server_environments
+          unless @chef_server_environments
+            @chef_server_environments = {}
+            config[:knife].each do |name, cfg|
+              cmd = "environment list -F json"
+              resp = run_knife_cmd(cmd, name)
+              envs = JSON.parse(resp)
+              @chef_server_environments[name] = envs
+            end
+          end
+          @chef_server_environments
+        end
+
+        def knife_config_dir
+          config[:knife_dir] || File.join(config.default_dir, '.chef')
+        end
+
+        def knife_config_file_for(name)
+          File.join(knife_config_dir, "knife-#{name}.rb")
+        end
+
+        def run_knife_ssh_cmd(query, cmd, server, options)
+          user = options[:knife_user] || 'hadmin'
+          attr = options[:knife_attr] || 'cloud.public_ipv4'
+          knife_options = options[:knife_options]
+          run_knife_cmd("ssh \"#{query}\" \"#{cmd}\" -x #{user} -a #{attr} #{knife_options}", server, false)
+        end
+
+        def run_knife_cmd(cmd, server, capture=true)
+          cmd = "cd #{File.expand_path("..", knife_config_dir)} && knife #{cmd} -c #{knife_config_file_for(server)}"
+          resp = thor.run(cmd, :capture => capture)
+          thor.say resp if verbose && !capture
+          resp
+        end
+
+        def run_chef_client_cmd(cmd, server, capture=false)
+          cmd = "cd #{File.expand_path("..", knife_config_dir)} && chef-client -z #{cmd} -c #{knife_config_file_for(server)}"
+          resp = thor.run(cmd, :capture => capture)
+          thor.say resp if verbose && !capture
+          resp
+        end
+
+      end
+    end
+  end
+end