fog-hetznercloud 0.0.1

data/lib/fog/hetznercloud/client.rb

@@ -0,0 +1,55 @@
+module Fog
+  module Hetznercloud
+    class Client
+      def initialize(endpoint, token, connection_options)
+        @endpoint           = endpoint
+        @token              = token
+        @connection_options = connection_options
+      end
+
+      def request(params)
+        params[:headers] ||= {}
+        params[:headers]['Content-Type'] ||= 'application/json'
+        params[:headers]['Authorization'] ||= "Bearer #{@token}"
+
+        params[:body] = encode_body(params)
+
+        response = connection.request(params)
+
+        response.body = decode_body(response)
+
+        response
+      end
+
+      private
+
+      def connection
+        @connection ||= Fog::Core::Connection.new(@endpoint, false, @connection_options)
+      end
+
+      def encode_body(params)
+        body         = params[:body]
+        content_type = params[:headers]['Content-Type']
+
+        if body.nil? || body.is_a?(String)
+          body
+        elsif content_type =~ %r{application/json.*}i
+          Fog::JSON.encode(body)
+        else
+          body.to_s
+        end
+      end
+
+      def decode_body(response)
+        body         = response.body
+        content_type = response.headers['Content-Type']
+
+        if !body.nil? && !body.empty? && content_type =~ %r{application/json.*}i
+          Fog::JSON.decode(body)
+        else
+          body
+        end
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/compute.rb

@@ -0,0 +1,146 @@
+require 'fog/hetznercloud/client'
+require 'fog/hetznercloud/errors'
+require 'fog/hetznercloud/request_helper'
+
+module Fog
+  module Hetznercloud
+    class Compute < Fog::Service
+      class UnauthorizedError < Error; end
+      class ForbiddenError < Error; end
+      class InvalidInputError < Error; end
+      class JsonErrorError < Error; end
+      class LockedError < Error; end
+      class NotFoundError < Error; end
+      class RateLimitExceededError < Error; end
+      class ResourceLimitExeceededError < Error; end
+      class ResourceUnavailableError < Error; end
+      class ServiceErrorError < Error; end
+      class UniquenessErrorError < Error; end
+      class UnknownResourceError < Error; end
+      class StateError < Error; end
+
+      requires   :hetznercloud_token
+      recognizes :hetznercloud_datacenter
+      recognizes :hetznercloud_location
+      secrets    :hetznercloud_token
+
+      model_path 'fog/hetznercloud/models/compute'
+
+      model      :server
+      collection :servers
+      model      :image
+      collection :images
+      model      :server_type
+      collection :server_types
+      model      :action
+      collection :actions
+      model      :floating_ip
+      collection :floating_ips
+      model      :location
+      collection :locations
+      model      :datacenter
+      collection :datacenters
+      model      :ssh_key
+      collection :ssh_keys
+
+      request_path 'fog/hetznercloud/requests/compute'
+
+      ## Servers
+      request :create_server
+      request :list_servers
+      request :get_server
+      request :update_server
+      request :delete_server
+      request :execute_server_action
+
+      # Server Types
+      request :list_server_types
+      request :get_server_type
+
+      # Images
+      request :list_images
+      request :get_image
+      request :delete_image
+      request :update_image
+
+      # Actions
+      request :list_actions
+      request :get_action
+
+      # Locations
+      request :list_locations
+      request :get_location
+
+      # Datacenters
+      request :list_datacenters
+      request :get_datacenter
+
+      # Datacenters
+      request :list_ssh_keys
+      request :get_ssh_key
+      request :create_ssh_key
+      request :delete_ssh_key
+      request :update_ssh_key
+
+      # Floating IP'S
+      request :list_floating_ips
+      request :get_floating_ip
+      request :create_floating_ip
+      request :delete_floating_ip
+      request :update_floating_ip
+      request :floating_ip_assign_to_server
+      request :floating_ip_unassign
+      request :floating_ip_update_dns_ptr
+
+      class Real
+        include Fog::Hetznercloud::RequestHelper
+
+        # FIXME: Make @location and @datacenter used in server creation
+        #        as default
+        def initialize(options)
+          @token              = options[:hetznercloud_token]
+          @location           = options[:hetznercloud_location] || 'fsn1'
+          @datacenter         = options[:hetznercloud_datacenter] || 'fsn1-dc8'
+          @connection_options = options[:connection_options] || {}
+        end
+
+        def request(params)
+          client.request(params)
+        rescue Excon::Errors::HTTPStatusError => error
+          decoded = Fog::Hetznercloud::Errors.decode_error(error)
+          raise if decoded.nil?
+
+          code    = decoded[:code]
+          message = decoded[:message]
+
+          raise case code
+                when 'unauthorized', 'forbidden', 'invalid_input', 'json_error', 'locked', 'not_found', 'rate_limit_exceeded', 'resource_limit_exceeded', 'resource_unavailable', 'service_error', 'uniqueness_error'
+                  Fog::Hetznercloud::Compute.const_get("#{camelize(code)}Error").slurp(error, message)
+                else
+                  Fog::Hetznercloud::Compute::Error.slurp(error, message)
+                end
+        end
+
+        private
+
+        def client
+          @client ||= Fog::Hetznercloud::Client.new(endpoint, @token, @connection_options)
+        end
+
+        def endpoint
+          'https://api.hetzner.cloud/v1'
+        end
+
+        def camelize(str)
+          str.split('_').collect(&:capitalize).join
+        end
+      end
+
+      class Mock
+        def request(*_args)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/errors.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Hetznercloud
+    module Errors
+      def self.decode_error(error)
+        body = begin
+                 Fog::JSON.decode(error.response.body)
+               rescue Fog::JSON::DecodeError
+                 nil
+               end
+
+        return if body.nil?
+
+        code    = body['error']['code']
+        message = body['error']['message']
+        details = body['error']['details']
+
+        return if code.nil? || message.nil?
+
+        unless details.nil?
+          message << "\n"
+          message << format_details(details)
+        end
+
+        { code: code, message: message }
+      end
+
+      def self.format_details(details)
+        details.map { |field, msgs| format_field(field, msgs) }.join("\n")
+      end
+
+      def self.format_field(field, msgs)
+        msgs = msgs.map { |msg| "\t\t- #{msg}" }
+        "\t#{field}:\n#{msgs.join("\n")}"
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/models/compute/action.rb

@@ -0,0 +1,31 @@
+# https://docs.hetzner.cloud/#resources-actions-get
+module Fog
+  module Hetznercloud
+    class Compute
+      class Action < Fog::Model
+        identity :id
+
+        attribute :command
+        attribute :status
+        attribute :progress
+        # attribute :extra_volumes
+        attribute :started
+        attribute :finished
+        attribute :resources
+        attribute :error
+
+        def running?
+          status == 'running'
+        end
+
+        def error?
+          status == 'error'
+        end
+
+        def success?
+          status == 'success'
+        end
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/models/compute/actions.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Hetznercloud
+    class Compute
+      class Actions < Fog::Collection
+        model Fog::Hetznercloud::Compute::Action
+
+        def all(filters = {})
+          actions = service.list_actions(filters).body['actions'] || []
+          load(actions)
+        end
+
+        def get(identity)
+          if (action = service.get_action(identity).body['action'])
+            new(action)
+          end
+        rescue Fog::Hetznercloud::Compute::UnknownResourceError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/models/compute/datacenter.rb

@@ -0,0 +1,15 @@
+# https://docs.hetzner.cloud/#resources-actions-get
+module Fog
+  module Hetznercloud
+    class Compute
+      class Datacenter < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :location
+        attribute :server_types
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/models/compute/datacenters.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Hetznercloud
+    class Compute
+      class Datacenters < Fog::Collection
+        model Fog::Hetznercloud::Compute::Datacenter
+
+        def all(filters = {})
+          datacenters = service.list_datacenters(filters).body['datacenters'] || []
+          load(datacenters)
+        end
+
+        def get(identity)
+          if (datacenter = service.get_datacenter(identity).body['datacenter'])
+            new(datacenter)
+          end
+        rescue Fog::Hetznercloud::Compute::UnknownResourceError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/hetznercloud/models/compute/floating_ip.rb

@@ -0,0 +1,154 @@
+# https://docs.hetzner.cloud/#resources-actions-get
+module Fog
+  module Hetznercloud
+    class Compute
+      class FloatingIp < Fog::Model
+        identity :id
+
+        attribute :description    # String
+        attribute :ip             # String
+        attribute :type           # ipv4|ipv6
+        attribute :server         # id of server
+        attribute :dns_ptr        # array of string
+        attribute :home_location  # location object
+        attribute :blocked        # boolean
+
+        def type=(value)
+          valid = %w[ipv4 ipv6]
+          if !valid.include? value
+            raise Fog::Hetznercloud::Compute::InvalidInputError, "ERROR: floating_ip type must be one of #{valid}"
+          else
+            attributes[:type] = value
+          end
+        end
+
+        def description=(value)
+          @lastdescription = attributes[:description]
+          attributes[:description] = value
+          if @lastdescription && @lastdescription != attributes[:description]
+            @needsupdate = true
+          else
+            @needsupdate = false
+          end
+        end
+
+        def home_location=(value)
+          attributes[:home_location] = case value
+                                       when Hash
+                                         service.locations.new(value)
+                                       when String
+                                         service.locations.new(identity: value)
+                                       else
+                                         value
+                                        end
+        end
+
+        def server=(value)
+          attributes[:server] = case value
+                                when Hash
+                                  service.servers.new(value)
+                                when Integer
+                                  service.servers.get(value)
+                                else
+                                  value
+                                        end
+        end
+
+        def destroy
+          requires :identity
+
+          service.delete_floating_ip(identity)
+          true
+        end
+
+        def save
+          if persisted?
+            reassign && unassign && update
+          else
+            create
+          end
+        end
+
+        def assign(serverid)
+          requires :identity
+          if serverid.nil?
+            body = {}
+
+            if (floating_ip = service.floating_ip_unassign(identity, body).body['floating_ip'])
+              merge_attributes(floating_ip)
+              true
+            else
+              false
+            end
+          else
+            body = {
+              server: serverid
+            }
+
+            if (floating_ip = service.floating_ip_assign_to_server(identity, body).body['floating_ip'])
+              merge_attributes(floating_ip)
+              true
+            else
+              false
+            end
+          end
+        end
+
+        def update_dns_ptr(newname)
+          requires :identity
+
+          body = {
+            ip: ip,
+            dns_ptr: newname
+          }
+
+          if (floating_ip = service.floating_ip_update_dns_ptr(identity, body).body['floating_ip'])
+            merge_attributes(floating_ip)
+            true
+          else
+            false
+          end
+        end
+
+        def unassign
+          assign(nil) unless server.nil?
+        end
+
+        private
+
+        def create
+          requires :type
+          requires_one :home_location, :server
+
+          options = {}
+          options[:description] = description unless description.nil?
+          options[:home_location] = home_location.identity unless home_location.nil?
+          options[:server] = server.identity unless server.nil?
+
+          if (floating_ip = service.create_floating_ip(type, options).body['floating_ip'])
+            merge_attributes(floating_ip)
+            true
+          else
+            false
+          end
+        end
+
+        def update
+          return true unless @needsupdate
+          requires :identity, :description
+
+          body = attributes.dup
+
+          body[:description] = description
+
+          if (floating_ip = service.update_floating_ip(identity, body).body['floating_ip'])
+            merge_attributes(floating_ip)
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end