kozo 0.1.0

data/lib/kozo/backends/local.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kozo
+  module Backends
+    class Local < Base
+      def state
+        Kozo.logger.debug "Reading local state in #{file}"
+
+        File.write(file, {}.to_json) unless File.exist?(file)
+
+        JSON.parse(File.read(file), symbolize_names: true)
+      rescue JSON::ParserError => e
+        Kozo.logger.fatal "Could not read state file: #{e.message}"
+      end
+
+      def state=(value)
+        Kozo.logger.debug "Writing local state in #{file}"
+        File.write(file, value.to_json)
+      end
+
+      def ==(other)
+        directory == other.directory
+      end
+
+      private
+
+      def file
+        @file ||= File.join(directory, "kozo.kzstate")
+      end
+    end
+  end
+end

data/lib/kozo/cli.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+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|
+        o.on("Global options:")
+        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)}") }
+        o.separator("\n")
+      end
+
+      @args = args
+      @command_args = []
+
+      parse!
+    end
+
+    def parse!
+      # Parse command line arguments (in order) and extract non-option arguments
+      # (unrecognized option values). Raise for invalid option arguments (unrecognized
+      # option keys). "--foo FOO --bar BAR" will result in "--foo" and "FOO" being parsed
+      # correctly, "--bar" and "BAR" will be extracted.
+      parser.order!(args, into: Kozo.options) { |value| command_args << value }
+    rescue OptionParser::InvalidOption => e
+      @command_args += e.args
+      retry
+    end
+
+    def start
+      command = command_args.shift
+
+      return usage unless command
+
+      klass = "Kozo::Commands::#{command.camelize}".safe_constantize
+
+      return usage(tail: "#{File.basename($PROGRAM_NAME)}: unknown command: #{command}") unless klass
+
+      klass
+        .new(command_args)
+        .start
+    end
+
+    private
+
+    def usage(code: 1, tail: nil)
+      puts parser.to_s
+      puts tail if tail
+
+      exit code
+    end
+
+    def commands
+      Commands::Base.descendants.map { |k| [k.name.demodulize.underscore, k.description] }
+    end
+  end
+end

data/lib/kozo/commands/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Base
+      class_attribute :description
+
+      def initialize(_args); end
+
+      def start
+        raise NotImplementedError
+      end
+
+      protected
+
+      def configuration
+        @configuration ||= Configuration.new(Kozo.options.directory)
+      end
+    end
+  end
+end

data/lib/kozo/commands/plan.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class Plan < Base
+      self.description = "Show execution plan"
+
+      def start
+        configuration.parse!
+      end
+    end
+  end
+end

data/lib/kozo/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Configuration
+    attr_writer :backend
+    attr_accessor :directory, :providers, :resources
+
+    def initialize(directory)
+      @directory = directory
+      @providers = {}
+      @resources = {}
+    end
+
+    def backend
+      @backend ||= Backends::Local.new(directory)
+    end
+
+    def parse!
+      dsl = DSL.new(self)
+      Dir[File.join(directory, "*.kz")]
+        .sort
+        .each { |file| dsl.instance_eval(File.read(file)) }
+    end
+  end
+end

data/lib/kozo/container.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Container
+    attr_reader :dependencies
+
+    def initialize
+      @dependencies = {}
+    end
+
+    def register(key, force: false, &block)
+      raise DependencyAlreadyRegistered, key unless force || !dependencies[key]
+
+      dependencies[key] = block
+    end
+
+    def resolve(key, *args, quiet: false, &block)
+      return dependencies[key].call(*args, &block) if dependencies[key]
+
+      raise DependencyNotRegistered, key unless quiet
+    end
+
+    class DependencyAlreadyRegistered < StandardError
+      def initialize(message)
+        super("Dependency already registered: #{message}")
+      end
+    end
+
+    class DependencyNotRegistered < StandardError
+      def initialize(message)
+        super("Dependency not registered: #{message}")
+      end
+    end
+  end
+end

data/lib/kozo/dsl.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Kozo
+  class DSL
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def kozo(&_block)
+      yield
+    end
+
+    def backend(type)
+      backend = resolve(:backend, type)
+
+      yield backend if block_given?
+
+      configuration.backend = backend
+    end
+
+    def provider(type)
+      provider = resolve(:provider, type)
+
+      yield provider if block_given?
+
+      configuration.providers[provider.class.name] = provider
+    end
+
+    def resource(type, name)
+      resource = resolve(:resource, type, name)
+      resource.provider = configuration.providers[resource.class.provider]
+
+      Kozo.logger.fatal "Provider #{resource.class.provider}" unless resource.provider
+
+      yield resource if block_given?
+
+      configuration.resources[resource.class.name] = resource
+    end
+
+    private
+
+    def resolve(resource, type, name = nil)
+      Kozo.logger.debug "Initializing #{resource} #{type} #{name}"
+
+      Kozo.container.resolve("#{resource}.#{type}")
+    rescue Container::DependencyNotRegistered
+      Kozo.logger.fatal "Unknown #{resource} type: #{type}"
+    end
+  end
+end

data/lib/kozo/environment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Environment < String
+    def initialize
+      super(ENV.fetch("KOZO_ENV", "development"))
+
+      return if %w(development test production).include?(self)
+
+      raise InvalidEnvironment, "Unknown environment: #{self}"
+    end
+
+    def development?
+      self == "development"
+    end
+
+    def test?
+      self == "test"
+    end
+
+    def production?
+      self == "production"
+    end
+
+    class InvalidEnvironment < StandardError; end
+  end
+end

data/lib/kozo/logger.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "logger"
+
+module Kozo
+  class Logger < SimpleDelegator
+    def initialize
+      super(::Logger.new($stdout, level: level, formatter: formatter))
+    end
+
+    private
+
+    def level
+      ENV.fetch("LOG_LEVEL", "info")
+    end
+
+    def formatter
+      level == "debug" ? ::Logger::Formatter.new : Formatter.new
+    end
+
+    class Formatter < ::Logger::Formatter
+      def call(severity, _time, _progname, msg)
+        abort("#{File.basename($PROGRAM_NAME)}: #{msg[0].downcase}#{msg[1..]}") if severity == "FATAL"
+
+        "#{msg}\n"
+      end
+    end
+  end
+end

data/lib/kozo/options.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Options
+    attr_writer :directory, :verbose
+
+    def directory
+      @directory ||= Dir.pwd
+    end
+
+    def directory?
+      directory.present?
+    end
+
+    def verbose
+      @verbose ||= false
+    end
+
+    def verbose?
+      verbose.present?
+    end
+
+    def [](key)
+      send(key)
+    end
+
+    def []=(key, value)
+      send(:"#{key}=", value)
+    end
+  end
+end

data/lib/kozo/provider.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Provider
+    class_attribute :name
+  end
+end

data/lib/kozo/providers/hcloud/provider.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module HCloud
+      class Provider < Kozo::Provider
+        attr_accessor :key
+
+        self.name = "hcloud"
+
+        def ==(other)
+          key == other.key
+        end
+      end
+    end
+  end
+end

data/lib/kozo/providers/hcloud/resource.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module HCloud
+      class Resource < Kozo::Resource
+        self.provider = "hcloud"
+      end
+    end
+  end
+end

data/lib/kozo/providers/hcloud/resources/ssh_key.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module HCloud
+      module Resources
+        class SSHKey < Resource
+          attr_accessor :name, :public_key
+
+          self.name = "hcloud_ssh_key"
+        end
+      end
+    end
+  end
+end

data/lib/kozo/providers/null/provider.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module Null
+      class Provider < Kozo::Provider
+        self.name = "null"
+
+        def ==(_other)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/kozo/providers/null/resource.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module Null
+      class Resource < Kozo::Resource
+        self.provider = "null"
+      end
+    end
+  end
+end

data/lib/kozo/providers/null/resources/null.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module Null
+      module Resources
+        class Null < Resource
+          self.name = "null"
+        end
+      end
+    end
+  end
+end