chef-rundeck2 0.1.1

data/lib/chef-rundeck/auth.rb

@@ -0,0 +1,78 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength
+#
+# Gem Name:: chef-rundeck
+# Module:: Auth
+#
+# Copyright (C) 2016 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'chef-rundeck/config'
+require 'chef-rundeck/util'
+require 'digest'
+
+module ChefRunDeck
+  # => Authorization Module
+  module Auth
+    extend self
+
+    #############################
+    # =>    Authorization    <= #
+    #############################
+
+    # => This holds the Authorization State
+    attr_accessor :auth
+
+    def auth
+      # => Define Authorization
+      @auth ||= reset!
+    end
+
+    def reset!
+      # => Reset Authorization
+      @auth = { 'roles' => [] }
+    end
+
+    def parse(user = nil)
+      # => Try to Find the User and their Authorization
+      auth = Util.parse_json_config(Config.auth_file, false)
+      return reset! unless auth && auth[user]
+      @auth = auth[user]
+    end
+
+    def admin?
+      # => Check if a User is an Administrator
+      auth['roles'].any? { |x| x.casecmp('admin') == 0 }
+    end
+
+    def creator?(node)
+      # => Grab the Node-State Object
+      existing = State.find_state(node)
+      return false unless existing
+      # => Check if Auth User was the Node-State Creator
+      existing[:creator].to_s.casecmp(Config.query_params['auth_user'].to_s) == 0
+    end
+
+    # => Validate the User's Authentication Key ## TODO: Use this, passthrough from a RunDeck Option Field
+    def key?
+      # => We store a SHA512 Hex Digest of the Key
+      return false unless Config.query_params['auth_key']
+      Digest::SHA512.hexdigest(Config.query_params['auth_key']) == auth['auth_key']
+    end
+
+    # => TODO: Project-Based Validation
+    def project_admin?(project = nil)
+      return false unless project.is_a?(Array)
+      # => parse_auth.include?(user) && parse_auth[user]['roles'].any? { |r| ['admin', project].include? r.to_s.downcase }
+      auth['roles'].any? { |r| ['admin', project].include? r.to_s.downcase }
+    end
+
+    # => Role-Based Administration
+    def role_admin?(run_list = nil)
+      return false unless run_list.is_a?(Array)
+      run_list.empty? || auth['roles'].any? { |role| run_list.any? { |r| r =~ /role\[#{role}\]/i } }
+    end
+  end
+end

data/lib/chef-rundeck/chef.rb

@@ -0,0 +1,193 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength, MethodLength
+#
+# Gem Name:: chef-rundeck
+# Module:: Chef
+#
+# Copyright (C) 2016 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'chef-api'
+require 'chef-rundeck/config'
+
+module ChefRunDeck
+  # => This is the Chef module.  It interacts with the Chef server
+  module Chef # rubocop: disable ModuleLength
+    extend self
+    # => Include Modules
+    include ChefAPI::Resource
+
+    #########################
+    # =>     ChefAPI     <= #
+    #########################
+
+    def api_client
+      # => Configure a Chef API Client
+      ChefAPI.endpoint = Config.chef_api_endpoint
+      ChefAPI.client = Config.chef_api_client
+      ChefAPI.key = Config.chef_api_client_key
+    end
+
+    def admin_api_client
+      # => Configure an Administrative Chef API Client
+      ChefAPI.endpoint = Config.chef_api_endpoint
+      ChefAPI.client = Config.chef_api_admin
+      ChefAPI.key = Config.chef_api_admin_key
+    end
+
+    def reset!
+      # => Reset the Chef API Configuration
+      ChefAPI.reset!
+      # => Clear Transient Configuration
+      Config.clear(:rundeck)
+    end
+
+    # => Get Node
+    def get_node(node, casecomp = false)
+      node = Node.list.find { |n| n =~ /^#{node}$/i } if casecomp
+      return false unless Node.exists?(node)
+      Node.fetch(node)
+    end
+
+    # => Return Array List of Nodes
+    def list
+      Node.list
+    end
+
+    # => Return a Node's Run List
+    def run_list(node)
+      return [] unless Node.exists?(node)
+      Node.fetch(node).run_list
+    end
+
+    # => Delete a Node Object
+    def delete(node)
+      # => Make sure the Node Exists
+      return 'Node not found on Chef Server' unless Node.exists?(node)
+
+      # => Initialize the Admin API Client Settings
+      admin_api_client
+
+      # => Delete the Client & Node Object
+      Client.delete(node)
+      Node.delete(node)
+      'Client/Node Deleted from Chef Server'
+    end
+
+    #############################
+    # =>  Resource Provider  <= #
+    #############################
+
+    #
+    # => Try to Parse Project-Specific Settings
+    #
+    def project_settings(project)
+      settings = Util.parse_json_config(Config.projects_file, false)
+      return {} unless settings && settings[project]
+      settings[project]
+    end
+
+    #
+    # => Construct Query-Specific Configuration
+    #
+    def transient_settings # rubocop: disable AbcSize
+      # => Initialize any Project-Specific Settings
+      project = project_settings(Config.query_params['project'])
+
+      # => Build the Configuration
+      cfg = {}
+      cfg[:username] = Config.query_params['username'] || project['username'] || Config.rd_node_username
+      cfg[:pattern] = Config.query_params['pattern'] || project['pattern'] || '*:*'
+      cfg[:extras] = Util.serialize_csv(Config.query_params['extras']) || project['extras']
+
+      # => Make the Settings Available via the Config Object
+      Config.add(rundeck: cfg)
+    end
+
+    #
+    # => Base Search Filter Definition
+    #
+    def default_search_filter
+      {
+        name: ['name'],
+        kernel_machine: ['kernel', 'machine'],
+        kernel_os: ['kernel', 'os'],
+        fqdn: ['fqdn'],
+        run_list: ['run_list'],
+        roles: ['roles'],
+        recipes: ['recipes'],
+        chef_environment: ['chef_environment'],
+        platform: ['platform'],
+        platform_version: ['platform_version'],
+        tags: ['tags'],
+        hostname: ['hostname']
+      }
+    end
+
+    #
+    # => Parse Additional Filter Elements
+    #
+    # => Default Elements can be removed by passing them in here as null or empty
+    #
+    def search_filter_additions
+      attribs = {}
+      Array(Config.rundeck[:extras]).each do |attrib|
+        attribs[attrib.to_sym] = [attrib]
+      end
+      # => Return the Custom Filter Additions Hash
+      attribs
+    end
+
+    #
+    # => Construct the Search Filter
+    #
+    def search_filter
+      # => Merge the Default Filter with Additions
+      default_search_filter.merge(search_filter_additions).reject { |_k, v| v.nil? || String(v).empty? }
+    end
+
+    #
+    # => Define Extra Attributes for Resource Return
+    #
+    def custom_attributes(node)
+      attribs = {}
+      Array(Config.rundeck[:extras]).each do |attrib|
+        attribs[attrib.to_sym] = node[attrib].inspect
+      end
+      # => Return the Custom Attributes Hash
+      attribs
+    end
+
+    def search(pattern = '*:*') # rubocop: disable AbcSize
+      # => Initialize the Configuration
+      transient_settings
+
+      # => Pull in the Pattern
+      pattern = Config.rundeck[:pattern]
+
+      # => Execute the Chef Search
+      result = PartialSearch.query(:node, search_filter, pattern, start: 0)
+
+      # => Custom-Tailor the Resulting Objects
+      result.rows.collect do |node|
+        {
+          nodename: node['name'],
+          hostname: node['fqdn'] || node['hostname'],
+          osArch: node['kernel_machine'],
+          osFamily: node['platform'],
+          osName: node['platform'],
+          osVersion: node['platform_version'],
+          description: node['name'],
+          roles: node['roles'].join(','),
+          recipes: node['recipes'].join(','),
+          tags: [node['roles'], node['recipes'], node['chef_environment'], node['tags']].flatten.join(','),
+          environment: node['chef_environment'],
+          editUrl: ::File.join(Config.chef_api_endpoint, 'nodes', node['name']),
+          username: Config.rundeck[:username]
+        }.merge(custom_attributes(node)).reject { |_k, v| v.nil? || String(v).empty? }
+      end
+    end
+  end
+end

data/lib/chef-rundeck/cli.rb

@@ -0,0 +1,132 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength, MethodLength, AbcSize
+#
+# Gem Name:: chef-rundeck
+# ChefRunDeck:: CLI
+#
+# Copyright (C) 2016 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'mixlib/cli'
+require 'chef-rundeck/config'
+require 'chef-rundeck/util'
+
+module ChefRunDeck
+  #
+  # => Chef-RunDeck Launcher
+  #
+  module CLI
+    extend self
+    #
+    # => Options Parser
+    #
+    class Options
+      # => Mix-In the CLI Option Parser
+      include Mixlib::CLI
+
+      option :cache_timeout,
+             short: '-t CACHE_TIMEOUT',
+             long: '--timeout CACHE_TIMEOUT',
+             description: 'Sets the cache timeout in seconds for API query response data.'
+
+      option :config_file,
+             short: '-c CONFIG',
+             long: '--config CONFIG',
+             description: 'The configuration file to use, as opposed to command-line parameters (optional)'
+
+      option :auth_file,
+             short: '-a CONFIG',
+             long: '--auth-json CONFIG',
+             description: "The JSON file containing authorization information (Default: #{Config.auth_file})"
+
+      option :state_file,
+             short: '-s STATE',
+             long: '--state-json STATE',
+             description: "The JSON file containing node state & auditing information (Default: #{Config.state_file})"
+
+      option :chef_api_endpoint,
+             short: '-ce ENDPOINT',
+             long: '--chef-api-endpoint ENDPOINT',
+             description: 'The Chef API Endpoint URL (e.g. https://api.chef.io/)'
+
+      option :chef_api_client,
+             short: '-ccn CLIENT_NAME',
+             long: '--chef-api-client-name CLIENT_NAME',
+             description: 'The name of the Non-Privileged API Client'
+
+      option :chef_api_client_key,
+             short: '-cck CLIENT_KEY',
+             long: '--chef-api-client-key CLIENT_KEY',
+             description: 'The path to the Non-Privileged API Client Keyfile'
+
+      option :chef_api_admin,
+             short: '-can ADMIN_NAME',
+             long: '--chef-api-admin-name ADMIN_NAME',
+             description: 'The name of the Administratively-Privileged API Client'
+
+      option :chef_api_admin_key,
+             short: '-cak ADMIN_KEY',
+             long: '--chef-api-admin-key ADMIN_KEY',
+             description: 'The path to the Administratively-Privileged API Client Keyfile'
+
+      option :rd_node_username,
+             short: '-u USERNAME',
+             long: '--rundeck-node-user USERNAME',
+             description: 'The name of the User Account to place into the RunDeck Resource Provider'
+
+      option :bind,
+             short: '-b HOST',
+             long: '--bind HOST',
+             description: "Listen on Interface or IP (Default: #{Config.bind})"
+
+      option :port,
+             short: '-p PORT',
+             long: '--port PORT',
+             description: "The port to run on. (Default: #{Config.port})"
+
+      option :environment,
+             short: '-e ENV',
+             long: '--env ENV',
+             description: 'Sets the environment for chef-rundeck to execute under. Use "development" for more logging.',
+             default: 'production'
+    end
+
+    # => Launch the Application
+    def run(argv = ARGV)
+      # => Parse CLI Configuration
+      cli = Options.new
+      cli.parse_options(argv)
+
+      # => Parse JSON Config File (If Specified & Exists)
+      json_config = Util.parse_json_config(cli.config[:config_file])
+
+      # => Grab the Default Values
+      default = ChefRunDeck::Config.options
+
+      # => Merge Configuration (JSON File Wins)
+      config = [default, json_config, cli.config].compact.reduce(:merge)
+
+      # => Apply Configuration
+      ChefRunDeck::Config.setup do |cfg|
+        cfg.config_file         = config[:config_file]
+        cfg.cache_timeout       = config[:cache_timeout].to_i
+        cfg.bind                = config[:bind]
+        cfg.port                = config[:port]
+        cfg.auth_file           = config[:auth_file]
+        cfg.state_file          = config[:state_file]
+        cfg.environment         = config[:environment].to_sym
+        cfg.chef_api_endpoint   = config[:chef_api_endpoint]
+        cfg.chef_api_client     = config[:chef_api_client]
+        cfg.chef_api_client_key = config[:chef_api_client_key]
+        cfg.chef_api_admin      = config[:chef_api_admin]
+        cfg.chef_api_admin_key  = config[:chef_api_admin_key]
+        cfg.rd_node_username    = config[:rd_node_username]
+      end
+
+      # => Launch the API
+      ChefRunDeck::API.run!
+    end
+  end
+end

data/lib/chef-rundeck/config.rb

@@ -0,0 +1,100 @@
+# Encoding: UTF-8
+#
+# Gem Name:: chef-rundeck
+# ChefRunDeck:: Config
+#
+# Copyright (C) 2016 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'chef-rundeck/helpers/configuration'
+require 'pathname'
+
+module ChefRunDeck
+  # => This is the Configuration module.
+  module Config
+    extend self
+    extend Configuration
+
+    # => Gem Root Directory
+    define_setting :root, Pathname.new(File.expand_path('../../../', __FILE__))
+
+    # => My Name
+    define_setting :author, 'Brian Dwyer - Intelligent Digital Services'
+
+    # => Application Environment
+    define_setting :environment, :production
+
+    # => Sinatra Configuration
+    define_setting :port, '9125'
+    define_setting :bind, 'localhost'
+    define_setting :cache_timeout, 30
+
+    # => Config File
+    define_setting :config_file, File.join(root, 'config', 'config.json')
+
+    # => Authentication File
+    define_setting :auth_file, File.join(root, 'config', 'auth.json')
+
+    # => State File
+    define_setting :state_file, File.join(root, 'config', 'state.json')
+
+    # => Project Configuration File
+    define_setting :projects_file, File.join(root, 'config', 'projects.json')
+
+    #
+    # => Chef API Configuration
+    #
+    # => Chef Endpoint
+    define_setting :chef_api_endpoint, 'https://api.chef.io'
+
+    # => Unprivileged Client
+    define_setting :chef_api_client # => Username
+    define_setting :chef_api_client_key # => Path to Key
+
+    # => Administratively-Privileged Client
+    define_setting :chef_api_admin # => Username
+    define_setting :chef_api_admin_key # => Path to Key
+
+    #
+    # => RunDeck Node Resource Configuration
+    #
+    # => Default Username (nil)
+    define_setting :rd_node_username, nil
+
+    #
+    # => Facilitate Dynamic Addition of Configuration Values
+    #
+    # => @return [class_variable]
+    #
+    def add(config = {})
+      config.each do |key, value|
+        define_setting key.to_sym, value
+      end
+    end
+
+    #
+    # => Facilitate Dynamic Removal of Configuration Values
+    #
+    # => @return nil
+    #
+    def clear(config)
+      Array(config).each do |setting|
+        delete_setting setting
+      end
+    end
+
+    #
+    # => List the Configurable Keys as a Hash
+    #
+    # @return [Hash]
+    #
+    def options
+      map = ChefRunDeck::Config.class_variables.map do |key|
+        [key.to_s.tr('@', '').to_sym, class_variable_get(:"#{key}")]
+      end
+      Hash[map]
+    end
+  end
+end

data/lib/chef-rundeck/helpers/configuration.rb

@@ -0,0 +1,57 @@
+# Encoding: UTF-8
+#
+# Gem Name:: chef-rundeck
+# Helper:: Configuration
+#
+# Author: Eli Fatsi - https://www.viget.com/articles/easy-gem-configuration-variables-with-defaults
+# Contributor: Brian Dwyer - Intelligent Digital Services
+#
+
+# => Configuration Helper Module
+module Configuration
+  #
+  # => Provides a method to configure an Application
+  # => Example:
+  #      ChefRunDeck::Config.setup do |cfg|
+  #        cfg.config_file = 'abc.json'
+  #        cfg.app_name = 'GemBase'
+  #      end
+  #
+  def setup
+    yield self
+  end
+
+  def define_setting(name, default = nil)
+    class_variable_set("@@#{name}", default)
+
+    define_class_method "#{name}=" do |value|
+      class_variable_set("@@#{name}", value)
+    end
+
+    define_class_method name do
+      class_variable_get("@@#{name}")
+    end
+  end
+
+  def delete_setting(name)
+    remove_class_variable("@@#{name}")
+
+    delete_class_method(name)
+  rescue NameError # => Handle Non-Existent Settings
+    return
+  end
+
+  private
+
+  def define_class_method(name, &block)
+    (class << self; self; end).instance_eval do
+      define_method name, &block
+    end
+  end
+
+  def delete_class_method(name)
+    (class << self; self; end).instance_eval do
+      undef_method name
+    end
+  end
+end

data/lib/chef-rundeck/state.rb

@@ -0,0 +1,86 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength
+#
+# Gem Name:: chef-rundeck
+# ChefRunDeck:: CLI
+#
+# Copyright (C) 2016 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'chef-rundeck/config'
+require 'chef-rundeck/util'
+
+module ChefRunDeck
+  # => This is the State controller.  It manages State information
+  module State
+    extend self
+
+    ##############################
+    # =>   State Operations   <= #
+    ##############################
+
+    attr_accessor :state
+
+    def state
+      @state ||= Util.parse_json_config(Config.state_file) || []
+    end
+
+    def find_state(node)
+      state.detect { |h| h[:name].casecmp(node) == 0 }
+    end
+
+    def update_state(hash) # rubocop: disable AbcSize
+      # => Check if Node Already Exists
+      # => existing = state.detect { |h| h[:name].casecmp(hash[:name]) == 0 }
+      existing = find_state(hash[:name])
+      if existing # => Update the Existing Node
+        state.delete(existing)
+        audit_string = [DateTime.now, hash[:creator]].join(' - ')
+        existing[:last_modified] = existing[:last_modified].is_a?(Array) ? existing[:last_modified].take(5).unshift(audit_string) : [audit_string]
+        hash = existing
+      end
+
+      # => Update the State
+      state.push(hash)
+
+      # => Write Out the Updated State
+      write_state
+    end
+
+    # => Add Node to the State
+    def add_state(node, user, params)
+      # => Create a Node-State Object
+      (n = {}) && (n[:name] = node)
+      n[:created] = DateTime.now
+      n[:creator] = user
+      n[:type] = params['type'] if params['type']
+      # => Build the Updated State
+      update_state(n)
+      # => Return the Added Node
+      find_state(node)
+    end
+
+    # => Remove Node from the State
+    def delete_state(node)
+      # => Find the Node
+      existing = find_state(node)
+      return 'Node not present in state' unless existing
+      # => Delete the Node from State
+      state.delete(existing)
+      # => Write Out the Updated State
+      write_state
+      # => Return the Deleted Node
+      existing
+    end
+
+    def write_state
+      # => Sort & Unique State
+      state.sort_by! { |h| h[:name].downcase }.uniq!
+
+      # => Write Out the Updated State
+      Util.write_json_config(Config.state_file, state)
+    end
+  end
+end

data/lib/chef-rundeck/util.rb

@@ -0,0 +1,64 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength
+#
+# Gem Name:: chef-rundeck
+# ChefRunDeck:: Util
+#
+# Copyright (C) 2016 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'json'
+
+module ChefRunDeck
+  # => Utility Methods
+  module Util
+    extend self
+
+    ########################
+    # =>    File I/O    <= #
+    ########################
+
+    # => Define JSON Parser
+    def parse_json_config(file = nil, symbolize = true)
+      return unless file && ::File.exist?(file.to_s)
+      begin
+        ::JSON.parse(::File.read(file.to_s), symbolize_names: symbolize)
+      rescue JSON::ParserError
+        return
+      end
+    end
+
+    # => Define JSON Writer
+    def write_json_config(file, object)
+      return unless file && object
+      begin
+        File.open(file, 'w') { |f| f.write(JSON.pretty_generate(object)) }
+      end
+    end
+
+    #############################
+    # =>    Serialization    <= #
+    #############################
+
+    def serialize(response)
+      # => Serialize Object into JSON Array
+      JSON.pretty_generate(response.map(&:name).sort_by(&:downcase))
+    end
+
+    def serialize_csv(csv)
+      # => Serialize a CSV String into an Array
+      return unless csv && csv.is_a?(String)
+      csv.split(',')
+    end
+
+    def serialize_revisions(branches, tags)
+      # => Serialize Branches/Tags into JSON Array
+      # => Branches = String, Tags = Key/Value
+      branches = branches.map(&:name).sort_by(&:downcase)
+      tags = tags.map(&:name).sort_by(&:downcase).reverse.map { |tag| { name: "Tag: #{tag}", value: tag } }
+      JSON.pretty_generate(branches + tags)
+    end
+  end
+end