cult 0.1.1.pre

data/lib/cult/cli/common.rb

@@ -0,0 +1,265 @@
+require 'io/console'
+require 'shellwords'
+
+module Cult
+  module CLI
+
+    class CLIError < RuntimeError
+    end
+
+    module_function
+
+    # This sets the global project based on a directory
+    def set_project(path)
+      Cult.project = Cult::Project.locate(path)
+      if Cult.project.nil?
+        fail CLIError, "#{path} does not contain a valid Cult project"
+      end
+    end
+
+
+    # Quiet mode controls how verbose `say` is
+    def quiet=(v)
+      @quiet = v
+    end
+
+
+    def quiet?
+      @quiet
+    end
+
+
+    def say(v)
+      puts v unless @quiet
+    end
+
+
+    # yes=true automatically answers yes to "yes_no" questions.
+    def yes=(v)
+      @yes = v
+    end
+
+
+    def yes?
+      @yes
+    end
+
+
+    # Asks a yes or no question with promp.  The prompt defaults to "Yes".  If
+    # Cli.yes=true, true is returned without showing the prompt.
+    def yes_no?(prompt, default: true)
+      return true if yes?
+
+      default = case default
+        when :y, :yes
+          true
+        when :n, :no
+          false
+        when true, false
+          default
+        else
+          fail ArgumentError, "invalid :default"
+      end
+
+      loop do
+        y =  default ? Rainbow('Y').bright : Rainbow('y').darkgray
+        n = !default ? Rainbow('N').bright : Rainbow('n').darkgray
+
+        begin
+          print "#{prompt} #{y}/#{n}: "
+          case $stdin.gets.chomp
+            when ''
+              return default
+            when /^[Yy]/
+              return true
+            when /^[Nn]/
+              return false
+            else
+              $stderr.puts "Unrecognized response"
+          end
+        rescue Interrupt
+          puts
+          raise
+        end
+      end
+    end
+
+
+    # Asks the user a question, and returns the response.  Ensures a newline
+    # exists after the response.
+    def ask(prompt)
+      print "#{prompt}: "
+      $stdin.gets.chomp
+    end
+
+
+    def prompt(*args)
+      ask(*args)
+    end
+
+
+    # Disables echo to ask the user a password.
+    def password(prompt)
+      STDIN.noecho do
+        begin
+          ask(prompt)
+        ensure
+          puts
+        end
+      end
+    end
+
+
+    # it's common for drivers to need the user to visit a URL to
+    # confirm an API key or similar.  This does this in the most
+    # compatable way I know.
+    def launch_browser(url)
+      case RUBY_PLATFORM
+        when /darwin/
+          system "open", url
+        when /mswin|mingw|cygwin/
+          system "start", url
+        else
+          system "xdg-open", url
+      end
+    end
+
+
+    # We actually want "base 47", so we have to generate substantially more
+    # characters than len.  The method already generates 1.25*len characters,
+    # but is offset by _ and - that we discard.  With the other characters we
+    # discard, we usethe minimum multiplier which makes a retry "rare" (every
+    # few thousand ids at 6 len), then handle that case.
+    def unique_id(len = 8)
+      @uniq_id_disallowed ||= /[^abcdefhjkmnpqrtvwxyzABCDEFGHJKMNPQRTVWXY2346789]/
+      candidate = SecureRandom.urlsafe_base64((len * 2.1).ceil)
+                              .gsub(@uniq_id_disallowed, '')
+      fail RangeError if candidate.size < len
+      candidate[0...len]
+    rescue RangeError
+      retry
+    end
+
+
+    # v is an option or argv value from a user, label: is the name of it.
+    #
+    # This asserts that `v` is in the collection `from`, and returns it.
+    # if `exist` is false, it verifies that v is NOT in the collection and
+    # returns v.
+    #
+    # As a convenience, `from` can be a class like Role, which will imply
+    # 'Cult.project.roles'
+    #
+    # CLIError is raised if these invariants are violated
+    def fetch_item(v, from:, label: nil, exist: true, method: :fetch)
+      implied_from = case
+        when from == Driver;   Cult::Drivers.all
+        when from == Provider; Cult.project.providers
+        when from == Role;     Cult.project.roles
+        when from == Node;     Cult.project.nodes
+        else;                  nil
+      end
+
+      label ||= implied_from ? from.name.split('::')[-1].downcase : nil
+      from = implied_from
+
+      fail ArgumentError, "label cannot be implied" if label.nil?
+
+      unless [:fetch, :all].include?(method)
+        fail ArgumentError, "method must be :fetch or :all"
+      end
+
+      # We got no argument
+      fail CLIError, "Expected #{label}" if v.nil?
+
+      if exist
+        begin
+          from.send(method, v).tap do |r|
+            # Make sure
+            fail KeyError if method == :all && r.empty?
+          end
+        rescue KeyError
+          fail CLIError, "#{label} does not exist: #{v}"
+        end
+      else
+        if from.key?(v)
+          fail CLIError, "#{label} already exists: #{v}"
+        end
+        v
+      end
+    end
+
+
+    # Takes a list of keys and returns an array of objects that correspond
+    # to any of them.  If required is true, each key must correspond to at
+    # least one object.
+    def fetch_items(*keys, **kw)
+      keys.flatten.map do |key|
+        fetch_item(key, method: :all, **kw)
+      end.flatten
+    end
+
+
+    # This intercepts GemNeededError and does the installation dance.  It looks
+    # a bit hairy because it has a few resumption points, e.g., attempts user
+    # gem install, and if that fails, tries the sudo gem install.
+    def offer_gem_install(&block)
+      prompt_install = ->(gems) do
+        unless quiet?
+          print <<~EOD
+            This driver requires the installation of one or more gems:
+
+              #{gems.inspect}
+
+            Cult can install them for you.
+          EOD
+        end
+        yes_no?("Install?")
+      end
+
+      try_install = ->(gem, sudo: false) do
+        cmd = "gem install #{Shellwords.escape(gem)}"
+        cmd = "sudo #{cmd}" if sudo
+        puts "executing: #{cmd}"
+        system cmd
+        $?.success?
+      end
+
+      begin
+        yield
+      rescue ::Cult::Driver::GemNeededError => needed
+        sudo = false
+        loop do
+          sudo = catch :sudo_attempt do
+            # We don't want to show this again on a retry
+            raise unless sudo || prompt_install.(needed.gems)
+
+            needed.gems.each do |gem|
+              success = try_install.(gem, sudo: sudo)
+              if !success
+                if sudo
+                  puts "Nothing seemed to have worked.  Giving up."
+                  puts "The gems needed are #{needed.gems.inspect}."
+                  raise
+                else
+                  puts "It doesn't look like that went well."
+                  if yes_no?("Retry with sudo?")
+                    throw :sudo_attempt, true
+                  end
+                  raise
+                end
+              end
+            end
+
+            # We exit our non-loop: Everything went fine.
+            break
+          end
+        end
+
+        # Everything went fine, we need to retry the user-supplied block.
+        Gem.refresh
+        retry
+      end
+    end
+  end
+end

data/lib/cult/cli/console_cmd.rb

@@ -0,0 +1,124 @@
+require 'delegate'
+require 'rainbow'
+
+module Cult
+  module CLI
+
+    class ConsoleContext < SimpleDelegator
+      attr_accessor :original_argv
+
+
+      def initialize(project, argv)
+        super(project)
+
+        @original_argv = [$0, *argv]
+        ENV['CULT_PROJECT'] = self.path
+      end
+
+
+      def load_rc
+        consolerc = project.location_of(".cultconsolerc")
+
+        # We don't `load' so the rc file has a more convenient context.
+        eval File.read(consolerc) if File.exist?(consolerc)
+      end
+
+
+      private def exit(*)
+        # IRB tries to alias this. And it must be private, or it warns.  WTF.
+        super
+      end
+
+
+      # Gives us an escape hatch to get the real, non-decorated object
+      def project
+        __getobj__
+      end
+
+
+      def cult(*argv)
+        system $0, *argv
+      end
+
+
+      def binding
+        super
+      end
+    end
+
+    module_function
+    def console_cmd
+      Cri::Command.define do
+        name        'console'
+        summary     'Launch an REPL with you project loaded'
+        description <<~EOD.format_description
+          The Cult console loads your project, and starts a Ruby REPL.  This can
+          be useful for troubleshooting, or just poking around the project.
+
+          A few convenience global variables are set to inspect.
+        EOD
+
+        flag :i,  :irb,    'IRB (default)'
+        flag :r,  :ripl,   'Ripl'
+        flag :p,  :pry,    'Pry'
+        flag nil, :reexec, 'Console has been exec\'d for a reload'
+
+        run(arguments: 0) do |opts, args, cmd|
+          context = ConsoleContext.new(Cult.project, ARGV)
+
+          if opts[:reexec]
+            $stderr.puts "Reloaded."
+          else
+            $stderr.puts <<~EOD
+
+              Welcome to the #{Rainbow('Cult').green} Console.
+
+              Your project has been made accessible via 'project', and forwards
+              via 'self':
+
+                => #{context.inspect}
+
+              Useful methods: nodes, roles, providers
+
+            EOD
+          end
+
+          context.load_rc
+
+          if opts[:ripl]
+            require 'ripl'
+            ARGV.clear
+            # Look, something reasonable:
+            Ripl.start(binding: context.binding)
+
+          elsif opts[:pry]
+            require 'pry'
+            context.binding.pry
+          else
+            # irb: This is ridiculous.
+            require 'irb'
+            ARGV.clear
+            IRB.setup(nil)
+
+            irb = IRB::Irb.new(IRB::WorkSpace.new(context.binding))
+            IRB.conf[:MAIN_CONTEXT] = irb.context
+            IRB.conf[:IRB_RC].call(irb.context) if IRB.conf[:IRB_RC]
+
+            trap("SIGINT") do
+              irb.signal_handle
+            end
+
+            begin
+              catch(:IRB_EXIT) do
+                irb.eval_input
+              end
+            ensure
+              IRB::irb_at_exit
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cult/cli/cri_extensions.rb

@@ -0,0 +1,84 @@
+require 'cri'
+
+module Cult
+  module CLI
+    class ::String
+      def format_description
+        self.gsub(/(\S)\n(\S)/m, '\1 \2')
+            .gsub(/\.[ ]{2}(\S)/m, '. \1')
+      end
+    end
+
+
+    module CommandExtensions
+      def project_required?
+        defined?(@project_required) ? @project_required : true
+      end
+
+
+      def project_required=(v)
+        @project_required = v
+      end
+
+
+      attr_accessor :argument_spec
+
+
+      # This function returns a wrapped version of the block passed to `run`
+      def block
+        lambda do |opts, args, cmd|
+          if project_required? && Cult.project.nil?
+            fail CLIError, "command '#{name}' requires a Cult project"
+          end
+
+          check_argument_spec!(args, argument_spec) if argument_spec
+
+          super.call(opts, args, cmd)
+        end
+      end
+
+
+      def check_argument_spec!(args, range)
+        range = (range..range) if range.is_a?(Integer)
+        if range.end == -1
+          range = range.begin .. Float::INFINITY
+        end
+
+        unless range.cover?(args.size)
+          msg = case
+            when range.size == 1 && range.begin == 0
+              "accepts no arguments"
+            when range.size == 1 && range.begin == 1
+              "accepts one argument"
+            when range.begin == range.end
+              "accepts exactly #{range.begin} arguments"
+            else
+              if range.end == Float::INFINITY
+                "requires #{range.begin}+ arguments"
+              else
+                "accepts #{range} arguments"
+              end
+          end
+          fail CLIError, "Command #{msg}"
+        end
+      end
+
+      Cri::Command.prepend(self)
+    end
+
+
+    module CommandDSLExtensions
+      def optional_project
+        @command.project_required = false
+      end
+
+
+      def run(arguments: nil, &block)
+        @command.argument_spec = arguments if arguments
+        super(&block)
+      end
+
+      Cri::CommandDSL.prepend(self)
+    end
+  end
+end

data/lib/cult/cli/init_cmd.rb

@@ -0,0 +1,116 @@
+require 'cult/skel'
+require 'cult/project'
+require 'cult/drivers/load'
+
+module Cult
+  module CLI
+
+    module_function
+    def init_cmd
+      Cri::Command.define do
+        drivers = Cult::Drivers.all.map{|d| d.driver_name }.join ", "
+
+        optional_project
+        name        'init'
+        aliases     'new'
+        usage       'init DIRECTORY'
+        summary     'Create a new Cult project'
+        description <<~EOD.format_description
+          Generates a new Cult project, based on a project skeleton.
+
+          The most useful option is --driver, which both specifies a driver and
+          sets up a provider of the same name.  This will make sure the
+          dependencies for using the driver are install, and any bookkeeping
+          required to start interacting with your VPS provider is handled.
+
+          This usually involves entering an account name or getting an API key.
+
+          The default provider is "script", which isn't too pleasant, but has
+          no dependencies.  The "script" driver manages your fleet by executing
+          scripts in $CULT_PROJECT/script, which you have to implement.  This is
+          tedious, but very doable.  However, if Cult knows about your provider,
+          it can handle all of this without you having to do anything.
+
+          Cult knows about the following providers:
+
+          > #{drivers}
+
+          The init process just gets you started, and it's nothing that couldn't
+          be accomplished by hand, so if you want to change anything later, it's
+          not a big deal.
+
+          The project generated sets up a pretty common configuration: an 'all'
+          role, a 'bootstrap' role, and a demo task that puts a colorful banner
+          in each node's MOTD.
+        EOD
+
+        required :d, :driver,   'Driver with which to create your provider'
+        required :p, :provider, 'Specify an explicit provider name'
+        flag     :g, :git,      'Enable Git integration'
+
+        run(arguments: 1) do |opts, args, cmd|
+          project = Project.new(args[0])
+          if project.exist?
+            fail CLIError, "a Cult project already exists in #{project.path}"
+          end
+
+          project.git_integration = opts[:git]
+
+          driver_cls = if !opts[:provider] && !opts[:driver]
+            opts[:provider] ||= 'scripts'
+            CLI.fetch_item(opts[:provider], from: Driver)
+          elsif opts[:provider] && !opts[:driver]
+            CLI.fetch_item(opts[:provider], from: Driver)
+          elsif opts[:driver] && !opts[:provider]
+            CLI.fetch_item(opts[:driver], from: Driver).tap do |dc|
+              opts[:provider] = dc.driver_name
+            end
+          elsif opts[:driver]
+            CLI.fetch_item(opts[:driver], from: Driver)
+          end
+
+          fail CLIError, "Hmm, no driver class" if driver_cls.nil?
+
+          skel = Skel.new(project)
+          skel.copy!
+
+          provider_conf = {
+            name: opts[:provider],
+            driver: driver_cls.driver_name
+          }
+
+          CLI.offer_gem_install do
+            driver_conf = driver_cls.setup!
+            provider_conf.merge!(driver_conf)
+
+
+            provider_dir = File.join(project.location_of("providers"),
+                                     provider_conf[:name])
+            FileUtils.mkdir_p(provider_dir)
+
+
+            provider_file = File.join(provider_dir,
+                                      project.dump_name("provider"))
+            File.write(provider_file, project.dump_object(provider_conf))
+
+
+            defaults_file = File.join(provider_dir,
+                                      project.dump_name("defaults"))
+            defaults = Provider.generate_defaults(provider_conf)
+            File.write(defaults_file, project.dump_object(defaults))
+          end
+
+          if opts[:git]
+            Dir.chdir(project.path) do
+              `git init .`
+              `git add -A`
+              `git commit -m "[Cult] Created new project"`
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/cult/cli/load.rb

@@ -0,0 +1,26 @@
+require 'cri'
+require 'cult/cli/cri_extensions'
+
+module Cult
+  module CLI
+
+    module_function
+    def load_commands!
+      Dir.glob(File.join(__dir__, "*_cmd.rb")).each do |file|
+        require file
+      end
+    end
+
+
+    def commands
+      Cult::CLI.methods(false).select do |m|
+        m.to_s.match(/_cmd\z/)
+      end.map do |m|
+        Cult::CLI.send(m)
+      end
+    end
+
+  end
+end
+
+Cult::CLI.load_commands!