hyperkit 1.0.0

data/lib/hyperkit/client/networks.rb

@@ -0,0 +1,47 @@
+module Hyperkit
+
+  class Client
+
+    # Methods for the networks API
+    # 
+    # @see Hyperkit::Client
+    # @see https://github.com/lxc/lxd/blob/master/specs/rest-api.md
+    module Networks
+
+      # List of networks defined on the host
+      #
+      # @return [Array<String>] An array of networks defined on the host
+      #
+      # @example Get list of networks
+      #   Hyperkit.networks #=> ["lo", "eth0", "lxcbr0"]
+      def networks
+        response = get(networks_path)
+        response.metadata.map { |path| path.split('/').last }
+      end
+
+      # Get information on a network
+      #
+      # @return [Sawyer::Resource] Network information
+      #
+      # @example Get information about lxcbr0
+      #   Hyperkit.network("lxcbr0") #=> {:name=>"lxcbr0", :type=>"bridge", :used_by=>[]}
+      def network(name)
+        get(network_path(name)).metadata
+      end
+
+      private
+
+      def network_path(name)
+        File.join(networks_path, name)
+      end
+
+      def networks_path
+        "/1.0/networks"
+      end
+ 
+    end
+
+  end
+
+end
+

data/lib/hyperkit/client/operations.rb

@@ -0,0 +1,123 @@
+require 'active_support/core_ext/hash/except'
+
+module Hyperkit
+
+  class Client
+
+    # Methods for the operations API
+    # 
+    # @see Hyperkit::Client
+    # @see https://github.com/lxc/lxd/blob/master/specs/rest-api.md
+    module Operations
+
+      # List of operations active on the server
+      #
+      # This will include operations that are currently executing, as well as
+      # operations that are paused until {#wait_for_operation} is called, at
+      # which time they will begin executing. 
+      #
+      # Additionally, since LXD keeps completed operations around for 5 seconds,
+      # the list returned may include recently completed operations.
+      #
+      # @return [Array<String>] An array of UUIDs identifying waiting, active, and recently completed (<5 seconds) operations
+      #
+      # @example Get list of operations
+      #   Hyperkit.operations #=> ["931e27fb-2057-4cbe-a49d-fd114713fa74"]
+      def operations
+        response = get(operations_path)
+        response.metadata.to_h.values.flatten.map { |path| path.split('/').last }
+      end
+
+      # Retrieve information about an operation
+      #
+      # @param [String] uuid UUID of the operation
+      # @return [Sawyer::Resource] Operation information
+      #
+      # @example Retrieve information about an operation
+      #   Hyperkit.operation("d5f359ae-ddcb-4f09-a8f8-0cc2f3c8b0df") #=> {
+      #     :id => "d5f359ae-ddcb-4f09-a8f8-0cc2f3c8b0df",
+      #     :class => "task",
+      #     :created_at => 2016-04-14 21:30:59 UTC,
+      #     :updated_at => 2016-04-14 21:30:59 UTC,
+      #     :status => "Running",
+      #     :status_code => 103, 
+      #     :resources => {
+      #       :containers => ["/1.0/containers/test-container"]
+      #     },
+      #     :metadata => nil,
+      #     :may_cancel => false,
+      #     :err => ""
+      #   }
+      def operation(uuid)
+        get(operation_path(uuid)).metadata
+      end
+
+      # Cancel a running operation
+      #
+      # Calling this will change the state of the operation to 
+      # <code>cancelling</code>.  Note that the operation must be cancelable,
+      # which can be ascertained by calling {#operation} and checking the 
+      # <code>may_cancel</code> property.
+      #
+      # @param [String] uuid UUID of the operation
+      # @return [Sawyer::Resource] 
+      #
+      # @example Cancel an operation
+      #   Hyperkit.cancel_operation("8b3dd0c2-9dad-4964-b00d-e21481a47fb8") => {}
+      def cancel_operation(uuid)
+        delete(operation_path(uuid)).metadata
+      end
+
+      # Wait for an asynchronous operation to complete
+      #
+      # Note that this is only needed if {#Hyperkit::auto_sync} has been
+      # set to <code>false</code>, or if the option <code>sync: false</code>
+      # has been passed to an asynchronous method.
+      #
+      # @param [String] uuid UUID of the operation
+      # @param [Fixnum] timeout Maximum time to wait (default: indefinite)
+      # @return [Sawyer::Resource] Operation result
+      #
+      # @example Wait for the creation of a container
+      #   Hyperkit.auto_sync = false
+      #   op = Hyperkit.create_container("test-container", alias: "ubuntu/amd64/default")
+      #   Hyperkit.wait_for_operation(op.id)
+      #
+      # @example Wait, but time out if the operation is not complete after 30 seconds
+      #   op = Hyperkit.copy_container("test1", "test2", sync: false)
+      #   Hyperkit.wait_for_operation(op.id, timeout: 30)
+      def wait_for_operation(uuid, timeout=nil)
+        url = File.join(operation_path(uuid), "wait")
+        url += "?timeout=#{timeout}" if timeout.to_i > 0
+
+        get(url).metadata
+      end
+
+      private
+
+      def handle_async(response, sync)
+
+        sync = sync.nil? ? auto_sync : sync
+
+        if sync 
+          wait_for_operation(response.id)
+        else
+          response
+        end
+
+      end
+
+      def operation_path(uuid)
+        File.join(operations_path, uuid)
+      end
+
+      def operations_path 
+        "/1.0/operations"
+      end
+ 
+    end
+
+  end
+
+end
+

data/lib/hyperkit/client/profiles.rb

@@ -0,0 +1,59 @@
+require 'active_support/core_ext/hash/except'
+
+module Hyperkit
+
+  class Client
+
+    # Methods for the profiles API
+    # 
+    # @see Hyperkit::Client
+    # @see https://github.com/lxc/lxd/blob/master/specs/rest-api.md
+    module Profiles
+
+      # GET /profiles
+      def profiles
+        response = get(profiles_path)
+        response.metadata.map { |path| path.split('/').last }
+      end
+
+      # POST /profiles
+      def create_profile(name, options={})
+        options = options.merge(name: name)
+        post(profiles_path, options).metadata
+      end
+
+      # GET /profiles/<name>
+      def profile(name)
+        get(profile_path(name)).metadata
+      end
+
+      # PUT /profiles/<name>
+      def update_profile(name, options={})
+        put(profile_path(name), options.except(:name)).metadata
+      end
+
+      # POST /profiles/<name>
+      def rename_profile(old_name, new_name)
+        post(profile_path(old_name), { name: new_name }).metadata
+      end
+
+      # DELETE /profiles/<name>
+      def delete_profile(name)
+        delete(profile_path(name)).metadata
+      end
+
+      private
+
+      def profiles_path
+        "/1.0/profiles"
+      end
+ 
+      def profile_path(name)
+        File.join(profiles_path, name)
+      end
+
+    end
+
+  end
+
+end

data/lib/hyperkit/configurable.rb

@@ -0,0 +1,110 @@
+################################################################################
+#                                                                              #
+# Modeled on Octokit::Configurable                                             #
+#                                                                              #
+# Original Octokit license                                                     #
+# ---------------------------------------------------------------------------- #
+# Copyright (c) 2009-2016 Wynn Netherland, Adam Stacoviak, Erik Michaels-Ober  #
+#                                                                              #
+# Permission is hereby granted, free of charge, to any person obtaining a      #
+# copy of this software and associated documentation files (the "Software"),   #
+# to deal in the Software without restriction, including without limitation    #
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,     #
+# and/or sell copies of the Software, and to permit persons to whom the        #
+# Software is furnished to do so, subject to the following conditions:         #
+#                                                                              #
+# The above copyright notice and this permission notice shall be included      #
+# in all copies or substantial portions of the Software.                       #
+# ---------------------------------------------------------------------------- #
+#                                                                              #
+################################################################################
+
+
+module Hyperkit
+
+  # Configuration options for {Client}, defaulting to values
+  # in {Default}
+  module Configurable
+
+    # @!attribute api_endpoint
+    #   @return [String] the base URL for API requests (default: <code>https://localhost:8443/</code>)
+    # @!attribute auto_sync
+    #   @return [String] whether to automatically wait on asynchronous events (default: <code>true</code>)
+    # @!attribute client_cert
+    #   @return [String] the client certificate used to authenticate to the LXD server
+    # @!attribute client_key 
+    #   @return [String] the client key used to authenticate to the LXD server
+    # @!attribute default_media_type
+    #   @return [String] the preferred media type (for API versioning, for example)
+    # @!attribute middleware
+    #   @see https://github.com/lostisland/faraday
+    #   @return [Faraday::Builder or Faraday::RackBuilder] middleware for Faraday
+    # @!attribute proxy
+    #   @see https://github.com/lostisland/faraday
+    #   @return [String] the URI of a proxy server used to connect to the LXD server
+    # @!attribute user_agent
+    #   @return [String] the <code>User-Agent</code> header used for requests made to the LXD server
+    # @!attribute verify_ssl
+    #   @return [Boolean] whether or not to verify the LXD server's SSL certificate
+
+    attr_accessor :auto_sync, :client_cert, :client_key, :default_media_type,
+                  :middleware, :proxy, :user_agent, :verify_ssl
+
+    attr_writer :api_endpoint
+
+    class << self
+
+      # List of configurable keys for {Hyperkit::Client}
+      # @return [Array] of option keys
+      def keys
+        @keys ||= [
+          :api_endpoint,
+          :auto_sync,
+          :client_cert,
+          :client_key,
+          :default_media_type,
+          :middleware,
+          :proxy,
+          :user_agent,
+          :verify_ssl
+        ]
+      end
+
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Hyperkit::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Hyperkit::Default.options[key])
+      end
+      self
+    end
+
+    alias setup reset!
+
+    # Compares client options to a Hash of requested options
+    #
+    # @param opts [Hash] Options to compare with current client options
+    # @return [Boolean]
+    def same_options?(opts)
+      opts.hash == options.hash
+    end
+
+    def api_endpoint
+      File.join(@api_endpoint, "")
+    end
+
+    private
+
+    def options
+      Hash[Hyperkit::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+  end
+
+end

data/lib/hyperkit/connection.rb

@@ -0,0 +1,196 @@
+################################################################################
+#                                                                              #
+# Based on Octokit::Connection                                                 #
+#                                                                              #
+# Original Octokit license                                                     #
+# ---------------------------------------------------------------------------- #
+# Copyright (c) 2009-2016 Wynn Netherland, Adam Stacoviak, Erik Michaels-Ober  #
+#                                                                              #
+# Permission is hereby granted, free of charge, to any person obtaining a      #
+# copy of this software and associated documentation files (the "Software"),   #
+# to deal in the Software without restriction, including without limitation    #
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,     #
+# and/or sell copies of the Software, and to permit persons to whom the        #
+# Software is furnished to do so, subject to the following conditions:         #
+#                                                                              #
+# The above copyright notice and this permission notice shall be included      #
+# in all copies or substantial portions of the Software.                       #
+# ---------------------------------------------------------------------------- #
+#                                                                              #
+################################################################################
+
+require 'sawyer'
+
+module Hyperkit
+
+  # Network layer for API clients.
+  module Connection
+
+    # Header keys that can be passed in options hash to {#get},{#head}
+    CONVENIENCE_HEADERS = Set.new([:accept, :content_type])
+
+    # Make a HTTP GET request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def get(url, options = {})
+      request :get, url, parse_query_and_convenience_headers(options)
+    end
+
+    # Make a HTTP POST request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Body and header params for request
+    # @return [Sawyer::Resource]
+    def post(url, options = {})
+      request :post, url, options
+    end
+
+    # Make a HTTP PUT request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Body and header params for request
+    # @return [Sawyer::Resource]
+    def put(url, options = {})
+      request :put, url, options
+    end
+
+    # Make a HTTP PATCH request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Body and header params for request
+    # @return [Sawyer::Resource]
+    def patch(url, options = {})
+      request :patch, url, options
+    end
+
+    # Make a HTTP DELETE request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def delete(url, options = {})
+      request :delete, url, options
+    end
+
+    # Make a HTTP HEAD request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def head(url, options = {})
+      request :head, url, parse_query_and_convenience_headers(options)
+    end
+
+    # Hypermedia agent for the GitHub API
+    #
+    # @return [Sawyer::Agent]
+    def agent
+      @agent ||= Sawyer::Agent.new(endpoint, sawyer_options) do |http|
+        http.headers[:accept] = default_media_type
+        http.headers[:content_type] = "application/json"
+        http.headers[:user_agent] = user_agent
+      end
+    end
+
+    # Fetch the root resource for the API
+    #
+    # @return [Sawyer::Resource]
+    def root
+      get "/"
+    end
+
+    # Response for last HTTP request
+    #
+    # @return [Sawyer::Response]
+    def last_response
+      @last_response if defined? @last_response
+    end
+
+    protected
+
+    def endpoint
+      api_endpoint
+    end
+
+    private
+
+    def reset_agent
+      @agent = nil
+    end
+
+    def request(method, path, data, options = {})
+      if data.is_a?(Hash)
+        options[:query]   = data.delete(:query) || {}
+        options[:headers] = data.delete(:headers) || {}
+        url_encode = data.delete(:url_encode) || true
+
+        if accept = data.delete(:accept)
+          options[:headers][:accept] = accept
+        end
+        if data[:raw_body]
+          data = data[:raw_body]
+        end
+      end
+
+      path = URI::Parser.new.escape(path.to_s) if url_encode
+
+      @last_response = response = agent.call(method, path, data, options)
+      response.data
+    end
+
+    # Executes the request, checking if it was successful
+    #
+    # @return [Boolean] True on success, false otherwise
+    def boolean_from_response(method, path, options = {})
+      request(method, path, options)
+      @last_response.status == 204
+    rescue Hyperkit::NotFound
+      false
+    end
+
+
+    def sawyer_options
+      opts = {
+        :links_parser => Sawyer::LinkParsers::Simple.new,
+      }
+      conn_opts = {}
+      conn_opts[:builder] = @middleware if @middleware
+      conn_opts[:proxy] = @proxy if @proxy
+
+      conn_opts[:ssl] = {
+        verify: verify_ssl
+      }
+
+      if client_cert && File.exist?(client_cert)
+        conn_opts[:ssl][:client_cert] = OpenSSL::X509::Certificate.new(File.read(client_cert))
+      end
+      
+      if client_key && File.exist?(client_key)
+        conn_opts[:ssl][:client_key] = OpenSSL::PKey::RSA.new(File.read(client_key)) 
+      end
+
+      opts[:faraday] = Faraday.new(conn_opts)
+
+      opts
+    end
+
+    def parse_query_and_convenience_headers(options)
+      headers = options.delete(:headers) { Hash.new }
+      CONVENIENCE_HEADERS.each do |h|
+        if header = options.delete(h)
+          headers[h] = header
+        end
+      end
+      query = options.delete(:query)
+      opts = {:query => options}
+      opts[:query].merge!(query) if query && query.is_a?(Hash)
+      opts[:headers] = headers unless headers.empty?
+
+      opts
+    end
+
+  end
+
+end