motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/api/v1/config_endpoint.rb

@@ -0,0 +1,12 @@
+module MotherBrain::API
+  class V1
+    class ConfigEndpoint < MB::API::Endpoint
+      helpers MB::Mixin::Services
+
+      desc "display the loaded configuration"
+      get 'config' do
+        config_manager.config
+      end
+    end
+  end
+end

data/lib/mb/api/v1/environments_endpoint.rb

@@ -0,0 +1,174 @@
+module MotherBrain::API
+  class V1
+    class EnvironmentsEndpoint < MB::API::Endpoint
+      helpers MB::API::Helpers
+
+      rescue_from MB::NoBootstrapRoutine do |ex|
+        rack_response(ex.to_json, 405, "Content-type" => "application/json")
+      end
+
+      rescue_from MB::InvalidProvisionManifest, MB::InvalidBootstrapManifest do |ex|
+        rack_response(ex.to_json, 400, "Content-type" => "application/json")
+      end
+
+      namespace 'environments' do
+        desc "list all of the environments"
+        get do
+          environment_manager.list
+        end
+
+        params do
+          requires :environment_id, type: String, desc: "environment name"
+        end
+        namespace ':environment_id' do
+          desc "destroy a provisioned environment"
+          delete do
+            provisioner.async_destroy(params[:environment_id])
+          end
+
+          desc "create (provision) a new cluster of nodes"
+          params do
+            requires :manifest, type: Hash, desc: "a Hash representation of the node group to create"
+            group :plugin do
+              requires :name, type: String, desc: "name of the plugin to use"
+              optional :version, sem_ver: true, desc: "version of the plugin to use"
+            end
+            optional :chef_version, type: String, desc: "version of Chef to install on the node(s)"
+            optional :component_versions, type: Hash, desc: "component versions to set with default attributes"
+            optional :cookbook_versions, type: Hash, desc: "cookbook versions to set on the environment"
+            optional :environment_attributes, type: Hash, desc: "additional attributes to set on the environment"
+            optional :skip_bootstrap, type: Boolean, desc: "skip automatic bootstrapping of the created environment"
+            optional :force, type: Boolean, desc: "force provisioning nodes to the environment even if the environment is locked"
+          end
+          post do
+            plugin   = find_plugin!(params[:plugin][:name], params[:plugin][:version])
+            manifest = Provisioner::Manifest.new(params[:manifest])
+            manifest.validate!(plugin)
+
+            provisioner.async_provision(
+              params[:environment_id].freeze,
+              manifest.freeze,
+              plugin.freeze,
+              params.except(:environment_id, :manifest, :plugin).freeze
+            )
+          end
+
+          desc "update (bootstrap) an existing cluster of nodes"
+          params do
+            requires :manifest, desc: "a Hash representation of the node group to update"
+            group :plugin do
+              requires :name, type: String, desc: "name of the plugin to use"
+              optional :version, sem_ver: true, desc: "version of the plugin to use"
+            end
+            optional :chef_version, type: String, desc: "version of Chef to install on the node(s)"
+            optional :component_versions, type: Hash, desc: "component versions to set with default attributes"
+            optional :cookbook_versions, type: Hash, desc: "cookbook versions to set on the environment"
+            optional :environment_attributes, type: Hash, desc: "additional attributes to set on the environment"
+            optional :force, type: Boolean
+            optional :hints
+          end
+          put do
+            plugin   = find_plugin!(params[:plugin][:name], params[:plugin][:version])
+            manifest = Bootstrap::Manifest.new(params[:manifest])
+            manifest.validate!(plugin)
+
+            bootstrapper.async_bootstrap(
+              params[:environment_id].freeze,
+              manifest.freeze,
+              plugin.freeze,
+              params.slice(:chef_version, :component_versions, :cookbook_versions, :environment_attributes, :force, :bootstrap_proxy, :hints).freeze
+            )
+          end
+
+          desc "lock an environment"
+          post 'lock' do
+            lock_manager.async_lock(params[:environment_id])
+          end
+
+          desc "unlock an environment"
+          delete 'lock' do
+            lock_manager.async_unlock(params[:environment_id])
+          end
+
+          desc "configure an existing environment cluster"
+          params do
+            requires :attributes, type: Hash, desc: "a hash of attributes to set on the environment"
+            optional :force, type: Boolean, desc: "force configure even if the environment is locked"
+          end
+          post 'configure' do
+            environment_manager.async_configure(params[:environment_id], params.slice(:attributes, :force))
+          end
+
+          desc "upgrade an environment to the specified versions"
+          params do
+            group :plugin do
+              requires :name, type: String, desc: "name of the plugin to use"
+              optional :version, sem_ver: true, desc: "version of the plugin to use"
+            end
+            optional :component_versions, type: Hash, desc: "the component versions to set with default attributes"
+            optional :cookbook_versions, type: Hash, desc: "the cookbook versions to set on the environment"
+            optional :environment_attributes, type: Hash, desc: "any additional attributes to set on the environment"
+            optional :force, type: Boolean, desc: "force upgrade even if the environment is locked"
+          end
+          post 'upgrade' do
+            options = params.slice(:component_versions, :cookbook_versions, :environment_attributes, :force)
+            plugin  = plugin_manager.find(params[:plugin][:name], params[:plugin][:version])
+
+            upgrade_manager.async_upgrade(params[:environment_id], plugin, options)
+          end
+
+          params do
+            requires :plugin_id, type: String, desc: "plugin name"
+          end
+          namespace 'commands/:plugin_id' do
+            desc "list of commands the plugin associated with the environment supports"
+            get do
+              plugin_manager.for_environment(params[:plugin_id], params[:environment_id]).commands
+            end
+
+            desc "invoke a plugin level command on the target environment"
+            params do
+              requires :command_id, type: String, desc: "command name"
+              optional :arguments, type: Array, desc: "optional array of arguments for the command"
+              optional :force, type: Boolean, desc: "force command an environment even if it is locked"
+            end
+            post ':command_id' do
+              command_invoker.async_invoke(params[:command_id],
+                plugin: params[:plugin_id],
+                component: params[:component_id],
+                environment: params[:environment_id],
+                arguments: params[:arguments],
+                force: params[:force]
+              )
+            end
+
+            desc "list of commands the component of the plugin associated with the environment supports"
+            params do
+              requires :component_id, type: String, desc: "plugin component name"
+            end
+            get ':component_id' do
+              plugin = plugin_manager.for_environment(params[:plugin_id], params[:environment_id])
+              plugin.component!(params[:component_id]).commands
+            end
+
+            desc "invoke a plugin component level command on the target environment"
+            params do
+              requires :component_id, type: String, desc: "plugin component name"
+              requires :command_id, type: String, desc: "command name"
+              optional :arguments, type: Array, desc: "optional array of arguments for the command"
+            end
+            post ':component_id/:command_id' do
+              command_invoker.invoke_component(
+                params[:plugin_id],
+                params[:component_id],
+                params[:command_id],
+                params[:environment_id],
+                params.slice(:arguments)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/api/v1/jobs_endpoint.rb

@@ -0,0 +1,31 @@
+module MotherBrain::API
+  class V1
+    class JobsEndpoint < MB::API::Endpoint
+      helpers MB::API::Helpers
+
+      rescue_from MB::JobNotFound do |ex|
+        rack_response(ex.to_json, 404, "Content-type" => "application/json")
+      end
+
+      namespace 'jobs' do
+        desc "list all jobs (completed and active)"
+        get do
+          job_manager.list
+        end
+
+        desc "list all active jobs"
+        get 'active' do
+          job_manager.active
+        end
+
+        desc "find and return the Job with the given ID"
+        params do
+          requires :job_id, type: String, desc: "job id"
+        end
+        get ':job_id' do
+          find_job!(params[:job_id])
+        end
+      end
+    end
+  end
+end

data/lib/mb/api/v1/plugins_endpoint.rb

@@ -0,0 +1,90 @@
+module MotherBrain::API
+  class V1
+    class PluginsEndpoint < MB::API::Endpoint
+      helpers MB::API::Helpers
+      helpers MB::Mixin::Services
+
+      rescue_from MB::PluginNotFound do |ex|
+        rack_response(ex.to_json, 404, "Content-type" => "application/json")
+      end
+
+      rescue_from Solve::Errors::InvalidVersionFormat do |ex|
+        rack_response(ex.to_json, 400, "Content-type" => "application/json")
+      end
+
+      namespace 'plugins' do
+        desc "list all loaded plugins and their versions"
+        get do
+          plugin_manager.list
+        end
+
+        params do
+          requires :name, type: String, desc: "plugin name"
+        end
+        namespace ':name' do
+          desc "display all the versions of the given plugin"
+          get do
+            plugin_manager.list(name: params[:name])
+          end
+
+          namespace 'latest' do
+            desc "display the latest version of the plugin of the given name"
+            get do
+              find_plugin!(params[:name])
+            end
+
+            desc "list of all the commands the latest plugin can do"
+            get 'commands' do
+              find_plugin!(params[:name]).commands
+            end
+
+            namespace 'components' do
+              desc "list of all the components the latest plugin has"
+              get do
+                find_plugin!(params[:name]).components
+              end
+
+              desc "list of all the commands the component of the latest plugin version has"
+              params do
+                requires :component_id, type: String, desc: "component name"
+              end
+              get ':component_id/commands' do
+                find_plugin!(params[:name]).component(params[:component_id])
+              end
+            end
+          end
+
+          params do
+            requires :plugin_version, type: String, desc: "plugin version"
+          end
+          namespace ':plugin_version' do
+            desc "display the plugin of the given name and version"
+            get do
+              find_plugin!(params[:name], params[:plugin_version])
+            end
+
+            desc "list of all the commands the specified plugin version can do"
+            get 'commands' do
+              find_plugin!(params[:name], params[:plugin_version]).commands
+            end
+
+            namespace 'components' do
+              desc "list of all the components the specified plugin version has"
+              get do
+                find_plugin!(params[:name], params[:plugin_version]).components
+              end
+
+              desc "list of all the commands the component of the specified plugin version has"
+              params do
+                requires :component_id, type: String, desc: "component name"
+              end
+              get ':component_id/commands' do
+                find_plugin!(params[:name], params[:plugin_version]).component!(params[:component_id]).commands
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/api/validators.rb

@@ -0,0 +1,5 @@
+module MotherBrain::API
+  module Validators
+    require_relative 'validators/sem_ver'
+  end
+end

data/lib/mb/api/validators/sem_ver.rb

@@ -0,0 +1,18 @@
+module MotherBrain::API::Validators
+  # Coerce a URI friendly version string into a SemVer string
+  #
+  # @example coercing a URI friendly string into a SemVer string
+  #
+  #   "1_0_0" => "1.0.0"
+  class SemVer < Grape::Validations::Validator
+    def validate_param!(attr_name, params)
+      return nil if params[attr_name].nil?
+
+      ver_string = params[attr_name].gsub('_', '.')
+      Solve::Version.split(ver_string)
+      params[attr_name] = ver_string
+    rescue Solve::Errors::InvalidVersionFormat => ex
+      throw :error, status: 400, message: ex.to_s
+    end
+  end
+end

data/lib/mb/application.rb

@@ -0,0 +1,148 @@
+# TODO: Fix this when Celluloid does for Ruby 2.0
+# https://github.com/celluloid/celluloid/pull/121
+r, w = IO.pipe
+Thread.new {
+  while c = r.read(1)
+    case c
+    when 's'
+      MB.log.info "Shutting down..."
+      MB::Application.instance.interrupt
+    when 'h'
+      MB.log.info "Reloading configuration..."
+      MB::ConfigManager.instance.reload
+    else
+      MB.log.warn "Unknown fake symbol #{c} in fake signal handler!"
+    end
+  end
+}
+Signal.trap('INT') { w.write('s') }
+Signal.trap('TERM') { w.write('s') }
+Signal.trap('HUP') { w.write('h') } if Signal.supported?('HUP')
+
+module MotherBrain
+  # Main application supervisor for motherbrain
+  #
+  # @example running the application in the foreground
+  #   MB::Application.run(config)
+  #
+  # @example running the application in the background
+  #   MB::Application.run!(config)
+  module Application
+    class << self
+      extend Forwardable
+      include MB::Mixin::Services
+      include MB::Logging
+
+      def_delegator :upgrade_manager, :upgrade
+      def_delegator :config_manager, :config
+
+      def_delegators :registry, :[], :[]=
+
+      # @raise [Celluloid::DeadActorError] if Application has not been started
+      #
+      # @return [Celluloid::SupervisionGroup(MB::Application::SupervisionGroup)]
+      def instance
+        return @instance unless @instance.nil?
+
+        raise Celluloid::DeadActorError, "application not running"
+      end
+
+      # The Actor registry for motherbrain.
+      #
+      # @note motherbrain uses it's own registry instead of Celluloid::Registry.root to
+      #   avoid conflicts in the larger namespace. Use MB::Application[] to access motherbrain
+      #   actors instead of Celluloid::Actor[].
+      #
+      # @return [Celluloid::Registry]
+      def registry
+        @registry ||= Celluloid::Registry.new
+      end
+
+      # Run the application asynchronously (terminate after execution)
+      #
+      # @param [MB::Config] config
+      def run!(config)
+        Celluloid.boot
+        log.info { "motherbrain starting..." }
+        setup
+        @instance = Application::SupervisionGroup.new(config)
+      end
+
+      # Run the application in the foreground (sleep on main thread)
+      #
+      # @param [MB::Config] config
+      def run(config)
+        loop do
+          supervisor = run!(config)
+
+          sleep 0.1 while supervisor.alive?
+
+          break if supervisor.interrupted
+
+          log.fatal { "!!! #{self} crashed. Restarting..." }
+        end
+      end
+
+      # Prepare the application and environment to run motherbrain
+      def setup
+        MB::Test.mock(:setup) if MB.testing?
+        MB::FileSystem.init
+      end
+
+      # Stop the running application
+      def stop
+        instance.terminate
+      end
+    end
+
+    class SupervisionGroup < ::Celluloid::SupervisionGroup
+      include Celluloid::Notifications
+      include MB::Logging
+
+      attr_reader :interrupted
+
+      def initialize(config)
+        super(MB::Application.registry)
+
+        supervise_as(:config_manager, MB::ConfigManager, config)
+        supervise_as(:ridley, Ridley::Client, config.to_ridley)
+        supervise_as(:job_manager, MB::JobManager)
+        supervise_as(:lock_manager, MB::LockManager)
+        supervise_as(:plugin_manager, MB::PluginManager)
+        supervise_as(:command_invoker, MB::CommandInvoker)
+        supervise_as(:node_querier, MB::NodeQuerier)
+        supervise_as(:environment_manager, MB::EnvironmentManager)
+        supervise_as(:bootstrap_manager, MB::Bootstrap::Manager)
+        supervise_as(:provisioner_manager, MB::Provisioner::Manager)
+        supervise_as(:upgrade_manager, MB::Upgrade::Manager)
+
+        if config.rest_gateway.enable
+          supervise_as(:rest_gateway, MB::RestGateway, config.to_rest_gateway)
+        end
+
+        @interrupt_mutex = Mutex.new
+        @interrupted     = false
+        subscribe(ConfigManager::UPDATE_MSG, :reconfigure)
+        MB::Test.mock(:init) if MB.testing?
+      end
+
+      def reconfigure(_msg, new_config)
+        log.debug { "[Application] ConfigManager has changed: re-configuring components..." }
+        @registry[:ridley].async.configure(new_config.to_ridley)
+      end
+
+      def interrupt
+        interrupt_mutex.synchronize do
+          unless interrupted
+            @interrupted = true
+            terminate
+          end
+        end
+      end
+
+      private
+
+        attr_reader :interrupt_mutex
+    end
+  end
+end