kozo 0.1.0 → 0.2.0

data/lib/kozo/backend.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Backend
+    attr_accessor :configuration, :directory
+
+    def initialize(configuration, directory)
+      @configuration = configuration
+      @directory = directory
+    end
+
+    def state
+      @state ||= State
+        .new(resources)
+    end
+
+    def state=(value)
+      @state = value
+
+      self.data = value.to_h
+    end
+
+    def validate!
+      state_version = data.fetch(:version)
+      kozo_version = data.fetch(:kozo_version)
+
+      raise StateError, "invalid version in state: got #{state_version}, expected #{State::VERSION}" unless state_version == State::VERSION
+
+      return if kozo_version == Kozo::VERSION
+
+      raise StateError, "invalid kozo version in state: got #{kozo_version}, expected #{Kozo::VERSION}"
+    end
+
+    ##
+    # Create necessary backend files/structures if they do not exist
+    #
+    def initialize!
+      raise NotImplementedError
+    end
+
+    def ==(other)
+      directory == other.directory
+    end
+
+    protected
+
+    ##
+    # Read state from backend
+    #
+    # @return Hash
+    #
+    def data
+      raise NotImplementedError
+    end
+
+    ##
+    # Write state to backend
+    #
+    # @param value Hash
+    #
+    def data=(value)
+      raise NotImplementedError
+    end
+
+    private
+
+    def resources
+      data
+        .fetch(:resources, [])
+        .map do |hash|
+        provider = configuration.providers[hash.dig(:meta, :provider)]
+
+        raise StateError, "provider #{hash.dig(:meta, :provider)} not configured" unless provider
+
+        Resource
+          .from_h(hash)
+          .tap { |r| r.provider = provider }
+      end
+    end
+  end
+end

data/lib/kozo/backends/git.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "git"
+
+module Kozo
+  module Backends
+    class Git < Local
+      attr_writer :repository
+      attr_accessor :remote
+
+      def initialize!
+        Kozo.logger.debug "Initializing local state in #{repository_path}"
+
+        return if Dir.exist?(repository_path)
+
+        # Initialize git repository
+        @git = ::Git.init(repository_path)
+        git.add_remote("origin", remote) if remote
+
+        super
+      end
+
+      def data=(value)
+        super
+
+        git.add(file)
+        git.commit("Update Kozo resource state")
+        git.push(git.remote("origin")) if remote
+      end
+
+      def repository
+        @repository ||= "kozo.git"
+      end
+
+      private
+
+      def repository_path
+        @repository_path ||= File.join(directory, repository)
+      end
+
+      def path
+        @path ||= File.join(directory, repository, file)
+      end
+
+      def git
+        @git ||= Git.open(path)
+      end
+    end
+  end
+end

data/lib/kozo/backends/local.rb

@@ -1,33 +1,59 @@
 # frozen_string_literal: true
 
-require "json"
+require "fileutils"
+require "yaml"
 
 module Kozo
   module Backends
-    class Local < Base
-      def state
-        Kozo.logger.debug "Reading local state in #{file}"
+    class Local < Kozo::Backend
+      attr_writer :file
+      attr_accessor :backups
 
-        File.write(file, {}.to_json) unless File.exist?(file)
+      def initialize(configuration, directory)
+        super
 
-        JSON.parse(File.read(file), symbolize_names: true)
-      rescue JSON::ParserError => e
-        Kozo.logger.fatal "Could not read state file: #{e.message}"
+        @directory ||= Kozo.options.directory
       end
 
-      def state=(value)
-        Kozo.logger.debug "Writing local state in #{file}"
-        File.write(file, value.to_json)
+      def initialize!
+        Kozo.logger.debug "Initializing local state in #{path}"
+
+        return if File.exist?(path)
+
+        # Initialize empty local state
+        self.state = State.new
       end
 
-      def ==(other)
-        directory == other.directory
+      def data
+        Kozo.logger.debug "Reading local state in #{path}"
+
+        YAML
+          .safe_load(File.read(path), [Time, Date])
+          .deep_symbolize_keys
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        raise StateError, "local state at #{path} not initialized"
+      rescue Psych::SyntaxError => e
+        raise StateError, "could not read state file: #{e.message}"
       end
 
-      private
+      def data=(value)
+        Kozo.logger.debug "Writing local state in #{path}"
+
+        @data = value
+
+        # Write backup state file
+        FileUtils.mv(path, "#{path}.#{DateTime.current.to_i}.kzbackup") if backups
+
+        # Write local state file
+        File.write(path, value.deep_stringify_keys.to_yaml)
+      end
 
       def file
-        @file ||= File.join(directory, "kozo.kzstate")
+        @file ||= "kozo.kzstate"
+      end
+
+      def path
+        @path ||= File.join(directory, file)
       end
     end
   end

data/lib/kozo/backends/memory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Backends
+    class Memory < Kozo::Backend
+      def initialize!
+        Kozo.logger.debug "Initializing local state in memory"
+
+        # Initialize empty local state
+        self.state = State.new
+      end
+
+      def data
+        Kozo.logger.debug "Reading local state in memory"
+
+        @data
+      end
+
+      def data=(value)
+        Kozo.logger.debug "Writing local state in memory"
+
+        @data = value
+      end
+    end
+  end
+end

data/lib/kozo/cli.rb

@@ -1,19 +1,27 @@
 # frozen_string_literal: true
 
 require "optparse"
+require "English"
 
 module Kozo
   class CLI
     attr_reader :parser, :args, :command_args
 
     def initialize(args)
-      @parser = OptionParser.new("#{File.basename($PROGRAM_NAME)} [global options] command [command options]") do |o|
+      @parser = OptionParser.new("#{File.basename($PROGRAM_NAME)} [global options] command [subcommand] [command options]") do |o|
         o.on("Global options:")
+        o.on("-d", "--directory=DIRECTORY", "Set working directory")
         o.on("-v", "--verbose", "Turn on verbose logging")
         o.on("-h", "--help", "Display this message") { usage }
         o.separator("\n")
         o.on("Commands:")
-        commands.each { |(name, description)| o.on("    #{name}#{description.rjust(48)}") }
+        commands.each do |(name, description, subcommands)|
+          o.on("    #{name.ljust(33)}#{description}")
+
+          subcommands.each do |(sb_name, sb_description)|
+            o.on("      #{sb_name.ljust(31)}#{sb_description}")
+          end
+        end
         o.separator("\n")
       end
 
@@ -37,28 +45,41 @@ module Kozo
     def start
       command = command_args.shift
 
-      return usage unless command
+      raise UsageError, "no command specified" unless command
 
       klass = "Kozo::Commands::#{command.camelize}".safe_constantize
 
-      return usage(tail: "#{File.basename($PROGRAM_NAME)}: unknown command: #{command}") unless klass
+      raise UsageError, "unknown command: #{command}" unless klass
 
       klass
-        .new(command_args)
+        .new(*command_args)
         .start
+    rescue UsageError => e
+      # Don't print tail if no message was passed
+      return usage if e.message == e.class.name
+
+      usage(tail: "#{File.basename($PROGRAM_NAME)}: #{e.message}")
+    rescue Error => e
+      Kozo.logger.fatal e.message
     end
 
     private
 
     def usage(code: 1, tail: nil)
-      puts parser.to_s
-      puts tail if tail
+      Kozo.logger.info parser.to_s
+      Kozo.logger.info tail if tail
 
-      exit code
+      raise ExitError, code
     end
 
     def commands
-      Commands::Base.descendants.map { |k| [k.name.demodulize.underscore, k.description] }
+      Command.subclasses.sort_by(&:name).map do |k|
+        [
+          k.name.demodulize.underscore,
+          k.description,
+          k.descendants.sort_by(&:name).map { |s| [s.name.demodulize.underscore, s.description] },
+        ]
+      end
     end
   end
 end

data/lib/kozo/command.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Command
+    class_attribute :description
+
+    attr_reader :args
+    attr_writer :state, :configuration
+
+    def initialize(*args)
+      @args = args
+    end
+
+    def start
+      raise NotImplementedError
+    end
+
+    protected
+
+    def configuration
+      @configuration ||= Parser
+        .new(Kozo.options.directory)
+        .call
+    end
+
+    def state
+      @state ||= configuration
+        .backend
+        .state
+    end
+  end
+end

data/lib/kozo/commands/apply.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Apply < Plan
+      self.description = "Execute a plan"
+
+      attr_reader :parser, :options
+
+      def initialize(*args)
+        super()
+
+        @options = {
+          yes: false,
+        }
+
+        @parser = OptionParser.new do |o|
+          o.on("-y", "--yes", "Answer yes to all prompts")
+        end.parse!(args, into: options)
+      end
+
+      def start
+        super
+
+        return if operations.empty?
+
+        unless options[:yes]
+          print "\nContinue executing these actions (yes/no)? ".bold
+
+          abort("\nApply cancelled") unless gets.chomp == "yes"
+        end
+
+        # Apply operations to in-memory state and remote infrastructure
+        operations
+          .each { |o| o.apply(state) }
+
+        # Write state
+        configuration
+          .backend
+          .state = state
+      end
+    end
+  end
+end

data/lib/kozo/commands/console.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Console < Kozo::Command
+      self.description = "Open an interactive Ruby console"
+
+      def start
+        # rubocop:disable Lint/Debugger
+        binding.irb
+        # rubocop:enable Lint/Debugger
+      end
+    end
+  end
+end

data/lib/kozo/commands/import.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Import < Kozo::Command
+      self.description = "Import existing resources into the state"
+
+      attr_reader :address, :id
+
+      def initialize(*args)
+        address = args.shift
+
+        raise UsageError, "address not specified" unless address
+
+        id = args.shift
+
+        raise UsageError, "id not specified" unless id
+
+        @address = address
+        @id = id
+      end
+
+      def start
+        # Find resource in configuration
+        resource = configuration
+          .resources
+          .find { |r| r.address == address }
+
+        raise StateError, "no such resource address: #{address}" unless resource
+
+        # Set ID and fetch attributes
+        resource
+          .tap { |r| r.id = id }
+          .refresh!
+
+        # Add or replace resource to in-memory state
+        state
+          .resources << resource
+
+        # Write state
+        configuration
+          .backend
+          .state = state
+      end
+    end
+  end
+end

data/lib/kozo/commands/init.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Init < Kozo::Command
+      self.description = "Prepare your working directory for other commands"
+
+      def start
+        configuration.backend.initialize!
+
+        Kozo.logger.info "Kozo initialized in #{configuration.directory}"
+      end
+    end
+  end
+end

data/lib/kozo/commands/plan.rb

@@ -2,11 +2,37 @@
 
 module Kozo
   module Commands
-    class Plan < Base
-      self.description = "Show execution plan"
+    class Plan < Kozo::Command
+      self.description = "Create and show an execution plan"
+
+      attr_reader :operations
+
+      def initialize(*_args)
+        @operations = []
+      end
 
       def start
-        configuration.parse!
+        @operations += configuration.changes.filter_map do |resource|
+          if resource.marked_for_creation?
+            Operations::Create.new(resource)
+          elsif resource.marked_for_deletion?
+            Operations::Destroy.new(resource)
+          elsif resource.changed?
+            Operations::Update.new(resource)
+          end
+        end
+
+        Kozo.logger.info "Kozo analyzed the state and created the following execution plan. Actions are indicated by the following symbols:"
+
+        [:create, :update, :destroy]
+          .map { |c| "Kozo::Operations::#{c.to_s.camelize}".constantize }
+          .each { |o| Kozo.logger.info " #{o.display_symbol} #{o.name.demodulize.downcase}" }
+
+        return Kozo.logger.info "\nNo actions have to be performed." if operations.empty?
+
+        Kozo.logger.info "\nKozo will perform the following actions:"
+
+        operations.each { |o| Kozo.logger.info o.to_s }
       end
     end
   end

data/lib/kozo/commands/refresh.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Refresh < Kozo::Command
+      self.description = "Update the state to match remote infrastructure"
+
+      def start
+        # Refresh resources in-memory
+        state
+          .resources
+          .each(&:refresh!)
+
+        # Write state
+        configuration
+          .backend
+          .state = state
+      end
+    end
+  end
+end

data/lib/kozo/commands/show.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Show < Kozo::Command
+      self.description = "Show all resources in the state"
+
+      def start
+        state
+          .resources
+          .each { |r| Kozo.logger.info Operations::Show.new(r).to_s }
+      end
+    end
+  end
+end

data/lib/kozo/commands/state.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class State < Kozo::Command
+      self.description = "Manage and manipulate state"
+
+      attr_reader :subcommand
+
+      def initialize(*args)
+        subcommand = args.shift
+
+        raise UsageError unless subcommand
+
+        klass = "Kozo::Commands::State::#{subcommand.camelize}".safe_constantize
+
+        raise UsageError, "unknown subcommand: state #{subcommand}" unless klass
+
+        @subcommand = klass.new(*args)
+      end
+
+      def start
+        subcommand
+          .start
+      end
+
+      class List < State
+        self.description = "List resources in the state"
+
+        def initialize(*_args); end
+
+        def start
+          state
+            .resources
+            .each { |r| Kozo.logger.info r.address }
+        end
+      end
+
+      class Show < State
+        self.description = "Show a resource in the state"
+
+        attr_reader :address
+
+        def initialize(*args)
+          address = args.shift
+
+          raise UsageError, "address not specified" unless address
+
+          @address = address
+        end
+
+        def start
+          resource = state
+            .resources
+            .find { |r| r.address == address }
+
+          raise StateError, "no such resource address: #{address}" unless resource
+
+          Kozo.logger.info Operations::Show.new(resource).to_s
+        end
+      end
+    end
+  end
+end

data/lib/kozo/commands/validate.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Validate < Kozo::Command
+      self.description = "Check whether configuration is valid"
+
+      def start
+        Kozo.logger.info "The configuration in #{configuration.directory} is valid"
+      end
+    end
+  end
+end

data/lib/kozo/commands/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Version < Kozo::Command
+      self.description = "Show the current application version"
+
+      def start
+        Kozo.logger.info "kozo #{Kozo::VERSION}"
+      end
+    end
+  end
+end

data/lib/kozo/concerns/assignment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Assignment
+    def initialize(attributes = {})
+      super()
+
+      assign_attributes(attributes) if attributes
+    end
+
+    def assign_attributes(attributes)
+      attributes.each do |k, v|
+        send(:"#{k}=", v)
+      end
+    end
+  end
+end