j-enc 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8fb70746bbb43bcc52ad7eff52488f41dd45222
+  data.tar.gz: 0582985c08fe3ab505572beac8b80bc5f3c94b06
+SHA512:
+  metadata.gz: 0a67465a92406e9a4aefa32180d1f4f8cdcc975baa01e1d42f03b13aedff2b46e0f76a58a4e6ff1b86b8896d2c83022436d6e4eb6dde564c9f644546d536a02d
+  data.tar.gz: f7c3f72d7ca574f5f5a932b4a448d06d7a4e7d26040a0f710fcdef43a565fbe480369c15ed2e2f97b87979783803954d1460a80622e4ad3ce4bfe9686ab4e705

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+binstubs

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in j-enc.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jestin Woods
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Collins::Enc
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'j-enc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install j-enc
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/j-enc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/j-enc

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'enc'
+rescue LoadError
+  unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+    $: << File.dirname(__FILE__) + '/../lib'
+  end
+  require 'enc'
+end
+
+Enc.run(ARGV)

data/j-enc.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'enc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "j-enc"
+  spec.version       = Enc::VERSION
+  spec.authors       = ["Jestin Woods"]
+  spec.email         = ["jestin.woods@jivesoftware.com"]
+  spec.summary       = %q{Puppet ENC using Collins.}
+  spec.description   = %q{Puppet ENC using Collins.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "webmock", "~> 1.20"
+  spec.add_development_dependency "factory_girl", "~> 4.5"
+
+  spec.add_runtime_dependency "collins_client", "~> 0.2"
+end

data/j-enc.iml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="CompassSettings">
+    <option name="compassSupportEnabled" value="true" />
+  </component>
+  <component name="FacetManager">
+    <facet type="gem" name="Ruby Gem">
+      <configuration>
+        <option name="GEM_APP_ROOT_PATH" value="$MODULE_DIR$" />
+        <option name="GEM_APP_TEST_PATH" value="" />
+        <option name="GEM_APP_LIB_PATH" value="" />
+      </configuration>
+    </facet>
+  </component>
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="RVM: ruby-2.0.0-p247" jdkType="RUBY_SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v1.7.4, RVM: ruby-2.0.0-p247) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rake (v10.3.2, RVM: ruby-2.0.0-p247) [gem]" level="application" />
+  </component>
+</module>
+

data/lib/enc/builder.rb

@@ -0,0 +1,28 @@
+module Enc
+  class Builder
+    def initialize(asset)
+      @asset = asset
+    end
+
+    def to_yaml
+      return String.new.to_yaml unless @asset.uses_enc?
+      output = {'parameters' => {'deployment_environment' => @asset.get_deployment_environment,
+                                 'datacenter'             => @asset.get_datacenter,
+                                 'roles'                  => @asset.get_roles}}
+
+      # Do not require the puppet environment until we upgrade to puppet 3.x.
+      # output[:environment] => @asset.get_puppet_environment
+
+      # We do this to satisfy the current requirement to have a roleN for each role, where N is the sorted index of the
+      # role list.
+      @asset.get_roles_by_index.each do |index, role|
+        output['parameters']['role' + (index + 1).to_s] = role
+      end
+
+      # It's not strictly necessary, but nice to have the $collins parameter at the end of the output.
+      output['parameters']['collins'] = @asset.get_flattened_attributes
+      output.to_yaml
+    end
+
+  end
+end

data/lib/enc/cache/exceptions.rb

@@ -0,0 +1,6 @@
+module Enc
+  module Cache
+    class CacheDoesNotExist < Exception; end
+    class UnableToCreateCacheDirectory < Exception; end
+  end
+end

data/lib/enc/cache/node_cache.rb

@@ -0,0 +1,57 @@
+module Enc
+  module Cache
+    class NodeCache
+      include Enc::Utils::Logging
+
+      def initialize(config)
+        ensure_cache_dir(config.get('jive_enc_cache_dir'))
+      end
+
+      def exists?(hostname)
+        logger.debug("Checking to see if cache file #{cache_path(hostname)} exists")
+        File.exist?(cache_path(hostname))
+      end
+
+      def read(hostname)
+        logger.debug("Attempting to read cache #{cache_path(hostname)}")
+        begin
+          File.open(cache_path(hostname), 'r') { |file| Marshal.load(file.read)}
+        rescue Errno::ENOENT
+          logger.error("The node #{hostname} does not exist in the cache.")
+          raise CacheDoesNotExist, "The node #{hostname} does not exist in the cache."
+        end
+      end
+
+      def write(hostname, node)
+        logger.debug("Writing to cache #{cache_path(hostname)}")
+        File.open(cache_path(hostname), 'w') { |file| file.write(Marshal.dump(node)) }
+      end
+
+      def delete!(hostname)
+        logger.debug("Deleting cache #{cache_path(hostname)}")
+        File.delete(cache_path(hostname)) if File.exist?(cache_path(hostname))
+      end
+
+      protected
+
+      def cache_path(node)
+        if node.is_a?String
+          return "#{@cache_dir}/#{node}"
+        end
+        "#{@cache_dir}/#{node.get_hostname}"
+      end
+
+      def ensure_cache_dir(cache_dir)
+        @cache_dir = cache_dir
+        unless File.directory?(@cache_dir)
+          logger.debug("Creating cache directory #{@cache_dir}")
+          begin
+            Dir.mkdir(@cache_dir)
+          rescue => e
+            raise UnableToCreateCacheDirectory, e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enc/cache.rb

@@ -0,0 +1,2 @@
+require 'enc/cache/exceptions'
+require 'enc/cache/node_cache'

data/lib/enc/collins_helper/api.rb

@@ -0,0 +1,43 @@
+require 'collins_client'
+
+module Enc
+  module CollinsHelper
+    class Api < Collins::Client
+      # The logger method is used by Collins::Client, so an override is needed rather than a simple include.
+      def logger
+        Enc::Utils::Logging.logger_for(self.class.name)
+      end
+
+      class TooManyAssets < Exception; end
+      class NoAssets < Exception; end
+      class AssetNotValid < Exception; end
+      class CannotConnect < Exception; end
+
+      def safe_find(options = {})
+        query = asset_hash_to_find_query(options)
+        params = query.to_a.map do |param|
+          (key, val) = param
+          if val.is_a?(Array)
+            val.map{|v| "#{key}=#{asset_escape_attribute(v)}"}.join('&')
+          else
+            "#{key}=#{asset_escape_attribute(val)}"
+          end
+        end.reject{|s| s.empty?}
+        logger.debug("Searching for asset using query: #{params.join('&')}")
+        begin
+          response = http_get('/api/assets', params) do |r|
+            parse_response(r, :expects => 200, :as => :paginated)
+          end
+        rescue SocketError, TimeoutError => e
+          raise CannotConnect, e
+        end
+        logger.debug("Got response: #{response.inspect}")
+        raise TooManyAssets, 'Too many assets' if response.count > 1
+        raise NoAssets, 'No assets found' if response.first.nil? or response.first.empty?
+        asset = CollinsHelper::Node::NodeAsset.from_json(response.first)
+        raise AssetNotValid, 'Asset is not valid' unless asset.is_valid?
+        asset
+      end
+    end
+  end
+end

data/lib/enc/collins_helper/connection.rb

@@ -0,0 +1,26 @@
+module Enc
+  module CollinsHelper
+    class Connection
+      include Enc::Utils::Logging
+
+      def initialize(config)
+        @config = config
+        @session = nil
+
+      end
+
+      def api
+        unless @session
+          logger.debug("Attempting to connect to #{@config.get('host')} as user #{@config.get('username')}")
+          @session = Enc::CollinsHelper::Api.new(:host     => @config.get('host'),
+                                                 :username => @config.get('username'),
+                                                 :password => @config.get('password'),
+                                                 :timeout  => @config.get('timeout'),
+                                                 :strict   => true)
+        end
+        @session
+      end
+
+    end
+  end
+end

data/lib/enc/collins_helper/node/exceptions.rb

@@ -0,0 +1,9 @@
+module Enc
+  module CollinsHelper
+    module Node
+      class NoDatacenter < Exception; end
+      class NoDeploymentEnvironment < Exception; end
+      class NoHostname < Exception; end
+    end
+  end
+end

data/lib/enc/collins_helper/node/node_asset.rb

@@ -0,0 +1,135 @@
+require 'collins_client'
+
+# Suppress warnings from Collins::Asset class.
+$VERBOSE = nil
+
+module Enc
+  module CollinsHelper
+    module Node
+      class NodeAsset < Collins::Asset
+        # Note: Do not include the logging module here. If the logging module loads a file handle, the Marshal.dump will
+        # fail horribly. This class is meant to be used as a resource.
+
+        VALID_ENC_FLAGS = %w(1 true yes y on)
+
+        class << self
+          def from_json(json_hash, bare_asset=false)
+            raise Collins::CollinsError, 'Invalid JSON specified for Asset.from_json' if
+                (json_hash.nil? || !json_hash.is_a?(Hash))
+            json = deep_copy_hash(json_hash)
+            json = json['data'] && json['data'] || json
+            if bare_asset or !json.include?('ASSET')
+              asset = NodeAsset.new json
+            else
+              asset = NodeAsset.new json.delete('ASSET')
+            end
+            asset.send('ipmi='.to_sym, Collins::Ipmi.from_json(json.delete('IPMI')))
+            asset.send('addresses='.to_sym, Collins::Address.from_json(json.delete('ADDRESSES')))
+            asset.send('power='.to_sym, Collins::Power.from_json(json.delete('POWER')))
+            asset.send('location=', json.delete('LOCATION'))
+            asset.send('extras=', json)
+            asset
+          end
+        end
+
+        def is_valid?
+          begin
+            get_hostname
+            get_deployment_environment
+            get_datacenter
+          rescue NoHostname, NoDeploymentEnvironment, NoDatacenter
+            return false
+          end
+          true
+        end
+
+        def uses_enc?
+          has_attribute?('PUPPET_ENC') && VALID_ENC_FLAGS.include?(get_attribute('PUPPET_ENC').to_s.downcase)
+        end
+
+        def has_attribute?(attribute)
+          begin
+            get_safe_attribute(attribute)
+          rescue KeyError
+            return false
+          end
+          true
+        end
+
+        def get_hostname
+          begin
+            value = get_safe_attribute('HOSTNAME')
+          rescue KeyError
+            raise NoHostname, 'The node does not have a hostname tag set'
+          end
+          value
+        end
+
+        def get_deployment_environment
+          begin
+            value = get_safe_attribute('ENVIRONMENT')
+          rescue KeyError
+            raise NoDeploymentEnvironment, 'The node does not have an environment tag set'
+          end
+          value
+        end
+
+        def get_datacenter
+          begin
+            value = get_safe_attribute('DATA_CENTER')
+          rescue KeyError
+            raise NoDatacenter, 'The node does not have a data_center tag set'
+          end
+          value
+        end
+
+        def get_puppet_environment
+          begin
+            value = get_safe_attribute('PUPPET_ENVIRONMENT')
+          rescue KeyError
+            value = 'production'
+          end
+          value
+        end
+
+        def get_roles
+          get_multi_attribute('CONFIGURATION_ROLES')
+        end
+
+        def get_roles_by_index
+          get_multi_attribute_with_index('CONFIGURATION_ROLES')
+        end
+
+        # We need to take all the attributes and make them more human-readable.
+        # TODO: Make it not so ugly.
+        def get_flattened_attributes
+          flattened_attributes = Hash.new
+          Hash[extract(extras, 'ATTRIBS').inject({}){ |hash, (k, v)| hash.merge(k.to_i => v) }.
+            sort_by {|k,_| k} ].each { |_,hash| hash.each {
+              |k,v| flattened_attributes.has_key?(k) && (flattened_attributes[k].is_a?(Array) &&
+                (flattened_attributes[k] << (v)) ||
+                (flattened_attributes[k] = [flattened_attributes[k], v])) ||
+                flattened_attributes[k] = v
+            }
+          }
+          flattened_attributes
+        end
+
+        def get_safe_attribute(attribute)
+          value = get_attribute(attribute)
+          raise KeyError unless value
+          value
+        end
+
+        def get_multi_attribute_with_index(attribute)
+          Hash[extract(extras, 'ATTRIBS').inject({}){ |hash, (k, v)| hash.merge(k.to_i => v[attribute]) if
+              v.has_key?(attribute) }.sort_by {|k,_| k} ]
+        end
+
+        def get_multi_attribute(attribute)
+          get_multi_attribute_with_index(attribute).values
+        end
+      end
+    end
+  end
+end

data/lib/enc/collins_helper/node.rb

@@ -0,0 +1,2 @@
+require 'enc/collins_helper/node/exceptions'
+require 'enc/collins_helper/node/node_asset'

data/lib/enc/collins_helper.rb

@@ -0,0 +1,3 @@
+require 'enc/collins_helper/connection'
+require 'enc/collins_helper/api'
+require 'enc/collins_helper/node'

data/lib/enc/config.rb

@@ -0,0 +1,63 @@
+module Enc
+  class Config
+    attr_reader :config_file
+
+    class InvalidConfiguration < Exception; end
+    class ConfigurationDoesNotExist < Exception; end
+
+    def initialize(config_file=nil, options={}, use_file=true)
+      @config_file = get_default_config(config_file)
+      @options = options.each { |k,v| {k.to_sym => v} }
+      @use_file = use_file
+    end
+
+    def get(key)
+      load[key.to_sym]
+    end
+
+    def load
+      if @options.empty?
+        @options = YAML.load_file(@config_file).inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      end
+      set_defaults
+      @options
+    end
+
+    def config_file_exists
+      File.exist?(@config_file)
+    end
+
+    def create!
+      raise InvalidConfiguration, 'Configuration requires host, username and password to be present.' unless
+        @options[:host] and @options[:username] and @options[:password]
+      File.open(@config_file, 'w') {|f| f.write @options.to_yaml }
+    end
+
+    def delete!
+      File.delete(@config_file) if File.exist?(@config_file)
+    end
+
+    protected
+
+    def set_defaults
+      @options[:timeout] = 30 unless @options.has_key?(:timeout)
+      @options[:jive_enc_cache_dir] = '/var/tmp/enc_cache' unless @options.has_key?(:jive_enc_cache_dir)
+      @options[:jive_enc_log_file] = '/var/log/enc.log' unless @options.has_key?(:jive_enc_log_file)
+    end
+
+    # Control the default config location order here. We need to assume at least this much so we know where to load the
+    # main collins config file.
+    def get_default_config(config_file=nil)
+      if config_file.nil? or config_file == ''
+        return "#{ENV['HOME']}/.collins.yaml" if File.exists?("#{ENV['HOME']}/.collins.yaml")
+        return'/var/lib/collins/.collins.yaml' if File.exists?('/var/lib/collins/.collins.yaml')
+        raise ConfigurationDoesNotExist,
+          'Could not find configuration in ~/.collins.yaml or /var/lib/collins/.collins.yaml.'
+      else
+        raise ConfigurationDoesNotExist, "Config file #{config_file} does not exist" if
+            (not File.exists?(config_file) and @use_file)
+        config_file
+      end
+    end
+  end
+end

data/lib/enc/runner.rb

@@ -0,0 +1,58 @@
+module Enc
+  class Runner
+    include Enc::Utils::Logging
+
+    def initialize(config)
+      @config = config
+      @cache = get_cache
+    end
+
+    def build(hostname)
+      asset, from_collins = get_asset(hostname)
+      # Do not rewrite the cache unless the asset comes from Collins.
+      @cache.write(hostname, asset) if from_collins
+      Enc::Builder.new(asset)
+    end
+
+    protected
+
+    def get_cache
+      begin
+        return Enc::Cache::NodeCache.new(@config)
+      rescue Enc::Cache::UnableToCreateCacheDirectory => e
+        bail('Could access cache directory', e)
+      end
+    end
+
+    def get_asset(hostname)
+      # It's important to handle any errors here so we know when to fall back to the cache.
+      begin
+        connection = Enc::CollinsHelper::Connection.new(@config)
+        return connection.api.safe_find(:hostname => hostname, :details => true), true
+      rescue Enc::CollinsHelper::Api::TooManyAssets,
+        Enc::CollinsHelper::Api::AssetNotValid,
+        Enc::CollinsHelper::Api::CannotConnect,
+        Collins::AuthenticationError,
+        Collins::RequestError
+        logger.error('Failed to connect to Collins. Attempting to read from cache')
+      # If the asset does not exist in Collins, it's important to save an empty asset in the cache that way in the case
+      # Collins is down, we will still return a valid, empty, response to puppet.
+      rescue Enc::CollinsHelper::Api::NoAssets
+        logger.info("Did not find any assets with hostname #{hostname}, saving an empty asset to the cache")
+        return Enc::CollinsHelper::Node::NodeAsset.new, true
+      end
+      begin
+        return @cache.read(hostname), false
+      rescue Enc::Cache::CacheDoesNotExist => e
+        bail('Could not find asset anywhere', e)
+      end
+    end
+
+    def bail(msg, exception)
+      logger.fatal("#{msg}: #{exception.message}")
+      logger.debug("Backtrace: #{exception.backtrace}")
+      exit(2)
+    end
+  end
+
+end

data/lib/enc/utils/logging.rb

@@ -0,0 +1,68 @@
+require 'logger'
+
+module Enc
+  module Utils
+    module Logging
+      def logger
+        unless @logger
+          @logger = Logging.logger_for(self.class.name)
+        end
+        @logger
+      end
+
+      @loggers = {}
+
+      class << self
+        def logger_for(classname)
+          unless @loggers.has_key?(classname)
+            set_config
+            set_log_level
+            set_log_file
+            @loggers[classname] = configure_logger(classname)
+          end
+          @loggers[classname]
+        end
+
+        def configure_logger(classname)
+          logger = Logger.new(@file)
+          logger.level = @level
+          logger.progname = classname
+          logger
+        end
+
+        def set_config
+          unless @config
+            @config = Enc::Config.new
+          end
+          @config
+        end
+
+        def set_log_level
+          unless @level
+            @level = convert_log_level(@config.get('jive_enc_log_level'))
+          end
+          @level
+        end
+
+        def set_log_file
+          unless @file
+            @file = @config.get('jive_enc_log_file')
+          end
+        end
+
+        def convert_log_level(level)
+          case level
+            when 'warn'
+              Logger::WARN
+            when 'error'
+              Logger::ERROR
+            when 'debug'
+              Logger::DEBUG
+            else
+              Logger::INFO
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enc/utils.rb

@@ -0,0 +1 @@
+require 'enc/utils/logging'

data/lib/enc/version.rb

@@ -0,0 +1,3 @@
+module Enc
+  VERSION = "0.0.2"
+end