lunanode 0.1.5

data/lib/lunanode/api.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "json"
+require "rest-client"
+
+module Lunanode
+  # Class for accessing the Lunanode API.
+  #
+  # The class is instantiated by either passing it a JSON file containing
+  # the keys `api_id` and `api_key`, or specifying the ID and key directly:
+  #   api = Lunanode::API.new("credentials_file.json")
+  #   api = Lunanode::API.new(api_id: "ABCDEFG", api_key: "HIJKLMNOP")
+  #
+  # Once instantiated, action methods follow the example:
+  #   api.vm_list # no parameters
+  #   api.vm_info(vm_id: "My-VM-ID") # required parameters
+  #   api.image_list(region: "Toronto") # optional parameters
+  #
+  # Required and optional arguments are specified in the method definitions,
+  # but can can be queried via {API.params_for}. They follow the API
+  # specification athttps://wiki.lunanode.com/index.php/API
+  #
+  class API
+    #
+    # Class-level definitions
+    #
+
+    API_ENDPOINT = "https://dynamic.lunanode.com/api/".freeze
+    @params_for = {}
+
+    # Show parameter info for any API method.
+    #
+    # @param method_name[#to_sym] The name of the API method
+    # @return [Hash] information about the method parameters
+    #
+    def self.params_for(method_name)
+      @params_for[method_name] ||= begin
+        method_name = method_name.to_sym
+        param_groups = instance_method(method_name).parameters.group_by(&:first)
+        out = {
+          required: param_groups[:keyreq] && param_group[:keyreq].map(&:last),
+          optional: param_groups[:key] && param_groups[:key].map(&:last),
+          additional: param_groups.key?(:keyrest),
+        }
+        out.each do |k, v|
+          if v
+            v.freeze
+          else
+            out.delete(k)
+          end
+        end
+        out.freeze
+      end
+    end
+
+    #
+    # Instance-level definitions
+    #
+
+    include APIActions
+    attr_reader :api_id
+
+    # @overload initialize(credentials_file)
+    #   Instantiate an API object from a credentials file.
+    #   @param credentials_file[IO,String] a JSON credentials file
+    #     (which contains the keys `api_id` and `api_key`)
+    #
+    # @overload initialize(api_id: nil, api_key: nil)
+    #   Instantiate an API object from an API ID and API Key.
+    #   @param api_id[String] A LunaNode API ID
+    #   @param api_key[String] A LunaNode API Key
+    #
+    def initialize(credentials_file = nil, api_id: nil, api_key: nil)
+      if !credentials_file.nil? && File.exist?(credentials_file)
+        credentials_data = File.read(credentials_file)
+        credentials = JSON.parse(credentials_data, symbolize_names: true)
+        @api_id = credentials[:api_id]
+        @api_key = credentials[:api_key]
+      else
+        @api_id = api_id
+        @api_key = api_key
+      end
+      @api_id = @api_id.to_s.freeze
+      @api_key = @api_key.to_s.freeze
+      @rest_client = RestClient::Resource.new(
+        API_ENDPOINT,
+        verify_ssl: OpenSSL::SSL::VERIFY_PEER
+      )
+    end
+
+    # Display a string representation of the object without key information.
+    def inspect
+      "#<#{self.class.name}: api_id=#{api_id.inspect}>"
+    end
+    alias to_s inspect
+
+    # Send an arbitrary API action without any parameter checks.
+    #
+    # @param category[#to_sym] The API action category (i.e. dns, image, vm...)
+    # @param action[#to_sym] The API action name (i.e. create, list...)
+    # @param params[Hash] Any parameters required for the action.
+    #
+    # @return [Hash,Array,String] Response data from the API action.
+    # @raise [APIError] If there was a problem with the action.
+    #
+    def action(category, action, **params)
+      resp = call_api("#{category}/#{action}/", params)
+      raise APIError, %("#{resp[:error]}") unless resp[:success] == "yes"
+      resp.delete(:success)
+
+      if resp.size == 1
+        resp.values.first
+      else
+        resp
+      end
+    end
+
+    private
+
+    attr_reader :api_key, :rest_client
+
+    # Make an API call and return response.
+    def call_api(handler_path, params)
+      req_formdata = auth_request_formdata(handler_path, clean_params(params))
+      JSON.parse(rest_client[handler_path].post(req_formdata),
+                 symbolize_names: true)
+    rescue RestClient::Exception => err
+      err.message += "\n  Request Path: #{rest_client.url}#{handler_path}" \
+                     "\n  Request Data: #{req_data}"
+      raise err
+    end
+
+    # Clean empty request parameters
+    def clean_params(params)
+      params.each_with_object({}) do |(k, v), acc|
+        if k && k.respond_to?(:to_sym) && v && v.respond_to?(:to_s)
+          acc[k.to_sym] = v.to_s
+        end
+      end
+    end
+
+    # Create signed request data
+    def auth_request_formdata(handler_path, params)
+      req_msg = raw_request_message(params)
+      nonce = gen_nonce
+      signature = gen_signature(handler_path, req_msg, nonce)
+      {
+        req: req_msg,
+        signature: signature,
+        nonce: nonce,
+      }
+    end
+
+    # Generate raw, unsigned request message.
+    def raw_request_message(params)
+      params[:api_id] = api_id
+      params[:api_partialkey] = api_key.slice(0, 64)
+      params.to_json
+    end
+
+    # Generate nonce for request
+    def gen_nonce
+      Time.now.utc.to_i.to_s
+    end
+
+    # Generate signature for request
+    def gen_signature(handler_path, req_msg, nonce)
+      message = "#{handler_path}|#{req_msg}|#{nonce}"
+      OpenSSL::HMAC.hexdigest("SHA512", api_key, message)
+    end
+  end
+end

data/lib/lunanode/api_actions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "lunanode/api_actions/dns"
+require "lunanode/api_actions/email"
+require "lunanode/api_actions/floating"
+require "lunanode/api_actions/image"
+require "lunanode/api_actions/lb"
+require "lunanode/api_actions/monitor"
+require "lunanode/api_actions/network"
+require "lunanode/api_actions/plan"
+require "lunanode/api_actions/region"
+require "lunanode/api_actions/script"
+require "lunanode/api_actions/securitygroup"
+require "lunanode/api_actions/vm"
+require "lunanode/api_actions/volume"
+
+module Lunanode
+  # Module containing all API action methods included from various component
+  # modules.
+  #
+  # Standard API action methods were automatically generated from a datafile to
+  # specifying all required and optional parameters as keyword arguments.
+  #
+  # See https://wiki.lunanode.com/index.php/API for more details on the
+  # individual actions and parameters.
+  module APIActions
+    # Modules are included in reverse order so that YARD shows them correctly.
+    include Volume
+    include VM
+    include Securitygroup
+    include Script
+    include Plan
+    include Network
+    include Monitor
+    include LB
+    include Image
+    include Floating
+    include Email
+    include DNS
+  end
+end

data/lib/lunanode/api_actions/default/dns.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lunanode
+  module APIActions
+    module DNS
+      def dns_list
+        action(:dns, :list)
+      end
+
+      def dns_set(ip:, hostname:)
+        action(:dns, :set, ip: ip, hostname: hostname)
+      end
+
+      def dns_zone_list
+        action(:dns, :zone_list)
+      end
+
+      def dns_zone_add(origin:, ttl: nil)
+        action(:dns, :zone_add, origin: origin, ttl: ttl)
+      end
+
+      def dns_zone_remove(zone_id:)
+        action(:dns, :zone_remove, zone_id: zone_id)
+      end
+
+      def dns_record_list(zone_id:)
+        action(:dns, :record_list, zone_id: zone_id)
+      end
+
+      def dns_record_add(zone_id:, name:, data:, ttl:, type:)
+        action(:dns, :record_add, zone_id: zone_id, name: name, data: data, ttl: ttl, type: type)
+      end
+
+      def dns_record_remove(record_id:)
+        action(:dns, :record_remove, record_id: record_id)
+      end
+
+      def dns_dyn_list
+        action(:dns, :dyn_list)
+      end
+
+      def dns_dyn_add(name:, ip:)
+        action(:dns, :dyn_add, name: name, ip: ip)
+      end
+
+      def dns_dyn_update(dyn_id:, name:, ip:)
+        action(:dns, :dyn_update, dyn_id: dyn_id, name: name, ip: ip)
+      end
+
+      def dns_dyn_remove(dyn_id:)
+        action(:dns, :dyn_remove, dyn_id: dyn_id)
+      end
+    end
+  end
+end

data/lib/lunanode/api_actions/default/email.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lunanode
+  module APIActions
+    module Email
+      def email_usage
+        action(:email, :usage)
+      end
+
+      def email_domain_list
+        action(:email, :domain_list)
+      end
+
+      def email_domain_add(name:)
+        action(:email, :domain_add, name: name)
+      end
+
+      def email_domain_remove(domain_id:)
+        action(:email, :domain_remove, domain_id: domain_id)
+      end
+
+      def email_domain_dkim_set(domain_id:, selector:, private_key:)
+        action(:email, :domain_dkim_set, domain_id: domain_id, selector: selector, private_key: private_key)
+      end
+
+      def email_domain_dkim_unset(domain_id:)
+        action(:email, :domain_dkim_unset, domain_id: domain_id)
+      end
+
+      def email_user_list(domain_id:)
+        action(:email, :user_list, domain_id: domain_id)
+      end
+
+      def email_user_add(domain_id:, username:, password:)
+        action(:email, :user_add, domain_id: domain_id, username: username, password: password)
+      end
+
+      def email_user_set_password(domain_id:, user_id:, password:)
+        action(:email, :user_set_password, domain_id: domain_id, user_id: user_id, password: password)
+      end
+
+      def email_user_remove(domain_id:, user_id:)
+        action(:email, :user_remove, domain_id: domain_id, user_id: user_id)
+      end
+
+      def email_alias_list(domain_id:)
+        action(:email, :alias_list, domain_id: domain_id)
+      end
+
+      def email_alias_add(domain_id:, name:, target:)
+        action(:email, :alias_add, domain_id: domain_id, name: name, target: target)
+      end
+
+      def email_alias_remove(domain_id:, alias_id:)
+        action(:email, :alias_remove, domain_id: domain_id, alias_id: alias_id)
+      end
+    end
+  end
+end

data/lib/lunanode/api_actions/default/floating.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lunanode
+  module APIActions
+    module Floating
+      def floating_list
+        action(:floating, :list)
+      end
+
+      def floating_add(region:)
+        action(:floating, :add, region: region)
+      end
+
+      def floating_delete(region:, ip:)
+        action(:floating, :delete, region: region, ip: ip)
+      end
+    end
+  end
+end

data/lib/lunanode/api_actions/default/image.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lunanode
+  module APIActions
+    module Image
+      def image_list(region: nil)
+        action(:image, :list, region: region)
+      end
+
+      def image_delete(image_id:)
+        action(:image, :delete, image_id: image_id)
+      end
+
+      def image_details(image_id:)
+        action(:image, :details, image_id: image_id)
+      end
+
+      def image_replicate(image_id:, region:)
+        action(:image, :replicate, image_id: image_id, region: region)
+      end
+
+      def image_fetch(region:, name:, location:, format:, virtio: nil)
+        action(:image, :fetch, region: region, name: name, location: location, format: format, virtio: virtio)
+      end
+
+      def image_retrieve(image_id:)
+        action(:image, :retrieve, image_id: image_id)
+      end
+    end
+  end
+end

data/lib/lunanode/api_actions/default/lb.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lunanode
+  module APIActions
+    module LB
+      def lb_list(region:, net_id: nil)
+        action(:lb, :list, region: region, net_id: net_id)
+      end
+
+      def lb_create(region:, net_id:, name:, method:, protocol:, connection_limit:, port:)
+        action(:lb, :create, region: region, net_id: net_id, name: name, method: method, protocol: protocol, connection_limit: connection_limit, port: port)
+      end
+
+      def lb_delete(region:, lb_id:)
+        action(:lb, :delete, region: region, lb_id: lb_id)
+      end
+
+      def lb_info(region:, lb_id:)
+        action(:lb, :info, region: region, lb_id: lb_id)
+      end
+
+      def lb_member_add(region:, lb_id:, ip:, port:)
+        action(:lb, :member_add, region: region, lb_id: lb_id, ip: ip, port: port)
+      end
+
+      def lb_member_remove(region:, lb_id:, member_id:)
+        action(:lb, :member_remove, region: region, lb_id: lb_id, member_id: member_id)
+      end
+
+      def lb_associate(region:, lb_id:, ip:)
+        action(:lb, :associate, region: region, lb_id: lb_id, ip: ip)
+      end
+    end
+  end
+end

data/lib/lunanode/api_actions/default/monitor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lunanode
+  module APIActions
+    module Monitor
+      def monitor_check_list
+        action(:monitor, :check_list)
+      end
+
+      def monitor_check_types
+        action(:monitor, :check_types)
+      end
+
+      def monitor_check_add(name:, type:, fail_count:, success_count:, check_interval:, **from_check_type)
+        action(:monitor, :check_add, name: name, type: type, fail_count: fail_count, success_count: success_count, check_interval: check_interval, **from_check_type)
+      end
+
+      def monitor_check_remove(check_id:)
+        action(:monitor, :check_remove, check_id: check_id)
+      end
+
+      def monitor_contact_list
+        action(:monitor, :contact_list)
+      end
+
+      def monitor_contact_add
+        action(:monitor, :contact_add)
+      end
+
+      def monitor_contact_remove(type:, rel:)
+        action(:monitor, :contact_remove, type: type, rel: rel)
+      end
+
+      def monitor_alert_list(check_id:)
+        action(:monitor, :alert_list, check_id: check_id)
+      end
+
+      def monitor_alert_add(check_id:, contact_id:)
+        action(:monitor, :alert_add, check_id: check_id, contact_id: contact_id)
+      end
+
+      def monitor_alert_remove(alert_id:)
+        action(:monitor, :alert_remove, alert_id: alert_id)
+      end
+    end
+  end
+end