kozo 0.1.0 → 0.2.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Providers
+    module HCloud
+      module Resources
+        class Server < Resource
+          self.resource_name = "hcloud_server"
+
+          attribute :name
+          attribute :image
+          attribute :server_type
+          attribute :location
+          attribute :datacenter
+
+          attribute :user_data
+
+          attribute :labels, type: :hash
+
+          attribute :ssh_keys, multiple: true
+
+          attribute :locked, argument: false, type: :boolean
+
+          attribute :created, argument: false, type: :time
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,13 @@ module Kozo
     module HCloud
       module Resources
         class SSHKey < Resource
-          attr_accessor :name, :public_key
+          self.resource_name = "hcloud_ssh_key"
 
-          self.name = "hcloud_ssh_key"
+          attribute :name
+          attribute :public_key
+          attribute :labels, type: :hash
+
+          attribute :created, type: :time, argument: false
         end
       end
     end

data/lib/kozo/resource.rb

@@ -2,12 +2,119 @@
 
 module Kozo
   class Resource
-    attr_accessor :id, :provider
+    include Attributes
 
-    class_attribute :name, :provider
+    include Assignment
+    include Mark
+    include Track
+
+    attr_accessor :provider, :state_name
+
+    attribute :id
+
+    class_attribute :resource_name, :provider_name
+
+    def address
+      "#{resource_name}.#{state_name}"
+    end
 
     def ==(other)
-      id == other.id
+      self.class == other.class &&
+        id == other.id &&
+        state_name == other.state_name
+    end
+
+    alias eql? ==
+
+    def hash
+      [self.class, id].hash
+    end
+
+    def to_h
+      {
+        meta: meta,
+        data: attributes,
+      }
+    end
+
+    def self.from_h(hash)
+      Kozo
+        .container
+        .resolve("resource.#{hash.dig(:meta, :resource)}")
+        .tap { |r| hash[:data].each { |k, v| r.send(:"#{k}=", v) } }
+        .tap { |r| r.state_name = hash.dig(:meta, :name) }
+    end
+
+    ##
+    # Refetch resource from remote infrastructure
+    #
+    def refresh!
+      Kozo.logger.info "#{address}: refreshing state"
+
+      refresh
+
+      Kozo.logger.info "#{address}: refreshed state"
+    end
+
+    ##
+    # Create resource in remote infrastructure
+    #
+    def create!
+      Kozo.logger.info "#{address}: creating resource"
+
+      create
+
+      Kozo.logger.info "#{address}: created resource"
+    end
+
+    ##
+    # Update resource in remote infrastructure
+    #
+    def update!
+      Kozo.logger.info "#{address}: updating resource"
+
+      update
+
+      Kozo.logger.info "#{address}: updated resource"
+    end
+
+    ##
+    # Destroy resource in remote infrastructure
+    #
+    def destroy!
+      Kozo.logger.info "#{address}: destroying resource"
+
+      destroy
+
+      Kozo.logger.info "#{address}: destroyed resource"
+    end
+
+    protected
+
+    def refresh
+      raise NotImplementedError
+    end
+
+    def create
+      raise NotImplementedError
+    end
+
+    def update
+      raise NotImplementedError
+    end
+
+    def destroy
+      raise NotImplementedError
+    end
+
+    private
+
+    def meta
+      {
+        name: state_name,
+        provider: provider_name,
+        resource: resource_name,
+      }
     end
   end
 end

data/lib/kozo/state.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kozo
+  class State
+    VERSION = 1
+
+    attr_accessor :resources
+
+    def initialize(resources = nil)
+      @resources = Set.new(resources)
+    end
+
+    def ==(other)
+      resources == other.resources
+    end
+
+    def to_h
+      {
+        version: VERSION,
+        kozo_version: Kozo::VERSION,
+        resources: resources.map(&:to_h),
+      }
+    end
+  end
+end

data/lib/kozo/type.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Type
+    def self.lookup(type)
+      "Kozo::Types::#{type.to_s.camelize}".constantize
+    rescue NameError
+      raise ArgumentError, "No such type: #{type}"
+    end
+
+    def self.cast(value); end
+
+    def self.serialize(value); end
+  end
+end

data/lib/kozo/types/boolean.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Boolean < Type
+      # rubocop:disable Lint/BooleanSymbol
+      FALSE_VALUES = [
+        false, 0,
+        "0", :"0",
+        "f", :f,
+        "F", :F,
+        "false", :false,
+        "FALSE", :FALSE,
+        "off", :off,
+        "OFF", :OFF,
+      ].freeze
+      # rubocop:enable Lint/BooleanSymbol
+
+      def self.cast(value)
+        return if value.nil?
+
+        !FALSE_VALUES.include?(value)
+      end
+
+      def self.serialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/kozo/types/date.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Date < Type
+      def self.cast(value)
+        return unless value
+        return value if value.is_a?(::Date)
+
+        ::Date.parse(value)
+      rescue ::Date::Error => e
+        raise ArgumentError, e
+      end
+
+      def self.serialize(value)
+        value&.iso8601
+      end
+    end
+  end
+end

data/lib/kozo/types/float.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Float < Type
+      def self.cast(value)
+        return unless value
+
+        send :Float, value
+      end
+
+      def self.serialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/kozo/types/hash.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Hash < Type
+      def self.cast(value)
+        return unless value
+        return value if value.is_a?(::Hash)
+
+        value.to_h
+      rescue TypeError, NoMethodError => e
+        raise ArgumentError, e
+      end
+
+      def self.serialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/kozo/types/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Integer < Type
+      def self.cast(value)
+        return unless value
+
+        send :Integer, value
+      end
+
+      def self.serialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/kozo/types/string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class String < Type
+      def self.cast(value)
+        return unless value
+
+        send :String, value
+      end
+
+      def self.serialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/kozo/types/time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Time < Type
+      def self.cast(value)
+        return unless value
+        return value if value.is_a?(::Time)
+
+        ::Time.parse(value)
+      end
+
+      def self.serialize(value)
+        value&.iso8601
+      end
+    end
+  end
+end

data/lib/kozo/version.rb

@@ -3,7 +3,7 @@
 module Kozo
   module Version
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     PATCH = 0
     PRE   = nil
 

data/lib/kozo.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
 require "active_support/all"
+require "active_model"
+require "colorize"
+require "dinja"
+require "zeitwerk"
+
+require "byebug" if ENV["ENV"] == "development"
 
 module Kozo
   class << self
@@ -16,11 +21,7 @@ module Kozo
     end
 
     def container
-      @container ||= Container.new
-    end
-
-    def env
-      @env ||= Environment.new
+      @container ||= Dinja::Container.new
     end
 
     def logger
@@ -30,13 +31,18 @@ module Kozo
     def setup
       @loader = Zeitwerk::Loader.for_gem
 
+      # Register inflections
       instance_eval(File.read(root.join("config/inflections.rb")))
 
+      # Set up code loader
       loader.enable_reloading
+      loader.ignore(root.join("lib/**/*/dependencies.rb"))
+      loader.collapse(root.join("lib/kozo/concerns"))
       loader.setup
       loader.eager_load
 
-      container.instance_eval(File.read(root.join("config/dependencies.rb")))
+      # Register dependencies
+      Dir[root.join("lib/**/*/dependencies.rb"), root.join("config/dependencies.rb")].each { |d| container.instance_eval(File.read(d)) }
     end
   end
 end