triton-internal 0.1.0

data/Users/thomas/tdh/triton/lib/triton/remote_exception.rb

@@ -0,0 +1,53 @@
+module Triton
+
+  # This module "magically" defines any constants as
+  # RemoteExceptions, so when the server send back
+  # error structures such as:
+  #
+  #    {"code" => "WidgetInvalid", ...}
+  #
+  # it means you can:
+  #
+  # begin
+  #   ...
+  # rescue Triton::RemoteException::WidgetInvalid
+  # end
+  #
+  # without having to exhaustively define all such exceptions beforehand
+  module RemoteExceptions
+    def self.const_missing(name)
+      klass = Class.new(RemoteException)
+      RemoteExceptions.const_set(name, klass)
+    end
+  end
+
+  #
+  # In tests, you can also `raise Triton::RemoteExceptions::WidgetFailure, 'the-message'
+  # and also `raise Triton::RemoteException, { "code" => 'WidgetFailure', 'message' => 'the-message' }
+  # with the same behaviour
+  #
+  class RemoteException < RuntimeError
+    def self.exception(payload)
+      if payload.is_a?(Hash) && payload.keys.include?('code')
+        const = Triton::RemoteExceptions.const_get(payload['code'].intern)
+        const.new(payload)
+      else
+        self.new(payload)
+      end
+    end
+
+    attr_reader :errors, :body, :code
+
+    def initialize(hash_or_string)
+      if hash_or_string.is_a?(Hash)
+        @errors = hash_or_string['errors']
+        @code = hash_or_string['code']
+        @body = hash_or_string
+        super(hash_or_string.fetch('message') { body.to_s })
+      else
+        super(hash_or_string)
+      end
+    end
+  end
+
+end

data/Users/thomas/tdh/triton/lib/triton/version.rb

@@ -0,0 +1,3 @@
+module Triton
+  VERSION = "0.1.0"
+end

data/Users/thomas/tdh/triton/lib/triton/vmapi.rb

@@ -0,0 +1,50 @@
+module Triton
+  class Vmapi < ApiBase
+
+    # The commit used to compile this itnerface:
+    # https://github.com/joyent/sdc-vmapi/blob/590a4e09c0c76093f66f4ff69d6b4fd66de09bb6/docs/index.md
+    #
+
+    self.name = "vmapi"
+
+    call('Ping',      :method => :get,    :path => '/ping')
+    call('ListVms',   :method => :get,    :path => '/vms' )
+    call('GetVm',     :method => :get,    :path => '/vms/:uuid')
+    call('CreateVm',  :method => :post,   :path => '/vms')
+    call("DeleteVm",  :method => :delete, :path => '/vms/:uuid')
+
+    {
+      'StartVm'          => 'start',
+      'StopVm'           => 'stop',
+      'RebootVm'         => 'reboot',
+      'ReprovisionVm'    => 'reprovision',
+      'UpdateVm'         => 'update',
+      'AddNics'          => 'add_nics',
+      'UpdateNics'       => 'update_nics',
+      'RemoveNics'       => 'remove_nics',
+      'CreateSnapshot'   => 'create_snapshot',
+      'DeleteSnapshot'   => 'delete_snapshot',
+      'RollbackSnapshot' => 'rollback_snapshot'
+    }.each do |api_name, action_name|
+      call(api_name, :method => :post, :path   => "/vms/:uuid?action=#{action_name}")
+    end
+
+    # :type in the following calls must be one of 'tags', 'customer_metadata', or 'internal_metadata'
+    call("ListMetadata",      :method => :get,    :path => '/vms/:uuid/:type')
+    call("GetMetadata",       :method => :get,    :path => '/vms/:uuid/:type/:key')
+    call("AddMetadata",       :method => :post,   :path => '/vms/:uuid/:type', :body_param => 'metadata')
+    call("SetMetadata",       :method => :put,    :path => '/vms/:uuid/:type', :body_param => 'metadata')
+    call("DeleteMetadata",    :method => :delete, :path => '/vms/:uuid/:type/:key')
+    call("DeleteAllMetadata", :method => :delete, :path => '/vms/:uuid/:type')
+    call("AddRoleTags",       :method => :post,   :path => '/vms/:uuid/role_tags')
+    call("SetRoleTags",       :method => :put,    :path => '/vms/:uuid/role_tags')
+    call("DeleteRoleTag",     :method => :delete, :path => '/vms/:uuid/role_tags/:role_tag')
+    call("DeleteAllRoleTags", :method => :delete, :path => '/vms/:uuid/role_tags')
+
+    call("GetJobs",     :method => :get, :path => '/jobs')
+    call("ListVmJobs",  :method => :get, :path => '/vms/:uuid/jobs')
+    call("GetJob",      :method => :get, :path => '/jobs/:uuid')
+    call("GetStatuses", :method => :get, :path => '/statuses')
+
+  end
+end

data/Users/thomas/tdh/triton/lib/triton.rb

@@ -0,0 +1,57 @@
+require 'triton/version'
+require 'rest-client'
+require 'cgi'
+
+module Triton
+
+  def self.suffix=(new_suffix)
+    @suffix = new_suffix
+  end
+  def self.suffix
+    @suffix
+  end
+
+
+  def self.socks=(new_socks)
+    if new_socks
+      server,port = new_socks.to_s.split(":")
+      if port.nil?
+        port = server
+        server = "127.0.0.1"
+      end
+      begin
+        require 'socksify'
+        TCPSocket::socks_server = server
+        TCPSocket::socks_port = port.to_i
+      rescue LoadError
+        $stderr.puts "Could not load 'socksify' gem. Socks forwarding won't work."
+      end
+
+    end
+  end
+
+  TestModeLeak = Class.new(RuntimeError)
+  def self.test_mode=(value)
+    @test_mode = value
+  end
+  def self.test_mode
+    @test_mode
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+  def self.logger
+    @logger ||= Logger.new("/dev/null")
+  end
+
+  require 'triton/remote_exception'
+  require 'triton/api_base'
+  require 'triton/vmapi'
+  require 'triton/cnapi'
+  require 'triton/napi'
+  require 'triton/papi'
+  require 'triton/imgapi'
+  require 'triton/indifferent_hash'
+
+end

data/Users/thomas/tdh/triton/spec/api_base_spec.rb

@@ -0,0 +1,288 @@
+require 'spec_helper'
+
+describe "ApiMapping" do
+
+  let(:fakeapi) do
+    Class.new(Triton::ApiBase) do
+      self.name = "fakeapi"
+      call("TestMethod", {
+        :method => :post,
+        :path   => "/testmethod/path"
+      })
+
+      call("GetMethod", {
+        :path   => "/testmethod/path"
+      })
+
+      call("GetThing", {
+        :path => "/things/:thing/foo"
+      })
+
+      call("PostThing", {
+        :method => :post,
+        :path => "/things/:thing"
+      })
+
+      call("GetThingWithQueryString", {
+        :path => "/things/:thing/foo?a=b"
+      })
+
+      call("SetTags", {
+        :method => :post,
+        :path => "/thing/:id/tag",
+        :body_param => :metadata
+      })
+
+    end
+  end
+
+  describe "instance behaviour" do
+
+    subject { fakeapi.new("TestMethod") }
+
+    it "should memoise the request" do
+      first_request = subject.request
+      expect(subject.request.object_id).to eq(first_request.object_id)
+    end
+
+    it "should pass execute to the request" do
+      expect(subject.request).to receive(:execute).and_return("{}")
+      subject.execute
+    end
+
+    it "should have a shortcut to execute the method from the class" do
+      expect(fakeapi).to respond_to(:execute)
+    end
+  end
+
+  describe "init - when the call isn't defined" do
+    it "should raise an exception if the call isn't recognised" do
+      expect { fakeapi.new("Unknown") }.to raise_exception(Triton::ApiBase::UnknownCall)
+    end
+
+    it "should be a NoMethodError" do
+      expect(Triton::ApiBase::UnknownCall.new).to be_a(NoMethodError)
+    end
+  end
+
+  describe "response handling" do
+    subject { fakeapi.new("TestMethod") }
+
+    it "should decode the payload as JSON" do
+      allow(subject.request).to receive(:execute).and_return('{"something": "here"}')
+      expect(subject.execute).to eq({"something" => "here"})
+    end
+
+    it "should return a hash with indifferent key access" do
+      allow(subject.request).to receive(:execute).and_return('{"something": "here", "nested": {"something": "inner"}}')
+      expect(subject.execute[:something]).to eq("here")
+      expect(subject.execute['something']).to eq("here")
+      expect(subject.execute[:nested][:something]).to eq("inner")
+      expect(subject.execute[:nested]['something']).to eq("inner")
+    end
+  end
+
+  describe "response exception handling" do
+    subject { fakeapi.new("TestMethod") }
+
+    let(:exception) { RestClient::Exception.new(double("Response", :body => "body"))}
+
+    before do
+      # Simulate a RestClient exception when we execute
+      allow(subject.request).to receive(:execute).and_raise(exception)
+    end
+
+    it "should re-raise the original RestClient exception if the body doesn't contain valid JSON" do
+      expect { subject.execute }.to raise_exception(exception)
+    end
+
+    it "should raise a Triton::RemoteException if the JSON decoded, but doesn't contain a 'code' field" do
+      allow(exception.response).to receive(:body).and_return("{}")
+      expect { subject.execute }.to raise_exception(Triton::RemoteException)
+    end
+
+    it "should synthesize an exception class if a 'code' is present" do
+      allow(exception.response).to receive(:body).and_return('{"code": "ItScrewedUp"}')
+      expect { subject.execute }.to raise_exception(Triton::RemoteExceptions::ItScrewedUp)
+    end
+
+    it "should be possible to raise a RemoteException with a struct" do
+      expect do
+        raise Triton::RemoteExceptions::RemoteException, { 'code' => 'ResourceNotFound', 'message' => 'VM not found'}
+      end.to raise_exception(Triton::RemoteExceptions::ResourceNotFound, 'VM not found')
+    end
+
+    it "should be possible to raise a RemoteException with a message directly" do
+      expect do
+        raise Triton::RemoteExceptions::ResourceNotFound, 'VM not found'
+      end.to raise_exception(Triton::RemoteExceptions::ResourceNotFound, 'VM not found')
+    end
+
+    it "should be possible to raise a RemoteException from a mock with a message in a test" do
+      object = Object.new
+      allow(object).to receive(:crash).and_raise(Triton::RemoteExceptions::ResourceNotFound, 'VM not found')
+
+      expect do
+        object.crash
+      end.to raise_exception(Triton::RemoteExceptions::ResourceNotFound, 'VM not found')
+    end
+  end
+
+  describe "request" do
+    subject { fakeapi.new("TestMethod").request }
+
+    it "should build a RestClient request" do
+      expect(subject).to be_a(RestClient::Request)
+    end
+
+    it "should use the specified name as the first part of the hostname" do
+      expect(subject.url).to match(%r{^http://fakeapi})
+    end
+
+    it "should append the configured suffix to the hostname" do
+      expect(subject.url).to match(%r{^http://fakeapi.test/})
+    end
+
+    it "should append the path to the url" do
+      expect(URI.parse(subject.url).path).to eq("/testmethod/path")
+    end
+
+
+    it "should set the method" do
+      expect(subject.method).to eq(:post)
+    end
+
+    it "should default the method to :get" do
+      expect(fakeapi.new("GetMethod").request.method).to eq(:get)
+    end
+  end
+
+  describe "path parametisation" do
+    it "should replace any :<word> values with the associated argument" do
+      expect(URI.parse(fakeapi.new("GetThing", :thing => "IDENT").request.url).path).to eq("/things/IDENT/foo")
+    end
+    it "should URL encode any value" do
+      expect(URI.parse(fakeapi.new("GetThing", :thing => "IDE/NT").request.url).path).to eq("/things/IDE%2FNT/foo")
+    end
+
+    it "should exclude any arguments used to build the URL from the query string of GET requests" do
+      request = fakeapi.new("GetThing", 'thing' => "123", :foo => "bar").request
+      expect(URI.parse(request.url).query).to eq("foo=bar")
+    end
+    it "should exclude any arguments used to build the URL from the payload of non-get requests" do
+      request = fakeapi.new("PostThing", 'thing' => "123", :foo => "bar").request
+      expect(URI.parse(request.url).path).to eq("/things/123")
+      expect(JSON.load(request.payload)).to eq("foo" => "bar")
+    end
+  end
+
+  it "should accept application/json" do
+    expect(fakeapi.new("GetThing", :thing => "IDENT").request.headers['Accept']).to eq("application/json")
+    expect(fakeapi.new("TestMethod").request.headers['Accept']).to eq("application/json")
+  end
+
+  describe "arguments - GET requests" do
+    subject { fakeapi.new("GetMethod", :foo=>"bar/baz", :bar=>"baz").request }
+    it "should urlencode and append to the URL as a query string" do
+      expect(URI.parse(subject.url).query).to eq("foo=bar%2Fbaz&bar=baz")
+    end
+
+    it "should append carefully if there is already a query string" do
+      url = fakeapi.new("GetThingWithQueryString", :thing => 1, :foo=>"bar", :bar=>"foo/bar").request.url
+      expect(URI.parse(url).query).to eq("a=b&foo=bar&bar=foo%2Fbar")
+
+    end
+
+    it "should not set a payload" do
+      expect(subject.payload).to be_nil
+    end
+
+    it "should not set a Content-Type header" do
+      expect(subject.headers["Content-Type"]).to be_nil
+    end
+  end
+
+  describe "arguments - non-GET" do
+    subject { fakeapi.new("TestMethod", 'some' => 'args', :live => :here).request }
+
+    it "should set the Content-Body to application/json" do
+      expect(subject.headers["Content-Type"]).to eq("application/json")
+    end
+    it "should serialize the arguments to JSON as the payload" do
+      expect(JSON.load(subject.payload)).to eq({'some' => 'args', 'live' => 'here'})
+    end
+
+  end
+
+  it "should generate a snake-case function call from the Api name" do
+    expect(fakeapi).to respond_to(:get_method)
+  end
+
+
+  describe "camelise" do
+    it "should return a camel_case string" do
+      expect("foo".camelise).to eq("Foo")
+      expect("foo_bar".camelise).to eq("FooBar")
+      expect("foo_bar_baz".camelise).to eq("FooBarBaz")
+      expect("foo______bar_baz".camelise).to eq("FooBarBaz")
+    end
+    it "should return nil if an unexpected string is encountered" do
+      expect("something-wrong".camelise).to eq(nil)
+      expect("Capsyousay".camelise).to eq(nil)
+      expect("wow!".camelise).to eq(nil)
+    end
+  end
+
+  describe "test_mode" do
+    before do
+      Triton.test_mode = true
+    end
+    it "should raise an exception if a request is attempted when test_mode is set" do
+      expect do
+        fakeapi.test_method()
+      end.to raise_exception(Triton::TestModeLeak)
+    end
+
+    it "should include the Api call name in the exception" do
+      expect do
+        fakeapi.test_method()
+      end.to raise_exception do |ex|
+        expect(ex.message).to include("TestMethod")
+      end
+    end
+
+    it "should include the call route in the exception" do
+      expect do
+        fakeapi.test_method()
+      end.to raise_exception do |ex|
+        expect(ex.message).to include("POST /testmethod/path")
+      end
+    end
+
+    it "should include the parameters in the exception" do
+      expect do
+        fakeapi.test_method("param" => "value")
+      end.to raise_exception do |ex|
+        expect(ex.message).to include(%{"param": "value"})
+      end
+    end
+  end
+
+
+  describe "body_param option" do
+
+    subject { fakeapi.new('SetTags', :id => "the-id", :other_param => "other_value", :key => 'value', :metadata => { "tag1" => "value1", "tag2" => "value2" })}
+
+    it "should write the value of the body_param to the body" do
+      expect(JSON.load(subject.request.payload)).to eq({ "tag1" => "value1", "tag2" => "value2" })
+    end
+
+    it "should set any additional parameters on the query-string" do
+      expect(URI.parse(subject.request.url).query).to eq("other_param=other_value&key=value")
+    end
+
+  end
+
+end
+
+

data/Users/thomas/tdh/triton/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "bundler/setup"
+require "triton/internal"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  config.before do
+    Triton.test_mode = false
+    Triton.suffix = "test"
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/Users/thomas/tdh/triton/spec/triton_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+RSpec.describe Triton do
+  it "has a version number" do
+    expect(Triton::VERSION).not_to be nil
+  end
+
+  it "should have a configurable suffix" do
+    expect(Triton.suffix).to eq("test")
+    Triton.suffix = "foo"
+    expect(Triton.suffix).to eq("foo")
+  end
+
+  describe "socks config" do
+    it "should accept host:port" do
+      Triton.socks = "1.2.3.4:5678"
+      expect(TCPSocket.socks_server).to eq("1.2.3.4")
+      expect(TCPSocket.socks_port).to eq(5678)
+    end
+    it "should accept string 'port' and assume localhost" do
+      Triton.socks = "5678"
+      expect(TCPSocket.socks_server).to eq("127.0.0.1")
+      expect(TCPSocket.socks_port).to eq(5678)
+    end
+    it "should accept an integer port, and assume localhost" do
+      Triton.socks = 5678
+      expect(TCPSocket.socks_server).to eq("127.0.0.1")
+      expect(TCPSocket.socks_port).to eq(5678)
+    end
+  end
+
+end

data/Users/thomas/tdh/triton/triton-internal.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'triton/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "triton-internal"
+  spec.version       = Triton::VERSION
+  spec.authors       = ["Thomas Haggett"]
+  spec.email         = ["thomas-tritongem@haggett.org"]
+  spec.licenses      = ['MIT']
+
+  spec.summary       = %q{Library to wrap the Triton internal APIs}
+  spec.description   = %q{Library that wraps all of the Joyent Triton Internal APIs in a consistent ruby interface allowing easier calling and mocking.}
+  spec.homepage      = "http://thomas.haggett.org/"
+
+  spec.files         = Dir.glob(File.expand_path("../**/*", __FILE__)).reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency 'rest-client', "~> 1.8"
+  spec.add_dependency 'socksify', "~> 1.7"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: triton-internal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Thomas Haggett
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: socksify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: Library that wraps all of the Joyent Triton Internal APIs in a consistent
+  ruby interface allowing easier calling and mocking.
+email:
+- thomas-tritongem@haggett.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "/Users/thomas/tdh/triton/Gemfile"
+- "/Users/thomas/tdh/triton/Gemfile.lock"
+- "/Users/thomas/tdh/triton/LICENSE"
+- "/Users/thomas/tdh/triton/README.md"
+- "/Users/thomas/tdh/triton/Rakefile"
+- "/Users/thomas/tdh/triton/bin/console"
+- "/Users/thomas/tdh/triton/bin/setup"
+- "/Users/thomas/tdh/triton/lib/triton.rb"
+- "/Users/thomas/tdh/triton/lib/triton/api_base.rb"
+- "/Users/thomas/tdh/triton/lib/triton/cnapi.rb"
+- "/Users/thomas/tdh/triton/lib/triton/imgapi.rb"
+- "/Users/thomas/tdh/triton/lib/triton/indifferent_hash.rb"
+- "/Users/thomas/tdh/triton/lib/triton/internal.rb"
+- "/Users/thomas/tdh/triton/lib/triton/napi.rb"
+- "/Users/thomas/tdh/triton/lib/triton/papi.rb"
+- "/Users/thomas/tdh/triton/lib/triton/remote_exception.rb"
+- "/Users/thomas/tdh/triton/lib/triton/version.rb"
+- "/Users/thomas/tdh/triton/lib/triton/vmapi.rb"
+- "/Users/thomas/tdh/triton/pkg/triton-internal-0.1.0.gem"
+- "/Users/thomas/tdh/triton/spec/api_base_spec.rb"
+- "/Users/thomas/tdh/triton/spec/spec_helper.rb"
+- "/Users/thomas/tdh/triton/spec/triton_spec.rb"
+- "/Users/thomas/tdh/triton/triton-internal.gemspec"
+homepage: http://thomas.haggett.org/
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Library to wrap the Triton internal APIs
+test_files: []