motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/config.rb

@@ -0,0 +1,275 @@
+require 'buff/config/json'
+
+module MotherBrain
+  class Config < Buff::Config::JSON
+    class << self
+      # The default location for motherbrain's config file
+      #
+      # @return [String]
+      def default_path
+        FileSystem.root.join("config.json").to_s
+      end
+
+      # @see Buff::Config::JSON.from_json
+      #
+      # @raise [MB::ConfigNotFound]
+      def from_file(*args)
+        super
+      rescue Buff::Errors::ConfigNotFound => ex
+        raise MB::ConfigNotFound, ex
+      rescue Buff::Errors::InvalidConfig => ex
+        raise MB::InvalidConfig.new(syntax_error: [ex.message])
+      end
+
+      def from_hash(hash)
+        super
+      rescue Buff::Errors::ConfigNotFound => ex
+        raise MB::ConfigNotFound, ex
+      rescue Buff::Errors::InvalidConfig => ex
+        raise MB::InvalidConfig.new(syntax_error: [ex.message])
+      end
+
+      # @raise [Celluloid::DeadActorError] if ConfigManager has not been started
+      #
+      # @return [Celluloid::Actor(ConfigManager)]
+      def manager
+        ConfigManager.instance
+      end
+
+      # Validate the given config
+      #
+      # @param [MB::Config] config
+      #
+      # @raise [MB::InvalidConfig] if the given configuration is invalid
+      def validate!(config)
+        unless config.valid?
+          raise InvalidConfig.new(config.errors)
+        end
+      end
+
+      def chef_config
+        MB::Chef::Config.new.parse
+      end
+    end
+
+    attribute 'berkshelf.path',
+      default: MB::Berkshelf.default_path,
+      type: String,
+      required: true
+
+    attribute 'chef.api_url',
+      default: (ENV['CHEF_API_URL'] || chef_config[:chef_server_url]),
+      type: String,
+      required: true
+
+    attribute 'chef.api_client',
+      default: chef_config[:node_name],
+      type: String,
+      required: true
+
+    attribute 'chef.api_key',
+      default: chef_config[:client_key],
+      type: String,
+      required: true
+
+    attribute 'chef.validator_client',
+      default: chef_config[:validation_client_name],
+      type: String
+
+    attribute 'chef.validator_path',
+      default: chef_config[:validation_key],
+      type: String
+
+    attribute 'chef.bootstrap_proxy',
+      type: String
+
+    attribute 'chef.encrypted_data_bag_secret_path',
+      type: String
+
+    attribute 'ssh.user',
+      type: String
+
+    attribute 'ssh.password',
+      type: String
+
+    attribute 'ssh.keys',
+      type: [ Set, Array ],
+      coerce: lambda { |m| m.to_set }
+
+    attribute 'ssh.sudo',
+      default: true,
+      type: Boolean
+
+    attribute 'ssh.timeout',
+      default: 10.0,
+      type: [ Integer, Float ]
+
+    attribute 'ssh.verbose',
+      type: String
+
+    attribute 'winrm.user',
+      type: String
+
+    attribute 'winrm.password',
+      type: String
+
+    attribute 'winrm.port',
+      default: 5985,
+      type: Integer
+
+    attribute 'ssl.verify',
+      default: true,
+      type: Boolean
+
+    attribute 'log.level',
+      default: 'INFO',
+      type: String,
+      coerce: lambda { |m|
+        m = m.is_a?(String) ? m.upcase : m
+        case m
+        when Logger::DEBUG
+          'DEBUG'
+        when Logger::INFO
+          'INFO'
+        when Logger::WARN
+          'WARN'
+        when Logger::ERROR
+          'ERROR'
+        when Logger::FATAL
+          'FATAL'
+        when 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'
+          m
+        else; nil
+        end
+      }
+
+    attribute 'log.location',
+      default: 'STDOUT',
+      type: String,
+      coerce: lambda { |m|
+        o = m
+        m = m.is_a?(String) ? m.upcase : m
+        case m
+        when STDOUT; 'STDOUT'
+        when STDERR; 'STDERR'
+        when 'STDOUT', 'STDERR'; m
+        else; o
+        end
+      }
+
+    attribute 'server.daemonize',
+      default: false,
+      type: Boolean
+
+    attribute 'server.pid',
+      default: "/var/run/motherbrain/mb.pid",
+      type: String
+
+    attribute 'rest_gateway.enable',
+      default: false,
+      type: Boolean
+
+    attribute 'rest_gateway.host',
+      default: RestGateway::DEFAULT_OPTIONS[:host],
+      type: String
+
+    attribute 'rest_gateway.port',
+      default: RestGateway::DEFAULT_OPTIONS[:port],
+      type: Integer
+
+    # Enables the plugin manager to automatically populate its set of plugins
+    # from cookbooks present on the remote Chef server that contain plugins
+    attribute 'plugin_manager.eager_loading',
+      default: false,
+      type: Boolean
+
+    # How long the plugin manager will wait before polling the Chef Server to eagerly
+    # load any new plugins
+    attribute 'plugin_manager.eager_load_interval',
+      default: 300, # 5 minutes
+      type: Integer
+
+    # Allows the plugin manager load it's plugins asynchronously in the background during startup
+    attribute 'plugin_manager.async_loading',
+      default: false,
+      type: Boolean
+
+    attribute 'ef.api_url',
+      type: String
+
+    attribute 'ef.api_key',
+      type: String
+
+    attribute 'aws.access_key',
+      type: String,
+      default: ENV['AWS_ACCESS_KEY']
+
+    attribute 'aws.secret_key',
+      type: String,
+      default: ENV['AWS_SECRET_KEY']
+
+    attribute 'aws.endpoint',
+      type: String,
+      default: ENV['EC2_URL']
+
+    attribute 'bootstrap.default_template',
+      type: String
+
+    # Validate the instantiated config
+    #
+    # @raise [MB::InvalidConfig] if the given configuration is invalid
+    def validate!
+      self.class.validate!(self)
+    end
+
+    # Returns a connection hash for Ridley from the instance's attributes
+    #
+    # @example
+    #   config = MB::Config.new.tap do |o|
+    #     o.chef_api_url = "https://api.opscode.com/organizations/vialstudios"
+    #     o.chef_api_client = "reset"
+    #     o.chef_api_key = "/Users/reset/.chef/reset.pem"
+    #   end
+    #
+    #   config.to_ridley =>
+    #   {
+    #     server_url: "https://api.opscode.com/organizations/vialstudios",
+    #     client_name: "reset",
+    #     client_key: "/Users/reset/.chef/reset.pem",
+    #     validator_client: nil,
+    #     validator_path: nil
+    #   }
+    #
+    # @return [Hash]
+    def to_ridley
+      {}.tap do |ridley_opts|
+        ridley_opts[:server_url] = self.chef.api_url
+        ridley_opts[:client_name] = self.chef.api_client
+        ridley_opts[:client_key] = self.chef.api_key
+        ridley_opts[:encrypted_data_bag_secret_path] = self.chef.encrypted_data_bag_secret_path
+        ridley_opts[:validator_path] = self.chef.validator_path
+        ridley_opts[:validator_client] = self.chef.validator_client
+        ridley_opts[:ssh] = self.ssh
+        ridley_opts[:winrm] = self.winrm
+        ridley_opts[:ssl] = {
+          verify: self.ssl.verify
+        }
+        ridley_opts[:ssh][:verbose] = ridley_opts[:ssh][:verbose].to_sym if ridley_opts[:ssh][:verbose]
+      end
+    end
+
+    def to_rest_gateway
+      {}.tap do |rest_opts|
+        rest_opts[:host] = self.rest_gateway.host
+        rest_opts[:port] = self.rest_gateway.port
+      end
+    end
+
+    def to_logger
+      {}.tap do |opts|
+        opts[:level] = self.log.level
+        opts[:location] = self.log.location
+      end
+    end
+  end
+end

data/lib/mb/config_manager.rb

@@ -0,0 +1,75 @@
+module MotherBrain
+  class ConfigManager
+    class << self
+      # @raise [Celluloid::DeadActorError] if ConfigManager has not been started
+      #
+      # @return [Celluloid::Actor(ConfigManager)]
+      def instance
+        MB::Application[:config_manager] or raise Celluloid::DeadActorError, "config manager not running"
+      end
+    end
+
+    include Celluloid
+    include Celluloid::Notifications
+    include MB::Logging
+
+    UPDATE_MSG = 'config_manager.configure'.freeze
+
+    # @return [MB::Config]
+    attr_reader :config
+
+    finalizer :finalize_callback
+
+    # @param [MB::Config] new_config
+    def initialize(new_config)
+      log.debug { "Config Manager starting..." }
+      @reload_mutex = Mutex.new
+      @reloading    = false
+      set_config(new_config)
+    end
+
+    # Update the current configuration
+    #
+    # @param [MB::Config] new_config
+    def update(new_config)
+      set_config(new_config)
+
+      MB.log.info "[ConfigManager] Configuration has changed: notifying subscribers..."
+      publish(UPDATE_MSG, self.config)
+    end
+
+    # Reload the current configuration from disk
+    def reload
+      reload_mutex.synchronize do
+        unless reloading?
+          @reloading = true
+          update(config.reload)
+        end
+      end
+
+      @reloading = false
+    end
+
+    # Check if the config manager is already attempting to reload it's configuration
+    #
+    # @return [Boolean]
+    def reloading?
+      @reloading
+    end
+
+    private
+
+      # @return [Mutex]
+      attr_reader :reload_mutex
+
+      def finalize_callback
+        log.debug { "Config Manager stopping..." }
+      end
+
+      # @param [MB::Config] new_config
+      def set_config(new_config)
+        new_config.validate!
+        @config = new_config
+      end
+  end
+end

data/lib/mb/console.rb

@@ -0,0 +1,35 @@
+require 'pry'
+require 'pry/repl'
+
+module MotherBrain
+  class Console < Pry::REPL
+    class << self
+      # @option options [Object] :target ({MB::Application})
+      #   The initial context for this session.
+      # @option options [Array<Proc>] :prompt ({Console.default_prompt})
+      #   The array of Procs to use for prompts.
+      # @option options [#readline] :input
+      #   The object to use for input.
+      # @option options [#puts] :output
+      #   The object to use for output.
+      # @option options [Pry::CommandBase] :commands
+      #   The object to use for commands.
+      # @option options [Hash] :hooks
+      #   The defined hook Procs.
+      # @option options [Proc] :print
+      #   The Proc to use for printing return values.
+      # @option options [Boolean] :quiet
+      #   Omit the `whereami` banner when starting.
+      # @option options [Array<String>] :backtrace
+      #   The backtrace of the session's `binding.pry` line, if applicable.
+      def start(options = {})
+        options = options.reverse_merge(target: MB::Application, prompt: method(:default_prompt))
+        super(options)
+      end
+
+      def default_prompt(target, nest_level, pry)
+        "mb(#{Pry.view_clip(target.class)}: #{Pry.view_clip(target)}):[#{nest_level}] >> "
+      end
+    end
+  end
+end

data/lib/mb/cookbook_metadata.rb

@@ -0,0 +1,73 @@
+module MotherBrain
+  class CookbookMetadata < ::Ridley::Chef::Cookbook::Metadata
+
+    RUBY_FILENAME = 'metadata.rb'.freeze
+    JSON_FILENAME = 'metadata.json'.freeze
+
+    class << self
+      # @return [Cookbook::Metadata]
+      def load(&block)
+        klass = new()
+        klass.instance_eval(&block) if block_given?
+        klass
+      end
+
+      # @param [#to_s] filepath
+      #
+      # @return [Cookbook::Metadata]
+      def from_file(filepath)
+        filepath = filepath.to_s
+
+        if File.extname(filepath) =~ /\.json/
+          from_json_file(filepath)
+        else
+          from_ruby_file(filepath)
+        end
+      end
+
+      # @param [#to_s] path
+      #
+      # @return [Cookbook::Metadata]
+      def from_path(path)
+        ruby_file     = File.join(path, RUBY_FILENAME)
+        json_file     = File.join(path, JSON_FILENAME)
+        metadata_file = File.exists?(json_file) ? json_file : ruby_file
+
+        from_file(metadata_file)
+      end
+
+      private
+
+        def from_ruby_file(filepath)
+          load { eval(File.read(filepath), binding, filepath, 1) }
+        end
+
+        def from_json_file(filepath)
+          load { from_json(File.read(filepath)) }
+        end
+    end
+
+    # @param [Cookbook::Metadata]
+    def initialize(&block)
+      super
+      
+      begin
+        self.instance_eval(&block) if block_given?
+      rescue => e
+        raise MotherBrain::InvalidCookbookMetadata, e
+      end
+    end
+
+    # Override the default version with [Solve::Version]
+    #
+    # @return [Solve::Version]
+    def version(data = nil)
+      @version = data.nil? ? @version : Solve::Version.new(data)
+    end
+
+    private
+
+      def method_missing(*args); nil end
+
+  end
+end