kozo 0.1.0 → 0.2.0

data/lib/kozo/concerns/attributes.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Attributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_types, default: {}
+
+      def read_attribute(name)
+        value = instance_variable_get(:"@#{name}")
+
+        return value unless value.nil?
+
+        # Set default
+        instance_variable_set(:"@#{name}", (attribute_types[name][:default].dup || (attribute_types[name][:multiple] ? [] : nil)))
+      end
+
+      def write_attribute(name, value)
+        try(:track_change!, name, value)
+
+        value = if attribute_types[name][:multiple]
+                  Array(value).map { |v| attribute_types[name][:type].cast(v) }
+                else
+                  attribute_types[name][:type].cast(value)
+                end
+
+        instance_variable_set(:"@#{name}", value)
+      end
+    end
+
+    # rubocop:disable Metrics/BlockLength
+    class_methods do
+      def inherited(sub_class)
+        super
+
+        sub_class.attribute_types = attribute_types.clone
+      end
+
+      def attribute(name, **options)
+        name = name.to_sym
+        type = Type.lookup(options.fetch(:type, :string))
+
+        try(:track, name)
+
+        options = attribute_types[name] = {
+          multiple: !!options[:multiple],
+          attribute: !!options.fetch(:attribute, true),
+          argument: !!options.fetch(:argument, true),
+          type: type,
+          default: options[:default],
+        }
+
+        # Define getter
+        unless method_defined? name
+          define_method(name) { read_attribute(name) }
+          define_method(:"#{name}?") { !!read_attribute(name) }
+        end
+
+        # Set visibility to public if it's an attribute
+        options[:attribute] ? public(name) : private(name)
+
+        # Define setter
+        define_method(:"#{name}=") { |value| write_attribute(name, value) } unless method_defined? :"#{name}="
+
+        # Set visibility to public if it's an argument
+        options[:argument] ? public(:"#{name}=") : private(:"#{name}=")
+      end
+
+      def attribute_names
+        @attribute_names ||= attribute_types
+          .select { |_k, v| v[:attribute] }
+          .keys
+      end
+
+      def argument_names
+        @argument_names ||= attribute_types
+          .select { |_k, v| v[:argument] }
+          .keys
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    def attributes
+      attribute_names
+        .map { |name| [name, read_attribute(name)] }
+        .to_h
+    end
+
+    def arguments
+      argument_names
+        .map { |name| [name, read_attribute(name)] }
+        .to_h
+    end
+
+    delegate :attribute_names, to: :class
+    delegate :argument_names, to: :class
+  end
+end

data/lib/kozo/concerns/mark.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Mark
+    def mark_for_deletion!
+      @status = :delete
+    end
+
+    def marked_for_deletion?
+      @status == :delete
+    end
+
+    def mark_for_creation!
+      @status = :create
+    end
+
+    def marked_for_creation?
+      @status == :create
+    end
+
+    def unmark!
+      @status = nil
+    end
+  end
+end

data/lib/kozo/concerns/track.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Track
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :trackables, default: Set.new
+
+      attr_reader :changes
+
+      def changed?
+        changes.any?
+      end
+
+      def clear_changes
+        @changes = {}
+      end
+
+      def restore_changes
+        changes.each { |key, (from, _to)| send(:"#{key}=", from) }
+
+        clear_changes
+      end
+
+      def track_change!(name, value)
+        changes[name] = [send(name), value] unless send(name) == value
+      end
+    end
+
+    class_methods do
+      def track(name)
+        trackables << name
+
+        define_method(:"#{name}_change") { changes[name] } unless method_defined? :"#{name}_change"
+        define_method(:"#{name}_changed?") { !!changes[name] } unless method_defined? :"#{name}_changed?"
+        define_method(:"#{name}_was") { changes.dig(name, 0) } unless method_defined? :"#{name}_was"
+      end
+    end
+
+    def initialize(...)
+      @changes = {}
+
+      super
+    end
+  end
+end

data/lib/kozo/configuration.rb

@@ -8,18 +8,45 @@ module Kozo
     def initialize(directory)
       @directory = directory
       @providers = {}
-      @resources = {}
+      @resources = Set.new
     end
 
     def backend
-      @backend ||= Backends::Local.new(directory)
+      @backend ||= Kozo
+        .container
+        .resolve("backend.local", self, directory)
     end
 
-    def parse!
-      dsl = DSL.new(self)
-      Dir[File.join(directory, "*.kz")]
-        .sort
-        .each { |file| dsl.instance_eval(File.read(file)) }
+    def changes
+      @changes ||= begin
+        # Copy resources in state
+        changes = backend
+          .state
+          .resources
+          .map(&:dup)
+          .each(&:clear_changes)
+          .each do |resource|
+          configured = resources.find { |r| r.address == resource.address }
+
+          # Assign updated attributes (mark for update)
+          resource.assign_attributes(configured&.attributes&.except(:id) || resource.attributes.except(:id).transform_values { nil })
+
+          # Mark for deletion
+          resource.mark_for_deletion! unless configured
+        end
+
+        # Append resources not in state
+        changes += resources
+          .reject { |r| backend.state.resources.any? { |res| res.address == r.address } }
+          .map { |r| r.class.new(state_name: r.state_name, **r.arguments) }
+          .each(&:mark_for_creation!)
+
+        changes
+      end
+    end
+
+    def to_s
+      "directory: #{directory}"
     end
   end
 end

data/lib/kozo/dsl.rb

@@ -13,7 +13,7 @@ module Kozo
     end
 
     def backend(type)
-      backend = resolve(:backend, type)
+      backend = resolve(:backend, type, configuration)
 
       yield backend if block_given?
 
@@ -25,28 +25,34 @@ module Kozo
 
       yield provider if block_given?
 
-      configuration.providers[provider.class.name] = provider
+      provider.setup
+
+      configuration.providers[provider.provider_name] = provider
     end
 
-    def resource(type, name)
-      resource = resolve(:resource, type, name)
-      resource.provider = configuration.providers[resource.class.provider]
+    def resource(type, state_name)
+      resource = resolve(:resource, type)
+      resource.state_name = state_name
+
+      raise InvalidResource, "resource #{resource.address} already defined" if configuration.resources.include?(resource)
+
+      resource.provider = configuration.providers[resource.provider_name]
 
-      Kozo.logger.fatal "Provider #{resource.class.provider}" unless resource.provider
+      raise InvalidResource, "provider #{resource.provider_name} not configured" unless resource.provider
 
       yield resource if block_given?
 
-      configuration.resources[resource.class.name] = resource
+      configuration.resources << resource
     end
 
     private
 
-    def resolve(resource, type, name = nil)
-      Kozo.logger.debug "Initializing #{resource} #{type} #{name}"
+    def resolve(resource, type, *args)
+      Kozo.logger.debug "Initializing #{resource} #{type}#{" with options #{args.join(' ')}" if args.any?}"
 
-      Kozo.container.resolve("#{resource}.#{type}")
-    rescue Container::DependencyNotRegistered
-      Kozo.logger.fatal "Unknown #{resource} type: #{type}"
+      Kozo.container.resolve("#{resource}.#{type}", *args)
+    rescue Dinja::Container::DependencyNotRegistered
+      raise InvalidResource, "unknown #{resource} type: #{type}"
     end
   end
 end

data/lib/kozo/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Error < StandardError; end
+
+  class InvalidResource < Error; end
+
+  class ExitError < Error; end
+
+  class UsageError < Error; end
+
+  class StateError < Error; end
+end

data/lib/kozo/logger.rb

@@ -12,18 +12,22 @@ module Kozo
     private
 
     def level
-      ENV.fetch("LOG_LEVEL", "info")
+      Kozo.options.verbose? ? "debug" : ENV.fetch("LOG_LEVEL", "info")
     end
 
     def formatter
-      level == "debug" ? ::Logger::Formatter.new : 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"
+        abort("#{File.basename($PROGRAM_NAME)}: #{msg[0].downcase}#{msg[1..]}".white.on_red) if severity == "FATAL"
 
-        "#{msg}\n"
+        msg = "#{msg}\n"
+        msg = msg.yellow if severity == "DEBUG"
+        msg = msg.red if severity == "ERROR"
+
+        msg
       end
     end
   end

data/lib/kozo/operation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Operation
+    attr_reader :resource
+
+    class_attribute :symbol, :display_symbol
+
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def apply(_state)
+      raise NotImplementedError
+    end
+
+    def to_s
+      resource_to_s
+    end
+
+    protected
+
+    def resource_to_s
+      <<~DSL.chomp
+        #{"# #{resource.address}:".bold}
+        #{display_symbol} resource "#{resource.resource_name}", "#{resource.state_name}" do |r|
+          #{attributes_to_s}
+        end
+
+      DSL
+    end
+
+    def attributes_to_s
+      l = resource.attribute_names.map(&:length).max || 1
+
+      resource
+        .attributes
+        .map { |k, v| "#{resource.changes.key?(k) ? display_symbol : ' '}  r.#{k.to_s.ljust(l)} = \"#{v.to_s.chomp.truncate(75)}\"" }
+        .join("\n  ")
+    end
+  end
+end

data/lib/kozo/operations/create.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Operations
+    class Create < Operation
+      self.symbol = :+
+      self.display_symbol = "+".green
+
+      def apply(state)
+        # Create resource in remote infrastructure
+        resource.create!
+
+        # Add resource to local state
+        state.resources << resource
+      end
+
+      protected
+
+      def attributes_to_s
+        l = resource.attribute_names.map(&:length).max || 1
+
+        resource
+          .attributes
+          .map { |k, v| "#{resource.changes.key?(k) ? display_symbol : ' '}  r.#{k.to_s.ljust(l)} = #{v.blank? ? '(known after apply)' : "\"#{v.to_s.chomp.truncate(75)}\""}" }
+          .join("\n  ")
+      end
+    end
+  end
+end

data/lib/kozo/operations/destroy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Operations
+    class Destroy < Operation
+      self.symbol = :-
+      self.display_symbol = "-".red
+
+      def apply(state)
+        # Destroy resource in remote infrastructure
+        resource.destroy!
+
+        # Delete resource from local state
+        state.resources.delete(resource)
+      end
+
+      protected
+
+      def attributes_to_s
+        l = resource.attribute_names.map(&:length).max || 1
+
+        resource
+          .attribute_names
+          .map { |k| "#{display_symbol}  r.#{k.to_s.ljust(l)} = \"#{resource.send(:"#{k}_was").to_s.chomp.truncate(75)}\"" }
+          .join("\n  ")
+      end
+    end
+  end
+end

data/lib/kozo/operations/show.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Operations
+    class Show < Operation
+      self.symbol = nil
+      self.display_symbol = nil
+
+      def apply(state); end
+    end
+  end
+end

data/lib/kozo/operations/update.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Operations
+    class Update < Operation
+      self.symbol = :~
+      self.display_symbol = "~".yellow
+
+      def apply(state)
+        # Update resource in remote infrastructure
+        resource.update!
+
+        # Update resource in local state
+        state.resources.delete(resource)
+        state.resources << resource
+      end
+    end
+  end
+end

data/lib/kozo/options.rb

@@ -2,7 +2,11 @@
 
 module Kozo
   class Options
-    attr_writer :directory, :verbose
+    attr_accessor :help
+
+    def directory=(path)
+      @directory = File.expand_path(path)
+    end
 
     def directory
       @directory ||= Dir.pwd
@@ -12,6 +16,10 @@ module Kozo
       directory.present?
     end
 
+    def verbose=(value)
+      @verbose = value.present?
+    end
+
     def verbose
       @verbose ||= false
     end

data/lib/kozo/parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Parser
+    attr_reader :directory
+
+    def initialize(directory)
+      @directory = directory
+    end
+
+    def call
+      configuration = Configuration.new(directory)
+      dsl = DSL.new(configuration)
+
+      Dir[File.join(directory, "main.kz"), File.join(directory, "**", "*.kz")]
+        .uniq
+        .reject { |file| ignores.any? { |ignore| file.include?(ignore) } }
+        .each { |file| dsl.instance_eval(File.read(file)) }
+
+      configuration
+    end
+
+    private
+
+    def ignores
+      @ignores ||= begin
+        File
+          .readlines(File.join(directory, ".kzignore"))
+          .map(&:chomp)
+      rescue Errno::ENOENT
+        []
+      end
+    end
+  end
+end

data/lib/kozo/provider.rb

@@ -2,6 +2,12 @@
 
 module Kozo
   class Provider
-    class_attribute :name
+    class_attribute :provider_name
+
+    def setup; end
+
+    def ==(other)
+      provider_name == other.provider_name
+    end
   end
 end

data/lib/kozo/providers/dummy/dependencies.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+register("provider.dummy") do
+  Kozo::Providers::Dummy::Provider.new
+end
+
+register("resource.dummy") do
+  Kozo::Providers::Dummy::Resources::Dummy.new
+end

data/lib/kozo/providers/{null → dummy}/provider.rb

@@ -2,13 +2,9 @@
 
 module Kozo
   module Providers
-    module Null
+    module Dummy
       class Provider < Kozo::Provider
-        self.name = "null"
-
-        def ==(_other)
-          true
-        end
+        self.provider_name = "dummy"
       end
     end
   end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module Dummy
+      class Resource < Kozo::Resource
+        self.provider_name = "dummy"
+
+        def refresh!; end
+
+        def create!; end
+
+        def destroy!; end
+
+        def update!; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module Dummy
+      module Resources
+        class Dummy < Resource
+          self.resource_name = "dummy"
+
+          attribute :name
+          attribute :description
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+register("provider.hcloud") do
+  Kozo::Providers::HCloud::Provider.new
+end
+
+register("resource.hcloud_ssh_key") do
+  Kozo::Providers::HCloud::Resources::SSHKey.new
+end
+
+register("resource.hcloud_server") do
+  Kozo::Providers::HCloud::Resources::Server.new
+end

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

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
+require "hcloud"
+
 module Kozo
   module Providers
     module HCloud
       class Provider < Kozo::Provider
         attr_accessor :key
 
-        self.name = "hcloud"
+        self.provider_name = "hcloud"
+
+        def setup
+          ::HCloud::Client.connection = ::HCloud::Client.new(access_token: key)
+        end
 
         def ==(other)
           key == other.key

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

@@ -4,7 +4,52 @@ module Kozo
   module Providers
     module HCloud
       class Resource < Kozo::Resource
-        self.provider = "hcloud"
+        self.provider_name = "hcloud"
+
+        attribute :id, type: :integer
+
+        protected
+
+        def refresh
+          resource = resource_class.find(id)
+
+          attribute_names
+            .excluding(:id)
+            .each { |attr| send(:"#{attr}=", resource.send(attr)) }
+        end
+
+        def create
+          resource = resource_class.new(**attributes.except(:id))
+          resource.create
+
+          attribute_names
+            .each { |attr| send(:"#{attr}=", resource.send(attr)) }
+        end
+
+        def update
+          resource = resource_class.find(id)
+
+          attribute_names
+            .excluding(:id)
+            .each { |attr| resource.send(:"#{attr}=", send(attr)) }
+
+          resource.update
+
+          attribute_names
+            .excluding(:id)
+            .each { |attr| send(:"#{attr}=", resource.send(attr)) }
+        end
+
+        def destroy
+          resource = resource_class.find(id)
+          resource.delete
+        end
+
+        private
+
+        def resource_class
+          "HCloud::#{self.class.name.demodulize}".constantize
+        end
       end
     end
   end