miasma-lxd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 768837675895e46e18d2454a8755dabf7a643689
+  data.tar.gz: 3696866fc4fae82a6c807826927acb6bd727dac2
+SHA512:
+  metadata.gz: 9b76ccc003a7a69d5a83f1d4d0fc683ae344a7e4b9c80e121d81f05271306a7a62c89287a0dfa1cc3739380edcae548c627999a776fb9354d65799ff0cd7248e
+  data.tar.gz: 3c7c6f533d4c53855a5106118745356a9e77dfc060af697b18d1907d051b4fe83515b707622d9867d7753c2c6c61ca5dd9af5b4ca3a85f692ac3ffa9cd60d94f

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v0.1.0
+* Initial release

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2015 Chris Roberts
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,46 @@
+# Miasma LXD
+
+LXD API plugin for the miasma cloud library
+
+## Supported credential attributes:
+
+Supported attributes used in the credentials section of API
+configurations:
+
+```ruby
+Miasma.api(
+  :type => :compute,
+  :provider => :lxd,
+  :credentials => {
+    ...
+  }
+)
+```
+
+### Required attributes
+
+* `api_endpoint` - LXD HTTPS endpoint (e.g. https://127.0.0.1:8443)
+* `ssl_key` - Path to client SSL key
+* `ssl_certificate` - Path to client SSL certificate
+
+### Initial connection required attributes
+
+* `name` - Name of this client (defaults to hostname)
+* `password` - Shared password with LXD to establish trust
+
+## Current support matrix
+
+|Model         |Create|Read|Update|Delete|
+|--------------|------|----|------|------|
+|AutoScale     |      |    |      |      |
+|BlockStorage  |      |    |      |      |
+|Compute       |  X   | X  |  X   |  X   |
+|DNS           |      |    |      |      |
+|LoadBalancer  |      |    |      |      |
+|Network       |      |    |      |      |
+|Orchestration |      |    |      |      |
+|Queues        |      |    |      |      |
+|Storage       |      |    |      |      |
+
+## Info
+* Repository: https://github.com/miasma-rb/miasma-lxd

data/lib/miasma/contrib/lxd/compute.rb

@@ -0,0 +1,258 @@
+require 'miasma'
+require 'shellwords'
+require 'bogo-websocket'
+
+module Miasma
+  module Models
+    class Compute
+      # LXD compute API
+      class Lxd < Compute
+
+        include Contrib::Lxd::Api
+
+        # State mapping based on status
+        SERVER_STATE_MAP = Smash.new(
+          'running' => :running,
+          'stopped' => :stopped
+        )
+
+        # Reload a server model's data
+        #
+        # @param server [Miasma::Models::Compute::Server]
+        # @return [Miasma::Models::Compute::Server]
+        def server_reload(server)
+          result = request(
+            :path => "containers/#{server.id}",
+            :expects => [200, 404]
+          )
+          if(result[:response].code == 200)
+            result = result.get(:body, :metadata)
+            server.load_data(
+              :id => result[:name],
+              :name => result[:name],
+              :state => SERVER_STATE_MAP.fetch(result.get(:status, :status).downcase, :pending),
+              :status => result.fetch(:status, :status, 'unknown').downcase,
+              :addresses_private => (result.get(:status, :ips) || []).map{ |ip|
+                Server::Address.new(
+                  :version => ip[:protocol].downcase.sub('ipv', '').to_i,
+                  :address => ip[:address]
+                )
+              },
+              :image_id => 'unknown',
+              :flavor_id => result.get(:profiles).first,
+              :userdata => result.get(:userdata),
+              :custom => Smash.new(
+                :ephemeral => result[:ephemeral]
+              )
+            )
+          else
+            server.load_data(
+              :id => server.id,
+              :name => server.name,
+              :state => :terminated,
+              :status => 'terminated',
+              :addresses_private => [],
+              :image_id => 'none',
+              :flavor_id => 'none'
+            )
+          end
+          server.valid_state
+        end
+
+        # Destroy an existing server
+        #
+        # @param server [Miasma::Models::Compute::Server]
+        # @return [TrueClass, FalseClass]
+        def server_destroy(server)
+          if(server.persisted?)
+            if(server.state == :running)
+              result = request(
+                :path => "containers/#{server.id}/state",
+                :method => :put,
+                :expects => 202,
+                :json => {
+                  :action => :stop,
+                  :force => true
+                }
+              )
+              wait_for_operation(result.get(:body, :operation))
+            end
+            request(
+              :path => "containers/#{server.id}",
+              :method => :delete,
+              :expects => 202
+            )
+            true
+          else
+            false
+          end
+        end
+
+        # Save the server (create or update)
+        #
+        # @param server [Miasma::Models::Compute::Server]
+        # @return [Miasma::Models::Compute::Server]
+        def server_save(server)
+          if(server.persisted?)
+          else
+            result = request(
+              :path => 'containers',
+              :method => :post,
+              :expects => 202,
+              :json => {
+                :name => server.name,
+                :profiles => [server.flavor_id],
+                :ephemeral => server.custom.fetch(:ephemeral, false),
+                :source => {
+                  :type => :image,
+                  :alias => server.image_id
+                }
+              }
+            )
+            wait_for_operation(result.get(:body, :operation))
+            request(
+              :path => "containers/#{server.name}/state",
+              :method => :put,
+              :expects => 202,
+              :json => {
+                :action => :start
+              }
+            )
+            wait_for_operation(result.get(:body, :operation))
+            server.id = server.name
+            server
+          end
+        end
+
+        # Return all servers
+        #
+        # @return [Array<Miasma::Models::Compute::Server>]
+        def server_all
+          result = request(
+            :path => 'containers'
+          ).get(:body)
+          result.fetch(:metadata, []).map do |c_info|
+            c_name = c_info.sub("/#{version}/containers/", '')
+            Server.new(
+              self,
+              :id => c_name,
+              :name => c_name
+            ).valid_state
+          end
+        end
+
+        # Fetch file from server
+        #
+        # @param server [Miasma::Models::Compute::Server]
+        # @param path [String] remote path
+        # @return [IO-ish]
+        def server_get_file(server, path)
+          request(
+            :path => "containers/#{server.id}/files",
+            :params => {
+              :path => path
+            }
+          ).get(:body)
+        end
+
+        # Put file on server
+        #
+        # @param server [Miasma::Models::Compute::Server]
+        # @param io [IO-ish]
+        # @param remote_path [String]
+        # @return [TrueClass]
+        # @todo update to write in chunks when over `n` size
+        def server_put_file(server, io, remote_path, options={})
+          request(
+            :method => :post,
+            :path => "containers/#{server.id}/files",
+            :params => {
+              :path => remote_path
+            },
+            :body => io.read,
+            :headers => {
+              'X-LXD-uid' => options.fetch(:uid, 0),
+              'X-LXD-gid' => options.fetch(:gid, 0),
+              'X-LXD-mode' => options.fetch(:mode, 0700)
+            }
+          )
+          true
+        end
+
+        # Execute command
+        #
+        # @param server [Miasma::Models::Compute::Server]
+        # @param command [String]
+        # @param options [Hash]
+        # @option options [IO] :stream write command output
+        # @return [TrueClass, FalseClass] command was successful
+        def server_execute(server, command, options={})
+          result = request(
+            :method => :post,
+            :path => "containers/#{server.id}/exec",
+            :expects => 202,
+            :json => Smash.new(
+              :command => Shellwords.shellwords(command),
+              :interactive => true,
+              'wait-for-websocket' => true
+            )
+          )
+          dest = URI.parse(api_endpoint)
+          operation = result.get(:body, :operation).sub("/#{version}/operations/", '')
+          ws_common = Smash.new(
+            :ssl_key => ssl_key,
+            :ssl_certificate => ssl_certificate
+          )
+          if(options[:stream])
+            ws_common[:on_message] = proc{|message|
+              options[:stream].write(message)
+            }
+          end
+          websockets = Smash[
+            ['control', '0'].map do |fd_id|
+              fd_secret = result.get(:body, :metadata, :fds, fd_id)
+              [
+                fd_id,
+                Bogo::Websocket::Client.new(
+                  ws_common.merge(
+                    :destination => "wss://#{[dest.host, dest.port].compact.join(':')}",
+                    :path => "/#{version}/operations/#{operation}/websocket",
+                    :params => {
+                      :secret => fd_secret
+                    }
+                  )
+                )
+              ]
+            end
+          ]
+          wait_for_operation(operation, options.fetch(:timeout, 20))
+          websockets.map(&:last).map(&:close)
+          result = request(
+            :path => "operations/#{operation}"
+          )
+          result.get(:body, :metadata, :metadata, :return) == 0
+        end
+
+        protected
+
+        # Wait for a remote operation to complete
+        #
+        # @param op_uuid [String]
+        # @param timeout [Integer]
+        # @return [TrueClass]
+        def wait_for_operation(op_uuid, timeout=20)
+          op_uuid = op_uuid.sub("/#{version}/operations/", '')
+          request(
+            :path => "operations/#{op_uuid}/wait",
+            :params => {
+              :status_code => 200,
+              :timeout => 20
+            }
+          )
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/miasma/contrib/lxd.rb

@@ -0,0 +1,103 @@
+require 'miasma'
+
+module Miasma
+  module Contrib
+    module Lxd
+      # API updates required for LXD communication
+      module Api
+
+        # Default API version to require
+        DEFAULT_API_VERSION = '1.0'
+
+        # Load required attributes into API class
+        #
+        # @param klass [Class]
+        def self.included(klass)
+          klass.class_eval do
+            attribute :name, String, :required => true, :default => Socket.gethostname
+            attribute :password, String
+            attribute :api_endpoint, String, :required => true
+            attribute :ssl_certificate, String, :required => true
+            attribute :ssl_key, String, :required => true
+            attribute :version, Gem::Version, :coerce => lambda{|v| Gem::Version.new(v.to_s)}, :required => true, :default => lambda{ Miasma::Contrib::Lxd::Api::DEFAULT_API_VERSION }
+          end
+        end
+
+        # @return [String] versioned endpoint
+        def endpoint
+          "#{api_endpoint}/#{version}"
+        end
+
+        # Clean up endpoint prior to data loading
+        #
+        # @param args [Hash]
+        def custom_setup(args)
+          if(args[:api_endpoint].to_s.end_with?('/'))
+            args[:api_endpoint] = args[:api_endpoint][0, endpoint.length - 1]
+          end
+        end
+
+        # Perform request
+        #
+        # @param connection [HTTP]
+        # @param http_method [Symbol]
+        # @param request_args [Array]
+        # @return [HTTP::Response]
+        def make_request(connection, http_method, request_args)
+          dest, options = request_args
+          options = Smash.new unless options
+          options[:ssl_context] = ssl_context
+          connection.send(http_method, dest, options)
+        end
+
+        protected
+
+        # @return [OpenSSL::SSL::SSLContext.new]
+        def ssl_context
+          memoize(:ssl_context) do
+            ctx = OpenSSL::SSL::SSLContext.new
+            ctx.cert = OpenSSL::X509::Certificate.new(File.read(ssl_certificate))
+            ctx.key = OpenSSL::PKey::RSA.new(File.read(ssl_key))
+            ctx
+          end
+        end
+
+        # Establish connection to endpoint and register client if not
+        # already registered
+        def connect
+          result = request(:endpoint => api_endpoint)[:body]
+          unless(result[:metadata].any?{|s| s.end_with?(version.to_s)})
+            raise InvalidVersionError
+          end
+          result = request(:endpoint => api_endpoint, :path => "/#{version}")[:body]
+          if(result[:auth] != 'trusted' && password)
+            authenticate_connection!
+          end
+        end
+
+        # Authenticate with the endpoint to create trusted connection
+        def authenticate_connection!
+          request(
+            :method => :post,
+            :path => 'certificates',
+            :json => {
+              :type => :client,
+              :name => name,
+              :password => password
+            }
+          )
+        end
+
+        # Always allow retry
+        #
+        # @return [TrueClass]
+        def retryable_allowed?(*_)
+          false
+        end
+
+      end
+    end
+  end
+
+  Models::Compute.autoload :Lxd, 'miasma/contrib/lxd/compute'
+end

data/lib/miasma-lxd/version.rb

@@ -0,0 +1,4 @@
+module MiasmaLxd
+  # Current library version
+  VERSION = Gem::Version.new('0.1.0')
+end

data/lib/miasma-lxd.rb

@@ -0,0 +1,2 @@
+require 'miasma'
+require 'miasma-lxd/version'

data/miasma-lxd.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'miasma-lxd/version'
+Gem::Specification.new do |s|
+  s.name = 'miasma-lxd'
+  s.version = MiasmaLxd::VERSION.version
+  s.summary = 'Smoggy LXD API'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'https://github.com/miasma-rb/miasma-lxd'
+  s.description = 'Smoggy LXD API'
+  s.license = 'Apache 2.0'
+  s.require_path = 'lib'
+  s.add_runtime_dependency 'bogo-websocket', '< 1.0.0'
+  s.add_development_dependency 'miasma', '>= 0.2.31'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'vcr'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'psych', '>= 2.0.8'
+  s.files = Dir['lib/**/*'] + %w(miasma-lxd.gemspec README.md CHANGELOG.md LICENSE)
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: miasma-lxd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bogo-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: miasma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.31
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.31
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.8
+description: Smoggy LXD API
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/miasma-lxd.rb
+- lib/miasma-lxd/version.rb
+- lib/miasma/contrib/lxd.rb
+- lib/miasma/contrib/lxd/compute.rb
+- miasma-lxd.gemspec
+homepage: https://github.com/miasma-rb/miasma-lxd
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Smoggy LXD API
+test_files: []