cult 0.1.1.pre

data/lib/cult/cli/node_cmd.rb

@@ -0,0 +1,205 @@
+require 'cult/skel'
+require 'cult/commander'
+
+require 'SecureRandom'
+
+module Cult
+  module CLI
+
+    module_function
+    def node_cmd
+      node = Cri::Command.define do
+        optional_project
+        name        'node'
+        aliases     'nodes'
+        summary     'Manage nodes'
+        description <<~EOD.format_description
+          The node commands manipulate your local index of nodes.  A node is
+          conceptually description of a server.
+        EOD
+
+        run(arguments: 0) do |opts, args, cmd|
+          puts cmd.help
+        end
+      end
+
+      node_ssh = Cri::Command.define do
+        name        'ssh'
+        usage       'ssh NODE'
+        summary     'Starts an interactive SSH shell to NODE'
+        description <<~EOD.format_description
+        EOD
+
+        run(arguments: 1) do |opts, args, cmd|
+          node = CLI.fetch_item(args[0], from: Node)
+          exec "ssh", "#{node.user}@#{node.host}"
+        end
+      end
+      node.add_command(node_ssh)
+
+      node_create = Cri::Command.define do
+        name        'create'
+        aliases     'new'
+        usage       'create [options] NAME...'
+        summary     'Create a new node'
+        description <<~EOD.format_description
+          This command creates a new node specification.  With --bootstrap,
+          it'll also provision it, so it'll actually exist out there.
+
+          The newly created node will have all the roles listed in --role.  If
+          none are specified, it'll have the role "all".  If no name is
+          provided, it will be named for its role(s).
+
+          If multiple names are provided, a new node is created for each name
+          given.
+
+          The --count option lets you create an arbitrary amount of new nodes.
+          The nodes will be identical, except they'll be named with increasing
+          sequential numbers, like:
+
+          > web-01, web-02
+
+          And so forth.  The --count option is incompatible with multiple names
+          given on the command line.  If --count is specified with one name, the
+          name will become the prefix for all nodes created.  If --count is
+          specified with no names, the prefix will be generated from the role
+          names used, as discussed above.
+        EOD
+
+        required :r, :role,      'Specify possibly multiple roles',
+                                  multiple: true
+        required :n, :count,     'Generates <value> number of nodes'
+
+        required :p, :provider,  'Provider'
+        required :Z, :zone,      'Provider zone'
+        required :I, :image,     'Provider image'
+        required :S, :size,      'Provider instance size'
+
+        flag     :b, :bootstrap, 'Bring up node'
+
+        run(arguments: 0..-1) do |opts, args, cmd|
+          random_suffix = ->(basename) do
+            begin
+              suffix = CLI.unique_id
+              CLI.fetch_item("#{basename}-#{suffix}", from: Node, exist: false)
+            rescue CLIError
+              retry
+            end
+          end
+
+          generate_sequenced_names = ->(name, n) do
+            result = []
+            result.push(random_suffix.(name)) until result.size == n
+            result
+          end
+
+          unless opts[:count].nil? || opts[:count].match(/^\d+$/)
+            fail CLIError, "--count must be an integer"
+          end
+
+          names = args.dup
+
+          roles = opts[:role] ? CLI.fetch_items(opts[:role], from: Role) : []
+
+          if roles.empty?
+            roles = CLI.fetch_items('all', from: Role)
+            if names.empty?
+              begin
+                names.push CLI.fetch_item('node', from: Node, exist: false)
+              rescue
+                names.push random_suffix.('node')
+              end
+            end
+          end
+
+          if names.size > 1 && opts[:count]
+            fail CLIError, "cannot specify both --count and more than one name"
+          end
+
+          if names.empty? && !roles.empty?
+            names.push roles.map(&:name).sort.join('-')
+          end
+
+          if opts[:count]
+            names = generate_sequenced_names.(names[0], opts[:count].to_i)
+          end
+
+          # Makes sure they're all new.
+          names = names.map do |name|
+            CLI.fetch_item(name, from: Node, exist: false)
+          end
+
+          provider = if opts.key?(:provider)
+            CLI.fetch_item(opts[:provider], from: Provider)
+          else
+            Cult.project.default_provider
+          end
+
+          # Use --size if it was specified, otherwise pull the
+          # provider's default.
+          node_spec = %i(size image zone).map do |m|
+            value = opts[m] || provider.definition["default_#{m}"]
+            fail CLIError, "No #{m} specified (and no default)" if value.nil?
+            [m, value]
+          end.to_h
+
+          nodes = names.map do |name|
+            data = {
+              name: name,
+              roles: roles.map(&:name)
+            }
+
+            Node.from_data!(Cult.project, data).tap do |node|
+              if opts[:bootstrap]
+                prov_data = provider.provision!(name: node.name,
+                                                image: node_spec[:image],
+                                                size: node_spec[:size],
+                                                zone: node_spec[:zone],
+                                                ssh_key_files: '/Users/mike/.ssh/id_rsa.pub')
+                File.write(Cult.project.dump_name(node.state_path),
+                           Cult.project.dump_object(prov_data))
+
+                c = Commander.new(project: Cult.project, node: node)
+                c.bootstrap!
+                c.install!(node)
+              end
+            end
+          end
+
+        end
+      end
+      node.add_command node_create
+
+      node_list = Cri::Command.define do
+        name        'list'
+        aliases     'ls'
+        summary     'List nodes'
+        description <<~EOD.format_description
+          This command lists the nodes in the project.
+        EOD
+
+        required :r, :role, 'List only nodes which include <value>',
+                     multiple: true
+
+        run(arguments: 0..1) do |opts, args, cmd|
+          nodes = args.empty? ? Cult.project.nodes
+                              : CLI.fetch_items(*args, from: Node)
+
+          if opts[:role]
+            roles = CLI.fetch_items(opts[:role], from: Role)
+            nodes = nodes.select do |n|
+              roles.any? { |role| n.has_role?(role) }
+            end
+          end
+
+          nodes.each do |node|
+            puts "Node: #{node.inspect}"
+          end
+        end
+      end
+      node.add_command node_list
+
+      return node
+    end
+  end
+end

data/lib/cult/cli/provider_cmd.rb

@@ -0,0 +1,123 @@
+require 'cult/drivers/load'
+
+module Cult
+  module CLI
+
+    module_function
+    def provider_cmd
+      provider = Cri::Command.define do
+        optional_project
+        name        'provider'
+        aliases     'providers'
+        summary     'Provider Commands'
+        description <<~EOD.format_description
+          A provider is a VPS service.  Cult ships with drivers for quite a few
+          services, (which can be listed with `cult provider drivers`).
+
+          The commands here actually set up your environment with provider
+          accounts.  Regarding terminology:
+
+          A "driver" is an interface to a third party service you probably pay
+          for, for example, "mikes-kvm-warehouse" would be a driver that knows
+          how to interact with the commercial VPS provider "Mike's KVM
+          Warehouse".
+
+          A "provider" is a configured account on a service, which uses a
+          driver to get things done.  For example "Bob's Account at Mike's
+          KVM Warehouse".
+
+          In a lot the common case, you'll be using one provider, which is using
+          a driver of the same name.
+        EOD
+
+        run(arguments: 0) do |opts, args, cmd|
+          puts cmd.help
+        end
+      end
+
+
+      provider_list = Cri::Command.define do
+        name        'list'
+        aliases     'ls'
+        summary     'List Providers'
+        description <<~EOD.format_description
+          Lists Providers for this project.  If --driver is specified, it only
+          lists Providers which employ that driver.
+        EOD
+        required :d, :driver, "Restrict list to providers using DRIVER"
+
+        run(arguments: 0..1) do |opts, args, cmd|
+          providers = Cult.project.providers
+
+          # Filtering
+          providers = providers.all(args[0]) if args[0]
+
+          if opts[:driver]
+            driver_cls = Cult.project.drivers[opts[:driver]]
+            providers = providers.select do |p|
+              p.driver.is_a?(driver_cls)
+            end
+          end
+
+          providers.each do |p|
+            printf "%-20s %-s\n", p.name, Cult.project.relative_path(p.path)
+          end
+
+        end
+      end
+      provider.add_command(provider_list)
+
+
+      provider_avail = Cri::Command.define do
+        optional_project
+        name       'drivers'
+        summary    'list available drivers'
+        description <<~EOD.format_description
+          Displays a list of all available drivers, by their name, and list of
+          gem dependencies.
+        EOD
+
+        run(arguments: 0) do |opts, args, cmd|
+          Cult::Drivers.all.each do |p|
+            printf "%-20s %-s\n", p.driver_name, p.required_gems
+          end
+        end
+      end
+      provider.add_command(provider_avail)
+
+
+      provider_create = Cri::Command.define do
+        name        'create'
+        aliases     'new'
+        usage       'create NAME'
+        summary     'creates a new provider for your project'
+        required    :d, :driver, 'Specify driver, if different than NAME'
+        description <<~EOD.format_description
+          Creates a new provider for the project.  There are a few ways this
+          can be specified, for example
+
+            cult provider create mikes-kvm-warehouse
+
+          Will set up a provider account using 'mikes-kvm-warehouse' as both
+          the driver type and the local provider name.
+
+          If you need the two to be separate, for example, if you have multiple
+          accounts at Mike's KVM Warehouse, you can specify a driver name with
+          --driver, and an independent provider name.
+        EOD
+
+        run(arguments: 1) do |opts, args, cmd|
+          name, _ = *args
+          driver = CLI.fetch_item(opts[:driver] || name, from: Driver)
+          name = CLI.fetch_item(name, from: Provider, exist: false)
+
+          puts [driver, name].inspect
+        end
+      end
+      provider.add_command(provider_create)
+
+
+      provider
+    end
+  end
+end

data/lib/cult/cli/role_cmd.rb

@@ -0,0 +1,149 @@
+require 'fileutils'
+
+module Cult
+  module CLI
+    module_function
+
+    def role_cmd
+      role = Cri::Command.define do
+        optional_project
+        name        'role'
+        aliases     'roles'
+        summary     'Manage roles'
+        description <<~EOD.format_description
+          A role defines what a node does.  The easiest way to think about it
+          is just a directory full of scripts (tasks).
+
+          A role can include an arbitrary number of other roles.  For example,
+          you may have two roles `rat-site' and `tempo-site', which both depend
+          on a common role `web-server'.  In this case, `web-server' would be
+          the set of tasks that install the web server through the package
+          manager, set up a base configuration, and allow ports 80 and 443
+          through the firewall.
+
+          Both `rat-site' and `tempo-site' would declare that they depend on
+          `web-server' by listing it in their `includes' array in role.json.
+          Their tasks would then only consist of dropping a configuration file,
+          TLS keys and certificates into `/etc/your-httpd.d`.
+
+          Composability is the mindset behind roles.  Cult assumes, by default,
+          that roles are written in a way to compose well with each other if
+          they find themselves on the same node.  That is not always possible,
+          (thus the `conflicts' key exists in `role.json'), but is the goal.
+          You should write tasks with that in mind.  For example, dropping
+          files into `/etc/your-httpd.d` instead of re-writing
+          `/etc/your-httpd.conf`. With this setup, a node could include both
+          `rat-site` and `tempo-site` roles and be happily serving both sites.
+
+          By default, `cult init` generates two root roles that don't depend on
+          anything else: `all` and `bootstrap`.  The `bootstrap` role exists
+          to get a node from a clean OS install to a configuration to be
+          managed by the settings in `all'.  Theoretically, if you're happy
+          doing all deploys as the root user, you don't need a `bootstrap` role
+          at all: Delete it and set the `user` key in `all/role.json` to
+          "root".
+
+          The tasks in the `all` role are considered shared amongst all roles.
+          However, the only thing special about the `all` role is that Cult
+          assumes roles and nodes without an explicit `includes` setting belong
+          to all.
+        EOD
+
+        run(arguments: 0) do |opts, args, cmd|
+          puts cmd.help
+        end
+      end
+
+
+      role_create = Cri::Command.define do
+        name        'create'
+        aliases     'new'
+        summary     'creates a new role'
+        usage       'create [options] NAME'
+        description <<~EOD.format_description
+          Creates a new role names NAME, which will then be available under
+          $CULT_PROJECT/roles/$NAME
+        EOD
+
+        required :r, :roles, 'this role depends on another role',
+                 multiple: true
+
+        run(arguments: 1) do |opts, args, cmd|
+          name = CLI.fetch_item(args[0], from: Role, exist: false)
+
+          role = Role.by_name(Cult.project, name)
+          data = {}
+
+          if opts[:roles]
+            data[:includes] = CLI.fetch_items(opts[:roles],
+                                              from: Role).map(&:name)
+          end
+          FileUtils.mkdir_p(role.path)
+          File.write(Cult.project.dump_name(role.definition_file),
+                     Cult.project.dump_object(data))
+
+          FileUtils.mkdir_p(File.join(role.path, "files"))
+          File.write(File.join(role.path, "files", ".keep"), '')
+
+          FileUtils.mkdir_p(File.join(role.path, "tasks"))
+          File.write(File.join(role.path, "tasks", ".keep"), '')
+        end
+      end
+      role.add_command role_create
+
+
+      role_destroy = Cri::Command.define do
+        name        'destroy'
+        aliases     'delete', 'rm'
+        usage       'destroy ROLES...'
+        summary     'Destroy role ROLE'
+        description <<~EOD.format_description
+          Destroys all roles specified.
+        EOD
+
+        run(arguments: 1..-1) do |opts, args, cmd|
+          roles = args.map do |role_name|
+            CLI.fetch_items(role_name, from: Role)
+          end.flatten
+
+          roles.each do |role|
+            if CLI.yes_no?("Delete role #{role.name} (#{role.path})?",
+                           default: :no)
+              FileUtils.rm_rf(role.path)
+            end
+          end
+        end
+      end
+      role.add_command(role_destroy)
+
+
+      role_list = Cri::Command.define do
+        name        'list'
+        aliases     'ls'
+        usage       'list [ROLES...]'
+        summary     'List existing roles'
+        description <<~EOD.format_description
+          Lists roles in this project.  By default, lists all roles.  If one or
+          more ROLES are specified, only lists those
+        EOD
+
+        run(arguments: 0..-1) do |opts, args, cmd|
+          roles = Cult.project.roles
+          unless args.empty?
+            roles = CLI.fetch_items(*args, from: Role)
+          end
+
+          roles.each do |r|
+            fmt = "%-20s %s\n"
+            printf fmt, r.name, r.build_order.map(&:name).join(', ')
+          end
+
+        end
+      end
+      role.add_command(role_list)
+
+
+      role
+    end
+  end
+end

data/lib/cult/cli/task_cmd.rb

@@ -0,0 +1,140 @@
+require 'cult/task'
+require 'cult/role'
+
+module Cult
+  module CLI
+    module_function
+    def task_cmd
+      task = Cri::Command.define do
+        optional_project
+        name        'task'
+        aliases     'tasks'
+        summary     'Task Manipulation'
+        usage       'task [command]'
+        description <<~EOD.format_description
+
+        EOD
+
+        run(arguments: 0) do |opts, args, cmd|
+          puts cmd.help
+          exit
+        end
+      end
+
+
+      task_reserial = Cri::Command.define do
+        name        'resequence'
+        summary     'Resequences task serial numbers'
+
+        flag     :A,  :all,             'Reserial all roles'
+        flag     :G,  :'git-add',       '`git add` each change'
+        required :r,  :role,            'Roles to resequence (multiple)',
+                      multiple: true
+
+        description <<~EOD.format_description
+          Resequences the serial numbers in each task provided with --roles,
+          or all roles with --all.  You cannot supply both --all and specify
+          --roles.
+
+          A resequence isn't something to do lightly once you have deployed
+          nodes.  This will be elaborated on in the future.  It's probably
+          a good idea to do this in a development branch and test out the
+          results.
+
+          The --git-add option will execute `git add` for each rename made.
+          This will make your status contain a bunch of neat renames, instead of
+          a lot of deleted and untracked files.
+
+          This command respects the global --yes flag.
+        EOD
+
+
+        run(arguments: 0) do |opts, args, cmd|
+          if opts[:all] && Array(opts[:role]).size != 0
+            fail CLIError, "can't supply -A and also a list of roles"
+          end
+
+          roles = if opts[:all]
+            Cult.project.roles
+          elsif opts[:role]
+            CLI.fetch_items(opts[:role], from: Role)
+          else
+            fail CLIError, "no roles specified with --role or --all"
+          end
+
+          roles.each do |role|
+            puts "Resequencing role: `#{role.name}'"
+            tasks = role.tasks.sort_by do |task|
+              # This makes sure we don't change order for duplicate serials
+              [task.serial, task.name]
+            end
+
+            renames = tasks.map.with_index do |task, i|
+              if task.serial != i
+                new_task = Task.from_serial_and_name(role,
+                                                     serial: i,
+                                                     name: task.name)
+                [task, new_task]
+              end
+            end.compact.to_h
+
+            next if renames.empty?
+
+            unless Cult::CLI.yes?
+              renames.each do |src, dst|
+                puts "rename #{Cult.project.relative_path(src.path)} " +
+                     "-> #{Cult.project.relative_path(dst.path)}"
+              end
+            end
+
+            if Cult::CLI.yes_no?("Execute renames?")
+              renames.each do |src, dst|
+                FileUtils.mv(src.path, dst.path)
+                if opts[:'git-add']
+                    `git add #{src.path}; git add #{dst.path}`
+                end
+              end
+            end
+          end
+        end
+      end
+      task.add_command(task_reserial)
+
+
+      task_sanity = Cri::Command.define do
+        name        'sanity'
+        summary     'checks task files for numbering sanity'
+        description <<~EOD.format_description
+          TODO: Document (and do something!)
+        EOD
+
+        run do |opts, args, cmd|
+          puts 'checking sanity...'
+        end
+      end
+      task.add_command task_sanity
+
+
+      task_create = Cri::Command.define do
+        name        'create'
+        aliases     'new'
+        usage       'create [options] DESCRIPTION'
+        summary     'create a new task for ROLE with a proper serial'
+        description <<~EOD.format_description
+        EOD
+
+        required :r, :role, 'role for task.  defaults to "all"'
+        flag :e, :edit, 'open generated task file in your $EDITOR'
+
+        run do |opts, args, cmd|
+          english = args.join " "
+          opts[:roles] ||= 'all'
+          puts [english, opts[:roles], opts[:edit]].inspect
+        end
+      end
+      task.add_command task_create
+
+      task
+    end
+  end
+end