lxd-common 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2862f300294934ad732a85a91460a901ddca30a1371b59f3c52d4823f845ba22
-  data.tar.gz: cf9f7a414093dce415a457d144ea222ae8bc5e106d18df00a9d0510c61876ce2
+  metadata.gz: 031530f1093174e61e18c8a58e85805376bbc9b80368c800f7cc28cc3476e8ac
+  data.tar.gz: 0dea2d0bdb81700c0b0c05b990620fef2ae999b0828d1ddee0714e54a914909f
 SHA512:
-  metadata.gz: d21f7a64be74067ff98a0170f0acb5006c1827000c3cc5dbe87f944c74fd362fd1b20202b3936e36ea84544b53159122b565732065a63d764f2bee5838a185fc
-  data.tar.gz: 91f6e12a53b3255b53f04dd875777b79c548d01aa4c88fcae6e5a240a45071704e1ab62c84480e56bb251627e7054df675a9cebe697c7e5a93a2d0485f346267
+  metadata.gz: 677d8545906f020bb8a485362cc39e8b7d809a96822fdeb05225d65f9da79bd1865c5105c3b3706946fc29ed09d3d0cbab4efb8c67c4acdd8724d6f41184f75f
+  data.tar.gz: 18772ed5c102a70bc3e0fdacb0742c7de807d210e339ba83d1db5efc61fc529e36ef423f364f630a3215564e99225b2771572d3699e231617fb2dbad3643f8a4

data/.travis.yml

@@ -2,8 +2,8 @@ sudo: false
 language: ruby
 rvm:
 - 2.1.0
-- 2.3.1
-- 2.4.2
+- 2.4.3
+- 2.5.0
 - ruby-head
 matrix:
   allow_failures:
@@ -32,4 +32,4 @@ deploy:
   gem: lxd-common
   on:
     tags: true
-    rvm: 2.4.2
+    rvm: 2.4.3

data/lib/nexussw/lxd/driver/mixins/cli.rb

@@ -103,7 +103,7 @@ module NexusSW
             res = inner_transport.execute("lxc list #{container_id} --format=json")
             res.error!
             JSON.parse(res.stdout).each do |c|
-              return convert_keys(c.except('state')) if c['name'] == container_id
+              return convert_keys(c.reject { |k, _| k == 'state' }) if c['name'] == container_id
             end
             nil
           end

data/lib/nexussw/lxd/driver/mixins/rest.rb

@@ -1,6 +1,6 @@
+require 'nexussw/lxd/rest_api'
 require 'nexussw/lxd/driver/mixins/helpers/wait'
 require 'nexussw/lxd/transport/rest'
-require 'hyperkit'
 
 module NexusSW
   module LXD
@@ -10,27 +10,26 @@ module NexusSW
           # PARITY note: CLI functions are on an indefinite timeout by default, yet we have a 2 minute socket read timeout
           # Leaving it alone, for now, on calls that are quick in nature
           # Adapting on known long running calls such as create, stop, execute
-          # REQUEST_TIMEOUT = 120 # upstream default: 120
           def initialize(rest_endpoint, driver_options = {}, inner_driver = nil)
             @rest_endpoint = rest_endpoint
             @driver_options = driver_options
-            hkoptions = (driver_options || {}).merge(
+            apioptions = (driver_options || {}).merge(
               api_endpoint: rest_endpoint,
               auto_sync: true
             )
-            @hk = inner_driver || Hyperkit::Client.new(hkoptions)
+            @api = inner_driver || RestAPI.new(apioptions)
           end
 
-          attr_reader :hk, :rest_endpoint, :driver_options
+          attr_reader :api, :rest_endpoint, :driver_options
 
           include Helpers::WaitMixin
 
           def server_info
-            @server_info ||= hk.get('/1.0')[:metadata]
+            @server_info ||= api.get('/1.0')[:metadata]
           end
 
           def transport_for(container_name)
-            Transport::Rest.new container_name, info: server_info, connection: hk, driver_options: driver_options, rest_endpoint: rest_endpoint
+            Transport::Rest.new container_name, info: server_info, connection: api, driver_options: driver_options, rest_endpoint: rest_endpoint
           end
 
           def create_container(container_name, container_options = {})
@@ -40,7 +39,7 @@ module NexusSW
             end
             # parity note: CLI will run indefinitely rather than timeout hence the 0 timeout
             retry_forever do
-              @hk.create_container(container_name, container_options.merge(sync: false))
+              api.create_container(container_name, container_options.merge(sync: false))
             end
             start_container container_name
             container_name
@@ -49,7 +48,7 @@ module NexusSW
           def start_container(container_id)
             return if container_status(container_id) == 'running'
             retry_forever do
-              @hk.start_container(container_id, sync: false)
+              api.start_container(container_id, sync: false)
             end
             wait_for_status container_id, 'running'
           end
@@ -57,7 +56,7 @@ module NexusSW
           def stop_container(container_id, options = {})
             return if container_status(container_id) == 'stopped'
             if options[:force]
-              @hk.stop_container(container_id, force: true)
+              api.stop_container(container_id, force: true)
             else
               last_id = nil
               use_last = false
@@ -67,14 +66,14 @@ module NexusSW
                   unless use_last
                     # Keep resubmitting until the server complains (Stops will be ignored/hang if init is not yet listening for SIGPWR i.e. recently started)
                     begin
-                      last_id = @hk.stop_container(container_id, sync: false)[:id]
-                    rescue Hyperkit::BadRequest # Happens if a stop command has previously been accepted as well as other reasons.  handle that on next line
+                      last_id = api.stop_container(container_id, sync: false)[:metadata][:id]
+                    rescue NexusSW::LXD::RestAPI::Error::BadRequest # Happens if a stop command has previously been accepted as well as other reasons.  handle that on next line
                       # if we have a last_id then a prior stop command has successfully initiated so we'll just wait on that one
                       raise unless last_id # rubocop:disable Metrics/BlockNesting
                       use_last = true
                     end
                   end
-                  @hk.wait_for_operation last_id # , options[:retry_interval]
+                  api.wait_for_operation last_id # , options[:retry_interval]
                 rescue Faraday::TimeoutError => e
                   return if container_status(container_id) == 'stopped'
                   raise Timeout::Retry.new e # if options[:retry_interval] # rubocop:disable Style/RaiseArgs
@@ -89,33 +88,35 @@ module NexusSW
             stop_container container_id, force: true
 
             # ISSUE 17: something upstream is causing a double-tap on the REST endpoint
-            begin
-              @hk.delete_container container_id
-            rescue ::Faraday::ConnectionFailed, ::Hyperkit::BadRequest
-              LXD.with_timeout_and_retries timeout: 120 do
-                loop do
-                  return unless container_exists? container_id
-                  sleep 0.3
-                end
-              end
-            end
+
+            # trial return to normal
+            # begin
+            api.delete_container container_id
+            # rescue ::Faraday::ConnectionFailed, ::NexusSW::LXD::RestAPI::Error::BadRequest
+            #   LXD.with_timeout_and_retries timeout: 120 do
+            #     loop do
+            #       return unless container_exists? container_id
+            #       sleep 0.3
+            #     end
+            #   end
+            # end
           end
 
           def container_status(container_id)
-            STATUS_CODES[container(container_id)[:status_code].to_i]
+            STATUS_CODES[api.container(container_id)[:metadata][:status_code].to_i]
           end
 
           def container_state(container_id)
             return nil unless container_status(container_id) == 'running' # Parity with CLI
-            @hk.container_state(container_id)
+            api.container_state(container_id)[:metadata]
           end
 
           def container(container_id)
-            @hk.container container_id
+            api.container(container_id)[:metadata]
           end
 
           def container_exists?(container_id)
-            hk.containers.include? container_id
+            api.containers[:metadata].map { |url| url.split('/').last }.include? container_id
           end
 
           protected
@@ -133,7 +134,7 @@ module NexusSW
             retval = yield
             LXD.with_timeout_and_retries timeout: 0 do
               begin
-                @hk.wait_for_operation retval[:id]
+                api.wait_for_operation retval[:metadata][:id]
               rescue Faraday::TimeoutError => e
                 raise Timeout::Retry.new e # rubocop:disable Style/RaiseArgs
               end

data/lib/nexussw/lxd/rest_api/connection.rb

@@ -0,0 +1,98 @@
+require 'faraday'
+require 'json'
+require 'openssl'
+
+module NexusSW
+  module LXD
+    class RestAPI
+      module Connection
+        def get(relative_url, &block)
+          send_request :get, relative_url, &block
+        end
+
+        def put(relative_url, content)
+          send_request :put, relative_url, content
+        end
+
+        def patch(relative_url, content)
+          send_request :patch, relative_url, content
+        end
+
+        def post(relative_url, content, &block)
+          send_request :post, relative_url, content, &block
+        end
+
+        def delete(relative_url)
+          send_request :delete, relative_url
+        end
+
+        private
+
+        def connection(&block)
+          return @conn if @conn
+
+          opts = {
+            url: baseurl,
+            ssl: {
+              verify: verify_ssl,
+              client_cert: OpenSSL::X509::Certificate.new(cert),
+              client_key: OpenSSL::PKey::RSA.new(key),
+            },
+          }
+
+          @conn = Faraday.new opts, &block
+        end
+
+        def baseurl
+          api_options[:api_endpoint]
+        end
+
+        def ssl_opts
+          api_options[:ssl] || {}
+        end
+
+        def cert
+          File.read(ssl_opts[:client_cert] || "#{ENV['HOME']}/.config/lxc/client.crt")
+        end
+
+        def key
+          File.read(ssl_opts[:client_key] || "#{ENV['HOME']}/.config/lxc/client.key")
+        end
+
+        def verify_ssl
+          return ssl_opts[:verify] if ssl_opts.key? :verify
+          api_options[:verify_ssl].nil? ? true : api_options[:verify_ssl]
+        end
+
+        def parse_response(response)
+          LXD.symbolize_keys(JSON.parse(response.body))
+        end
+
+        def send_request(verb, relative_url, content = nil)
+          response = connection.send(verb) do |req|
+            req.url relative_url
+            if content.is_a? Hash
+              req.headers['Content-Type'] = 'application/json'
+              req.body = content.to_json
+            elsif content # Only upon file upload
+              req.headers['Content-Type'] = 'application/octet-stream'
+              req.headers['X-LXD-uid'] = '0'
+              req.headers['X-LXD-gid'] = '0'
+              req.headers['X-LXD-mode'] = '0600'
+              req.body = content.to_s
+            end
+          end
+          if response.status >= 400
+            err = JSON.parse(response.body)
+            case err['error_code']
+            when 404 then raise RestAPI::Error::NotFound, err['error']
+            when 400 then raise RestAPI::Error::BadRequest, err['error']
+            else raise "Error #{err['error_code']}: #{err['error']}"
+            end
+          end
+          block_given? ? yield(response) : parse_response(response)
+        end
+      end
+    end
+  end
+end

data/lib/nexussw/lxd/rest_api/errors.rb

@@ -0,0 +1,9 @@
+class NexusSW::LXD::RestAPI
+  class Error < RuntimeError
+    class NotFound < Error
+    end
+
+    class BadRequest < Error
+    end
+  end
+end

data/lib/nexussw/lxd/rest_api.rb

@@ -0,0 +1,130 @@
+require 'nexussw/lxd/rest_api/connection'
+require 'nexussw/lxd/rest_api/errors'
+require 'shellwords'
+
+module NexusSW
+  module LXD
+    class RestAPI
+      def initialize(api_options)
+        @api_options = api_options
+      end
+
+      include RestAPI::Connection
+
+      def create_container(container_name, options)
+        options, sync = parse_options options
+        options[:config] = convert_bools(options[:config]) if options.key? :config
+        handle_async post('/1.0/containers', create_source(options).merge(name: container_name)), sync
+      end
+
+      def execute_command(container_name, command, options)
+        options, sync = parse_options options
+        command = command.shellsplit if command.is_a? String
+        handle_async post("/1.0/containers/#{container_name}/exec", options.merge(command: command)), sync
+      end
+
+      def log(container_name, log_name)
+        get "/1.0/containers/#{container_name}/logs/#{log_name}" do |response|
+          return response.body
+        end
+      end
+
+      def delete_log(container_name, log_name)
+        delete "/1.0/containers/#{container_name}/logs/#{log_name}"
+      end
+
+      def start_container(container_name, options)
+        options, sync = parse_options options
+        handle_async put("/1.0/containers/#{container_name}/state", options.merge(action: 'start')), sync
+      end
+
+      def stop_container(container_name, options)
+        options, sync = parse_options options
+        handle_async put("/1.0/containers/#{container_name}/state", options.merge(action: 'stop')), sync
+      end
+
+      def delete_container(container_name, options = {})
+        handle_async delete("/1.0/containers/#{container_name}"), options[:sync]
+      end
+
+      def read_file(container_name, path)
+        get "/1.0/containers/#{container_name}/files?path=#{path}" do |response|
+          return response.body
+        end
+      end
+
+      def write_file(container_name, path, options)
+        post "/1.0/containers/#{container_name}/files?path=#{path}", options[:content]
+      end
+
+      def push_file(local_path, container_name, remote_path)
+        write_file container_name, remote_path, content: IO.binread(local_path)
+      end
+
+      def pull_file(container_name, remote_path, local_path)
+        IO.binwrite(local_path, read_file(container_name, remote_path))
+      end
+
+      def container_state(container_name)
+        get "/1.0/containers/#{container_name}/state"
+      end
+
+      def container(container_name)
+        exceptkeys = %w(config expanded_config)
+        get "/1.0/containers/#{container_name}" do |response|
+          retval = JSON.parse(response.body)
+          lift = retval['metadata'].select { |k, _| exceptkeys.include? k }
+          retval['metadata'].delete_if { |k, _| exceptkeys.include? k }
+          retval = LXD.symbolize_keys(retval)
+          retval[:metadata][:config] = lift['config'] if lift.key? 'config'
+          retval[:metadata][:expanded_config] = lift['expanded_config'] if lift.key? 'expanded_config'
+          return retval
+        end
+      end
+
+      def containers
+        get('/1.0/containers')
+      end
+
+      def wait_for_operation(operation_id)
+        get "/1.0/operations/#{operation_id}/wait" do |response|
+          LXD.symbolize_keys(JSON.parse(response.body))
+        end
+      end
+
+      private
+
+      attr_reader :api_options
+
+      def handle_async(data, sync)
+        return data if sync == false
+        wait_for_operation data[:metadata][:id]
+      end
+
+      def parse_options(options)
+        sync = options[:sync]
+        [options.delete_if { |k, _| k == :sync }, sync]
+      end
+
+      def create_source(options)
+        moveprops = [:type, :alias, :fingerprint, :properties, :protocol, :server]
+        options.dup.tap do |retval|
+          retval[:source] = { type: 'image', mode: 'pull' }.merge(retval.select { |k, _| moveprops.include? k }) unless retval.key? :source
+          retval.delete_if { |k, _| moveprops.include? k }
+        end
+      end
+
+      def convert_bools(hash)
+        {}.tap do |retval|
+          hash.each do |k, v|
+            retval[k] = case v
+                        when true then 'true'
+                        when false then 'false'
+                        else v.is_a?(Hash) ? convert_bools(v) : v
+                        end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexussw/lxd/transport/mixins/cli.rb

@@ -23,7 +23,8 @@ module NexusSW
             mycommand = command.is_a?(Array) ? command.join(' ') : command
             subcommand = options[:subcommand] || "exec #{container_name} --"
             mycommand = "lxc #{subcommand} #{mycommand}"
-            options = options.except :subcommand if options.key? :subcommand
+            # options = options.except :subcommand if options.key? :subcommand
+            options = options.reject { |k, _| k == :subcommand }
             # We would have competing timeout logic depending on who the inner transport is
             # I'll just let rest & local do the timeouts, and if inner is a chef sourced transport, they have timeout logic of their own
             # with_timeout_and_retries(options) do

data/lib/nexussw/lxd/transport/mixins/helpers/execute.rb

@@ -1,3 +1,5 @@
+require 'nexussw/lxd/rest_api/errors'
+
 module NexusSW
   module LXD
     class Transport
@@ -26,7 +28,7 @@ module NexusSW
                 msg = "Error: '#{command}' failed with exit code #{exitstatus}.\n"
                 msg += "STDOUT: #{stdout}" if stdout.is_a?(String) && !stdout.empty?
                 msg += "STDERR: #{stderr}" if stderr.is_a?(String) && !stderr.empty?
-                raise msg
+                raise ::NexusSW::LXD::RestAPI::Error, msg
               end
             end
 
@@ -47,8 +49,8 @@ module NexusSW
             end
 
             class InteractiveResult < ExecuteResult
-              def initialize(command, options, exitstatus, stdin, thread = nil)
-                super(command, options, exitstatus)
+              def initialize(command, options, stdin, thread = nil)
+                super(command, options, nil)
                 @stdin = stdin
                 @thread = thread
               end

data/lib/nexussw/lxd/transport/mixins/helpers/upload_folder.rb

@@ -36,7 +36,8 @@ module NexusSW
                 # TODO: serious: make sure the tar extract does an overwrite of existing files
                 #   multiple converge support as well as CI cycle/dev updated files get updated instead of .1 suffixed (?)
                 #   I think I need a flag (it's been a while)
-                execute("bash -c 'mkdir -p #{path} && cd #{path} && tar -xf #{fname} && rm -rf #{fname}'").error!
+                # TODO: explore the chmod & make the same as if uploaded via CLI
+                execute("bash -c 'mkdir -p #{path} && cd #{path} && tar -xf #{fname} && rm -rf #{fname} && chmod -R 600 #{File.basename(local_path)}'").error!
               ensure
                 tfile.unlink
               end
@@ -48,10 +49,10 @@ module NexusSW
               return false if @can_archive == false
               @can_archive ||= begin
                                   # I don't want to code tarball logic into the mock transport
-                                  return false if respond_to?(:hk) && hk.respond_to?(:mock)
+                                  return false if respond_to?(:api) && api.respond_to?(:mock)
                                   return false if respond_to?(:inner_transport) && inner_transport.respond_to?(:mock)
                                   return false if respond_to?(:inner_transport) && inner_transport.respond_to?(:inner_transport) && inner_transport.inner_transport.respond_to?(:mock)
-                                  return false if respond_to?(:inner_transport) && inner_transport.respond_to?(:hk) && inner_transport.hk.respond_to?(:mock)
+                                  return false if respond_to?(:inner_transport) && inner_transport.respond_to?(:api) && inner_transport.api.respond_to?(:mock)
                                   `tar --version`
                                   true
                                 rescue

data/lib/nexussw/lxd/transport/mixins/local.rb

@@ -21,7 +21,7 @@ module NexusSW
               Open3.popen3(command) do |stdin, stdout, stderr, th|
                 if options[:capture] == :interactive
                   # return immediately if interactive so that stdin may be used
-                  return Helpers::ExecuteMixin::InteractiveResult.new(command, options, -1, stdin, th).tap do |active|
+                  return Helpers::ExecuteMixin::InteractiveResult.new(command, options, stdin, th).tap do |active|
                     chunk_callback(stdout, stderr) do |stdout_chunk, stderr_chunk|
                       active.send_output stdout_chunk if stdout_chunk
                       active.send_output stderr_chunk if stderr_chunk

data/lib/nexussw/lxd/transport/mixins/rest.rb

@@ -2,6 +2,7 @@ require 'nexussw/lxd/transport/mixins/helpers/execute'
 require 'nexussw/lxd/transport/mixins/helpers/upload_folder'
 require 'nio/websocket'
 require 'tempfile'
+require 'json'
 
 module NexusSW
   module LXD
@@ -13,11 +14,11 @@ module NexusSW
             @config = config
             @rest_endpoint = config[:rest_endpoint]
             @driver_options = config[:driver_options]
-            @hk = config[:connection]
-            raise 'The rest transport requires the following keys: { :connection, :driver_options, :rest_endpoint }' unless @rest_endpoint && @hk && @driver_options
+            @api = config[:connection]
+            raise 'The rest transport requires the following keys: { :connection, :driver_options, :rest_endpoint }' unless @rest_endpoint && @api && @driver_options
           end
 
-          attr_reader :hk, :rest_endpoint, :container_name, :config
+          attr_reader :api, :rest_endpoint, :container_name, :config
 
           include Helpers::ExecuteMixin
           include Helpers::UploadFolder
@@ -62,43 +63,43 @@ module NexusSW
             backchannel = nil
             getlogs = false
             if block_given? && (options[:capture] || !config[:info][:api_extensions].include?('container_exec_recording'))
-              hkopts = { wait_for_websocket: true, interactive: false, sync: false }
-              hkopts[:interactive] = true if options[:capture] == :interactive
-              retval = hk.execute_command(container_name, command, hkopts)
+              apiopts = { :'wait-for-websocket' => true, interactive: false, sync: false }
+              apiopts[:interactive] = true if options[:capture] == :interactive
+              retval = api.execute_command(container_name, command, apiopts)[:metadata]
               opid = retval[:id]
               backchannel = options[:capture] == :interactive ? ws_connect(opid, retval[:metadata][:fds]) : ws_connect(opid, retval[:metadata][:fds], &block)
 
               # patch for interactive session
-              return Helpers::ExecuteMixin::InteractiveResult.new(command, options, -1, StdinStub.pipe(backchannel.waitlist[:'0']), backchannel).tap do |active|
+              return Helpers::ExecuteMixin::InteractiveResult.new(command, options, StdinStub.pipe(backchannel.waitlist[:'0']), backchannel).tap do |active|
                 backchannel.callback = proc do |stdout|
                   active.send_output stdout
                 end
                 yield active
                 backchannel.exit if backchannel.respond_to? :exit
-                retval = hk.wait_for_operation opid
+                retval = api.wait_for_operation opid
                 active.exitstatus = retval[:metadata][:return].to_i
               end if options[:capture] == :interactive
             elsif block_given? && config[:info][:api_extensions].include?('container_exec_recording')
               getlogs = true
-              retval = hk.execute_command(container_name, command, record_output: true, interactive: false, sync: false)
-              opid = retval[:id]
+              retval = api.execute_command(container_name, command, :'record-output' => true, interactive: false, sync: false)
+              opid = retval[:metadata][:id]
             else
-              opid = hk.execute_command(container_name, command, sync: false)[:id]
+              opid = api.execute_command(container_name, command, sync: false)[:metadata][:id]
             end
             LXD.with_timeout_and_retries({ timeout: 0 }.merge(options)) do
               begin
-                retval = hk.wait_for_operation opid
+                retval = api.wait_for_operation(opid)[:metadata]
                 backchannel.join if backchannel.respond_to? :join
                 if getlogs
                   begin
                     stdout_log = retval[:metadata][:output][:'1'].split('/').last
                     stderr_log = retval[:metadata][:output][:'2'].split('/').last
-                    stdout = hk.log container_name, stdout_log
-                    stderr = hk.log container_name, stderr_log
+                    stdout = api.log container_name, stdout_log
+                    stderr = api.log container_name, stderr_log
                     yield stdout, stderr
-                  ensure
-                    hk.delete_log container_name, stdout_log
-                    hk.delete_log container_name, stderr_log
+
+                    api.delete_log container_name, stdout_log
+                    api.delete_log container_name, stderr_log
                   end
                 end
                 return Helpers::ExecuteMixin::ExecuteResult.new command, options, retval[:metadata][:return].to_i
@@ -108,23 +109,21 @@ module NexusSW
             end
           end
 
-          # '' instead of Hyperkit::NotFound is a chef-provisioning expectation - at this level we'll let the exception propagate
+          # empty '' instead of an exception is a chef-provisioning expectation - at this level we'll let the exception propagate
           def read_file(path)
-            hk.read_file container_name, path
-            # rescue ::Hyperkit::NotFound
-            #   return ''
+            api.read_file container_name, path
           end
 
           def write_file(path, content)
-            hk.write_file container_name, path, content: content
+            api.write_file container_name, path, content: content
           end
 
           def download_file(path, local_path)
-            hk.pull_file container_name, path, local_path
+            api.pull_file container_name, path, local_path
           end
 
           def upload_file(local_path, path)
-            # return hk.push_file(local_path, container_name, path)
+            # return api.push_file(local_path, container_name, path)
             write_file(path, IO.binread(local_path))
           end
 
@@ -182,6 +181,28 @@ module NexusSW
                 sleep 0.1
               end
             end
+
+            def window_resize(width, height)
+              send_control_msg 'window-resize', width: width.to_s, height: height.to_s
+            end
+
+            def signal(signum)
+              send_control_msg 'signal', signum
+            end
+
+            private
+
+            def send_control_msg(message, val)
+              msg = {}.tap do |retval|
+                retval['command'] = message
+                case message
+                when 'window-resize' then retval['args'] = val
+                when 'signal' then retval['signal'] = val.to_i
+                end
+              end.to_json
+
+              waitlist[:control].binary msg
+            end
           end
 
           def ws_connect(opid, endpoints, &block)

data/lib/nexussw/lxd/version.rb

@@ -1,5 +1,5 @@
 module NexusSW
   module LXD
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

data/lib/nexussw/lxd.rb

@@ -28,5 +28,16 @@ module NexusSW
         end
       end
     end
+
+    def self.symbolize_keys(hash)
+      {}.tap do |retval|
+        hash.each do |k, v|
+          v.map! do |a|
+            a.is_a?(Hash) ? symbolize_keys(a) : a
+          end if v.is_a?(Array)
+          retval[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
+        end
+      end
+    end
   end
 end

data/lxd-common.gemspec

@@ -8,16 +8,10 @@ Gem::Specification.new do |spec|
   spec.version       = NexusSW::LXD::VERSION
   spec.authors       = ['Sean Zachariasen']
   spec.email         = ['thewyzard@hotmail.com']
-
+  spec.license       = 'Apache-2.0'
   spec.summary       = 'Shared LXD Container Access Library'
-  # spec.description   = %q{TODO: Write a longer description or delete this line.}
   spec.homepage      = 'http://github.com/NexusSW/lxd-common'
 
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-
-  # spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'" if spec.respond_to?(:metadata)
-
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
@@ -25,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'hyperkit', '~> 1.1'
+  spec.add_dependency 'faraday', '~> 0.13'
   spec.add_dependency 'nio4r-websocket', '~> 0.6'
 
   spec.add_development_dependency 'bundler'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lxd-common
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Sean Zachariasen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-31 00:00:00.000000000 Z
+date: 2018-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hyperkit
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0.13'
 - !ruby/object:Gem::Dependency
   name: nio4r-websocket
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +118,9 @@ files:
 - lib/nexussw/lxd/driver/mixins/helpers/wait.rb
 - lib/nexussw/lxd/driver/mixins/rest.rb
 - lib/nexussw/lxd/driver/rest.rb
+- lib/nexussw/lxd/rest_api.rb
+- lib/nexussw/lxd/rest_api/connection.rb
+- lib/nexussw/lxd/rest_api/errors.rb
 - lib/nexussw/lxd/transport.rb
 - lib/nexussw/lxd/transport/cli.rb
 - lib/nexussw/lxd/transport/local.rb
@@ -130,7 +133,8 @@ files:
 - lib/nexussw/lxd/version.rb
 - lxd-common.gemspec
 homepage: http://github.com/NexusSW/lxd-common
-licenses: []
+licenses:
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []