motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/bootstrap/template.rb

@@ -0,0 +1,73 @@
+require 'faraday_middleware/response/follow_redirects'
+
+module MotherBrain
+  module Bootstrap
+    class Template
+      class << self
+        # Install a bootstrap template into the templates directory
+        #
+        # @param [String] name
+        #   the name of the template
+        # @param [String] filename_or_url
+        #   a local filename or URL to download
+        #
+        # @raise [MB::BootstrapTemplateNotFound] if the file cannot be installed
+        def install(name, filename_or_url)
+          template_path = MB::FileSystem.templates.join("#{name}.erb")
+          if template_path.exist?
+            raise MB::BootstrapTemplateNotFound, "Template named `#{name}` already installed"
+          end
+          MB.log.info "Installing bootstrap template `#{name}` from #{filename_or_url}"
+          name += ".erb"
+          if filename_or_url.match(URI.regexp)
+            if filename_or_url.match(URI.regexp(['http','https']))
+              uri = URI.parse(filename_or_url)
+              begin
+                conn = Faraday.new do |b|
+                  b.use FaradayMiddleware::FollowRedirects
+                  b.adapter :net_http
+                end
+                response = conn.get filename_or_url
+                template_path.open("w+") do |file|
+                  file.write(response.body)
+                end
+              rescue Exception => ex
+                raise MB::BootstrapTemplateNotFound, ex
+              end
+            else
+              raise MB::BootstrapTemplateNotFound, "Only http/https URLs are supported"
+            end
+          elsif File.exists?(filename_or_url)
+            FileUtils.copy(filename_or_url, template_path.to_s)
+          else
+            raise MB::BootstrapTemplateNotFound, "Couldn't find the template to install or the protocol given is not supported."
+          end
+        end
+
+        # Find and validate a user-chosen template
+        #
+        # @param [String] name_or_path
+        #  User's choice of template
+        #
+        # @return [String] the actual path the the chosen template
+        # @return [nil] if there is no template
+        #
+        # @raise [MB::BootstrapTemplateNotFound] if the template file
+        #   does not exist
+        def find(name_or_path=nil)
+          name_or_path ||= MB::Application.config.bootstrap.default_template
+          return unless name_or_path
+          installed = MB::FileSystem.templates.join("#{name_or_path}.erb").to_s
+          if File.exists?(installed)
+            return installed
+          end
+          if File.exists?(name_or_path)
+            return name_or_path
+          else
+            raise MB::BootstrapTemplateNotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/bootstrap/worker.rb

@@ -0,0 +1,227 @@
+module MotherBrain
+  module Bootstrap
+    # @api private
+    class Worker
+      # Used internally within the {Bootstrap::Worker} to identify hosts which should be
+      # partially or fully bootstrapped.
+      #
+      # @api private
+      class Host
+        # The fully qualified hostname of the machine
+        #
+        # @example
+        #   "reset.riotgames.com"
+        #
+        # @return [String]
+        attr_reader :hostname
+
+        # @param [String] hostname
+        #   A fully qualified hostname for a machine
+        def initialize(hostname)
+          @hostname = hostname
+        end
+
+        # @return [Boolean]
+        def full_bootstrap?
+          node_name.nil?
+        end
+
+        # The name of the machine as seen in Chef
+        #
+        # @example
+        #   "reset"
+        #
+        # @return [String]
+        def node_name
+          @node_name ||= NodeQuerier.instance.registered_as(hostname)
+        end
+
+        # @return [Boolean]
+        def partial_bootstrap?
+          node_name.present?
+        end
+
+        def to_s
+          "#{node_name}(#{hostname})"
+        end
+      end
+
+      include Celluloid
+      include MB::Logging
+      include MB::Mixin::Services
+
+      # Run a bootstrap on each of the hosts given to this instance of {Worker}. There are two different kinds of
+      # bootstrap processes which may be run on a node; a partial bootstrap and a full bootstrap.
+      #
+      # Partial Bootstrap: a node will be partially bootstrapped if it has
+      #   1. Chef installed by omnibus
+      #   2. Ruby installed by omnibus
+      #   3. A Chef client registered with the Chef server.
+      #      note: the name of the client is the "node_name" of the node. This obtained by running the
+      #            ruby node name script "script/node_name.rb" on the node.
+      #
+      # Full Bootstrap: a node will be fully bootstrapped if it does not satisfy all of the criteria for a
+      #   partial bootstrap.
+      #
+      # @example
+      #   worker = Worker.new
+      #   worker.run("cloud-1.riotgames.com") #=> {
+      #     node: "cloud-1.riotgames.com",
+      #     status: :ok,
+      #     message: "",
+      #     bootstrap_type: :full
+      #   }
+      #
+      # @param [String] address
+      #   a hostname or ipaddress to bootstrap
+      #
+      # @option options [String] :environment
+      #   environment to join the node to (default: '_default')
+      # @option options [Hash] :attributes (Hash.new)
+      #   a hash of attributes to use in the first Chef run
+      # @option options [Array] :run_list (Array.new)
+      #   an initial run list to bootstrap with
+      # @option options [String] :chef_version
+      #   version of Chef to install on the node
+      # @option options [Hash] :hints (Hash.new)
+      #   a hash of Ohai hints to place on the bootstrapped node
+      # @option options [Boolean] :sudo (true)
+      #   bootstrap with sudo
+      # @option options [String] :bootstrap_proxy (nil)
+      #   URL to a proxy server to bootstrap through
+      #
+      # @return [Hash]
+      def run(address, options = {})
+        host = Host.new(address)
+        if host.full_bootstrap?
+          full_bootstrap(host, options)
+        else
+          partial_bootstrap(host, options.slice(:attributes, :run_list))
+        end
+      end
+
+      # Perform a bootstrap on a group of nodes which have not yet been registered with the Chef server
+      # and may not have Ruby, Chef, or other requirements installed.
+      #
+      # @example
+      #   host = Host.new("cloud-1.riotgames.com")
+      #
+      #   worker.full_bootstrap(host) #=> {
+      #     node_name: "cloud-1",
+      #     hostname: "cloud-1.riotgames.com",
+      #     status: :ok
+      #     message: "",
+      #     bootstrap_type: :full
+      #   }
+      #
+      # @param [Worker::Host] host
+      #   a host to bootstrap
+      #
+      # @option options [String] :environment
+      #   environment to join the node to (default: '_default')
+      # @option options [String] :chef_version
+      #   version of Chef to install on the node
+      # @option options [Hash] :attributes (Hash.new)
+      #   a hash of attributes to use in the first Chef run
+      # @option options [Array] :run_list (Array.new)
+      #   an initial run list to bootstrap with
+      # @option options [Hash] :hints (Hash.new)
+      #   a hash of Ohai hints to place on the bootstrapped node
+      # @option options [Boolean] :sudo (true)
+      #   bootstrap with sudo
+      #
+      # @return [Hash]
+      def full_bootstrap(host, options = {})
+        options = options.reverse_merge(
+          run_list: Array.new,
+          attributes: Hash.new,
+          hints: Hash.new,
+          sudo: true
+        )
+
+        begin
+          options[:template] = MB::Bootstrap::Template.find(options[:template])
+        rescue MB::BootstrapTemplateNotFound => e
+          abort e
+        end
+        options.delete(:template) if options[:template].nil?
+
+        ssh_response = chef_connection.node.bootstrap(host.hostname, options)
+
+        {}.tap do |response|
+          response[:node_name]      = nil
+          response[:hostname]       = ssh_response.host
+          response[:bootstrap_type] = :full
+          response[:message]        = ""
+          response[:status]         = :ok
+
+          if ssh_response.error?
+            response[:status]  = :error
+            response[:message] = ssh_response.stderr.chomp
+          end
+        end
+      end
+
+      # Perform a bootstrap on a group of nodes which have already been registered with the Chef server.
+      #
+      # Partial bootstrap steps:
+      #   1. The given values given for the run_list and attributes options will be merged with the existing
+      #      node data
+      #   2. Your organization's secret key will be placed on the node
+      #   3. Perform a chef client run on the target node
+      #
+      # @example
+      #   host = Host.new("cloud-1.riotgames.com")
+      #   worker.partial_bootstrap(host) #=> {
+      #     node_name: "cloud-1",
+      #     hostname: "cloud-1.riotgames.com",
+      #     status: :ok
+      #     message: "",
+      #     bootstrap_type: :partial
+      #   }
+      #
+      # @param [Worker::Host] host
+      #   a host to bootstrap
+      #
+      # @option options [Array] :run_list
+      #   a chef run list
+      # @option options [Hash] :attributes
+      #   attributes to set on the node at normal precedence
+      #
+      # @return [Hash]
+      def partial_bootstrap(host, options = {})
+        log.info "#{host} is already registered with Chef. Performing a partial bootstrap."
+
+        {}.tap do |response|
+          response[:node_name]      = host.node_name
+          response[:hostname]       = host.hostname
+          response[:bootstrap_type] = :partial
+          response[:message]        = ""
+          response[:status]         = :ok
+
+          begin
+            chef_connection.node.merge_data(host.node_name, options.slice(:run_list, :attributes))
+            node_querier.put_secret(host.hostname)
+            node_querier.chef_run(host.hostname)
+          rescue Ridley::Errors::ResourceNotFound => ex
+            response[:status]  = :error
+            response[:message] = "Host #{host} has a client on the node and a matching client on the Chef server, " +
+              "but there is no matching node object on the Chef server for the client. This should not happen. " +
+              "Run `mb purge #{host}` or manually destroy the client on the node itself and the node object on " +
+              "the Chef server and re-run your bootstrap."
+            # JW TODO: We can recover here by creating the node object. However, we can't do this right
+            # now because OHC/OPC have ACLs associated with the node object. When we create the object the
+            # API user that we are acting as will be the only user with full permissions to the node
+            # object resulting in a 403 error when the node attempts to save itself back to the Chef server.
+            #
+            # TLDR; The undocumented ACL endpoints need to be implemented in Ridley to support graceful
+            # recovery. https://github.com/RiotGames/ridley/issues/147
+          rescue Exception => ex
+            response[:status]  = :error
+            response[:message] = ex.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/chef.rb

@@ -0,0 +1,6 @@
+module MotherBrain
+  module Chef
+    autoload :Config, 'mb/chef/config'
+    autoload :RunListItem, 'mb/chef/run_list_item'
+  end
+end

data/lib/mb/chef/config.rb

@@ -0,0 +1,69 @@
+module MotherBrain
+  module Chef
+    # Handles loading configuration values from a Chef config file
+    class Config < Hash
+      DEFAULT_PATHS = %w[
+        ./.chef/knife.rb
+        ~/.chef/knife.rb
+        /etc/chef/solo.rb
+        /etc/chef/client.rb
+      ]
+
+      # @param [String] path
+      def initialize(path = nil)
+        @path = path
+      end
+
+      # Parse the file for the path and store symbolicated keys for knife
+      # configuration options.
+      #
+      # @return [Knife] self
+      def parse
+        parse_file
+        self
+      end
+
+      private
+
+        def parse_file
+          lines.each { |line| parse_line line }
+        end
+
+        def parse_line(line)
+          eval line, binding
+        rescue
+        end
+
+        def method_missing(key, value = nil)
+          store key.to_sym, value
+        end
+
+        def lines
+          file_contents.lines.to_a
+        end
+
+        def file_contents
+          File.read(file_path)
+        rescue
+          String.new
+        end
+
+        def file_path
+          File.expand_path(path)
+        end
+
+        def path
+          @path ||= DEFAULT_PATHS.find { |path|
+            File.exist?(File.expand_path(path))
+          }
+        end
+
+        # Because it's common to set the local variable current_dir in a knife.rb
+        # and then interpolate that into strings, set it here because that's hard
+        # to parse.
+        def current_dir
+          File.dirname(file_path)
+        end
+    end
+  end
+end

data/lib/mb/chef/run_list_item.rb

@@ -0,0 +1,115 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Retrieved on 1/28/2014 @ 24dc69a9a97e82a6e4207de68d6dcc664178249b
+# Source: https://github.com/opscode/chef/blob/24dc69a9a97e82a6e4207de68d6dcc664178249b/lib/chef/run_list/run_list_item.rb
+
+module MotherBrain
+  module Chef
+    class RunListItem
+      # MB Specific
+      RECIPE_SEPARATOR = "::"
+      # /MB Specific
+
+      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}
+      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}
+      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}
+      FALSE_FRIEND                 = %r{[\[\]]}
+
+      attr_reader :name, :type, :version
+
+
+      def initialize(item)
+        @version = nil
+        case item
+        when Hash
+          assert_hash_is_valid_run_list_item!(item)
+          @type = (item['type'] || item[:type]).to_sym
+          @name = item['name'] || item[:name]
+          if (item.has_key?('version') || item.has_key?(:version))
+            @version = item['version'] || item[:version]
+          end
+        when String
+          if match = QUALIFIED_RECIPE.match(item)
+            # recipe[recipe_name]
+            # recipe[recipe_name@1.0.0]
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = QUALIFIED_ROLE.match(item)
+            # role[role_name]
+            @type = :role
+            @name = match[1]
+          elsif match = VERSIONED_UNQUALIFIED_RECIPE.match(item)
+            # recipe_name@1.0.0
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = FALSE_FRIEND.match(item)
+            # Recipe[recipe_name]
+            # roles[role_name]
+            name = match[1]
+            raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be recipe[#{name}] or role[#{name}]"
+
+          else
+            # recipe_name
+            @type = :recipe
+            @name = item
+          end
+        else
+          raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be a Hash or String"
+        end
+      end
+
+      def to_s
+        "#{@type}[#{@name}#{@version ? "@#{@version}" :""}]"
+      end
+
+      def role?
+        @type == :role
+      end
+
+      def recipe?
+        @type == :recipe
+      end
+
+      def ==(other)
+        if other.kind_of?(String)
+          self.to_s == other.to_s
+        else
+          other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version
+        end
+      end
+
+      def assert_hash_is_valid_run_list_item!(item)
+        unless (item.key?('type')|| item.key?(:type)) && (item.key?('name') || item.key?(:name))
+          raise ArgumentError, "Initializing a #{self.class} from a hash requires that it have a 'type' and 'name' key"
+        end
+      end
+
+      # MB specific
+      def cookbook_name
+        if self.recipe?
+          cookbook, _ = self.name.split(RECIPE_SEPARATOR)
+          return cookbook
+        end
+        return nil
+      end
+      # /MB specific
+    end
+  end
+end