fog-fifo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 36b4e9f87e2cdc5911f01bf44a857b45c9813c4f
+  data.tar.gz: e31dee1fa24928a148d47fb9cedc1a7253917dc5
+SHA512:
+  metadata.gz: db94411dd1046cca9039ed96bcd8ab40b3c340736a3f447c70ceec2d8dc606f96659e6597648f17bd7b938b925a8fbf569fa789607731d8bbec25670d50cc587
+  data.tar.gz: 0135958f45ee3760ea5e53823ce35768f2033a4ce49ba28ab4ebb32bab65644cfd76854cd5a4e48b9f840570014a9a94d524011ca958c3cbd580a4bd0ab04e33

data/LICENSE

@@ -0,0 +1,9 @@
+(The MIT License)
+
+Copyright (c) 2012 bakins (Brian Akins)
+
+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.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+very rough start to a project-fifo driver for fog.
+
+Based primarily on the Joyent driver. Thanks to all those who worked on that and all of fog.

data/examples/test.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../lib'))
+require 'fog/fifo'
+require 'pp'
+connection = Fog::Compute.new(
+                              :provider => 'Fifo',
+                              :fifo_username => ENV['FIFO_USERNAME'],
+                              :fifo_password => ENV['FIFO_PASSWORD'],
+                              :fifo_url => ENV['FIFO_URL']
+                              )
+
+pp connection.datasets.all
+pp connection.packages.all
+pp connection.networks.all
+pp connection.ipranges.all
+pp connection.servers.all
+

data/fog-fifo.gemspec

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "fog-fifo"
+  spec.version       = '0.1.0'
+  spec.authors       = [ "Brian Akins" ]
+  spec.email         = [ "brian@akins.org" ]
+  spec.description   = %q{fifo support for fog}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/bakins/fog-fifo"
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 1.9.1"
+  spec.add_dependency("fog", "~> 1.17")
+end

data/lib/fog/fifo/compute.rb

@@ -0,0 +1,215 @@
+require 'fog/fifo'
+#require 'fog/joyent/errors'
+require 'fog/compute'
+require 'pp'
+
+module Fog
+  module Compute
+    class Fifo < Fog::Service
+      requires :fifo_username
+
+      requires :fifo_password
+      requires :fifo_url
+
+      model_path 'fog/fifo/models/compute'
+      request_path 'fog/fifo/requests/compute'
+
+      # Datasets
+      collection :datasets
+      model :dataset
+      request :list_datasets
+      request :get_dataset
+
+      # packages
+      collection :packages
+      model :package
+      request :list_packages
+      request :get_package
+
+      # Servers
+      collection :servers
+      model :server
+      request :list_vms
+      request :get_vm
+      request :reboot_vm
+      request :stop_vm
+      request :start_vm
+      request :create_vm
+
+      if false
+      request :create_machine
+      request :start_machine
+      request :stop_machine
+      request :resize_machine
+      request :delete_machine
+      end
+
+      # Networks
+      collection :networks
+      model :network
+      request :list_networks
+      request :get_network
+
+      # Ipranges
+      collection :ipranges
+      model :iprange
+      request :list_ipranges
+      request :get_iprange
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def data
+          self.class.data
+        end
+
+        def initialize(options = {})
+          @fifo_username = options[:fifo_username] || Fog.credentials[:fifo_username]
+          @fifo_password = options[:fifo_password] || Fog.credentials[:fifo_password]
+        end
+
+        def request(opts)
+          raise "Not Implemented"
+        end
+      end # Mock
+
+      class Real
+        def initialize(options = {})
+
+          @connection_options = options[:connection_options] || {}
+          @persistent = options[:persistent] || false
+
+          @fifo_username = options[:fifo_username]
+
+          unless @fifo_username
+            raise ArgumentError, "options[:fifo_username] required"
+          end
+
+          @fifo_url = options[:fifo_url]
+
+          unless @fifo_url
+            raise ArgumentError, "options[:fifo_url] required"
+          end
+
+          @fifo_password = options[:fifo_password]
+
+          unless @fifo_password
+            raise ArgumentError, "options[:fifo_password] required"
+          end
+
+          @fifo_password = options[:fifo_password]
+
+          @fifo_token = nil
+
+          @fifo_uri = ::URI.parse(@fifo_url)
+
+          @connection = Fog::Connection.new(
+            @fifo_url,
+            @persistent,
+            @connection_options
+          )
+          authenticate
+        end
+
+        def authenticate
+          response = @connection.request({
+                                           :expects => [200, 204, 303],
+                                           #:host    => @fifo_uri.host,
+                                           :method  => 'POST',
+                                           :path    => create_path('sessions'),
+                                           :headers => {
+                                             "Content-Type" => "application/json",
+                                             "Accept" => "application/json"
+                                           },
+                                           :body => Fog::JSON.encode({
+                                                                       "user" => @fifo_username,
+                                                                       "password" => @fifo_password
+                                                                     })
+                                         })
+
+          @fifo_token = response.headers["x-snarl-token"] || File.basename(response.headers["location"])
+        end
+
+        def request(opts = {})
+          opts[:headers] = {
+            "X-Api-Version" => @fifo_version,
+            "Content-Type" => "application/json",
+            "Accept" => "application/json",
+            "x-Snarl-Token" => @fifo_token
+          }.merge(opts[:headers] || {})
+
+          if opts[:body]
+            opts[:body] = Fog::JSON.encode(opts[:body])
+          end
+
+          opts[:path] = create_path(opts[:path])
+          response = @connection.request(opts)
+          if response.headers["Content-Type"] == "application/json"
+            response.body = json_decode(response.body)
+          end
+
+          #pp response
+          response
+        rescue Excon::Errors::HTTPStatusError => e
+          raise_if_error!(e.request, e.response)
+        end
+
+        private
+
+        def create_path(path)
+          ::File.join(@fifo_uri.path, path)
+        end
+
+        def json_decode(body)
+          parsed = Fog::JSON.decode(body)
+          decode_time_attrs(parsed)
+        end
+
+        def decode_time_attrs(obj)
+          if obj.kind_of?(Hash)
+            obj["created"] = Time.parse(obj["created"]) unless obj["created"].nil? or obj["created"] == ''
+            obj["updated"] = Time.parse(obj["updated"]) unless obj["updated"].nil? or obj["updated"] == ''
+          elsif obj.kind_of?(Array)
+            obj.map do |o|
+              decode_time_attrs(o)
+            end
+          end
+
+          obj
+        end
+
+        def raise_if_error!(request, response)
+          case response.status
+          when 401 then
+            raise Fifo::Errors::Unauthorized.new('Invalid credentials were used', request, response)
+          when 403 then
+            raise Fifo::Errors::Forbidden.new('No permissions to the specified resource', request, response)
+          when 404 then
+            raise Fifo::Errors::NotFound.new('Requested resource was not found', request, response)
+          when 405 then
+            raise Fifo::Errors::MethodNotAllowed.new('Method not supported for the given resource', request, response)
+          when 406 then
+            raise Fifo::Errors::NotAcceptable.new('Try sending a different Accept header', request, response)
+          when 409 then
+            raise Fifo::Errors::Conflict.new('Most likely invalid or missing parameters', request, response)
+          when 414 then
+            raise Fifo::Errors::RequestEntityTooLarge.new('You sent too much data', request, response)
+          when 415 then
+            raise Fifo::Errors::UnsupportedMediaType.new('You encoded your request in a format we don\'t understand', request, response)
+          when 420 then
+            raise Fifo::Errors::PolicyNotForfilled.new('You are sending too many requests', request, response)
+          when 449 then
+            raise Fifo::Errors::RetryWith.new('Invalid API Version requested; try with a different API Version', request, response)
+          when 503 then
+            raise Fifo::Errors::ServiceUnavailable.new('Either there\'s no capacity in this datacenter, or we\'re in a maintenance window', request, response)
+          end
+        end
+
+      end # Real
+    end
+  end
+end

data/lib/fog/fifo/models/compute/dataset.rb

@@ -0,0 +1,17 @@
+module Fog
+  module Compute
+    class Fifo
+      class Dataset < Fog::Model
+
+        identity :dataset
+
+        attribute :name
+        attribute :os
+        attribute :type
+        attribute :version
+        attribute :description
+        
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/datasets.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/fifo/models/compute/dataset'
+
+module Fog
+  module Compute
+
+    class Fifo
+      class Datasets < Fog::Collection
+
+        model Fog::Compute::Fifo::Datasets
+
+        def all
+          service.list_datasets().body
+        end
+
+        def get(id)
+          data = service.get_dataset(id).body
+          new(data)
+        end
+
+      end # Images
+    end # Fifo
+
+  end # Compute
+end # Fog

data/lib/fog/fifo/models/compute/iprange.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+    class Fifo
+      class Iprange < Fog::Model
+        identity :uuid
+
+        attribute :name
+        attribute :version
+        attribute :first
+        attribute :last
+        attribute :gateway
+        attribute :netmask
+        attribute :network
+        attribute :tag
+        attribute :vlan
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/ipranges.rb

@@ -0,0 +1,21 @@
+require 'fog/fifo/models/compute/iprange'
+module Fog
+  module Compute
+    class Fifo
+      class Ipranges < Fog::Collection
+
+        model Fog::Compute::Fifo::Iprange
+
+        def all
+          service.list_ipranges().body.map{|id| get(id) }
+        end
+
+        def get(id)
+          data = service.get_iprange(id).body
+          new(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/keys.rb

@@ -0,0 +1,33 @@
+#require 'fog/joyent/models/compute/key'
+
+module Fog
+  module Compute
+    class Fifo
+      class Keys < Fog::Collection
+
+        model Fog::Compute::Fifo::Key
+
+        def all
+          data = service.list_keys.body
+          load(data)
+        end
+
+        def get(keyname)
+          data = service.get_key(keyname).body
+          if data
+            new(data)
+          else
+            nil
+          end
+        end
+
+        def create(params = {})
+          raise ArgumentError, "option [name] required" unless params.key?(:name)
+          raise ArgumentError, "option [key] required" unless params.key?(:key)
+
+          service.create_key(params)
+        end
+
+      end
+    end
+  end

data/lib/fog/fifo/models/compute/network.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Compute
+    class Fifo
+      class Network < Fog::Model
+        identity :uuid
+
+        attribute :name
+        attribute :version
+        attribute :ipranges
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/networks.rb

@@ -0,0 +1,21 @@
+require 'fog/fifo/models/compute/network'
+module Fog
+  module Compute
+    class Fifo
+      class Networks < Fog::Collection
+
+        model Fog::Compute::Fifo::Network
+
+        def all
+          service.list_networks().body.map{|id| get(id) }
+        end
+
+        def get(id)
+          data = service.get_network(id).body
+          new(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/package.rb

@@ -0,0 +1,17 @@
+module Fog
+  module Compute
+    class Fifo
+      class Package < Fog::Model
+
+        identity :uuid
+
+        attribute :name
+        attribute :ram
+        attribute :quota
+        attribute :cpu_cap
+        attribute :version
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/packages.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/fifo/models/compute/package'
+
+module Fog
+  module Compute
+
+    class Fifo
+      class Packages < Fog::Collection
+
+        model Fog::Compute::Fifo::Package
+
+        def all
+          service.list_packages().body.map{|id| get(id) }
+        end
+
+        def get(id)
+          data = service.get_package(id).body
+          new(data)
+        end
+
+      end
+    end # Fifo
+
+  end # Compute
+end # Fog

data/lib/fog/fifo/models/compute/server.rb

@@ -0,0 +1,67 @@
+require 'fog/compute/models/server'
+module Fog
+  module Compute
+    class Fifo
+
+      class Server < Fog::Compute::Server
+        identity :uuid
+
+        attribute :state
+        attribute :hypervisor
+        attribute :config
+        attribute :package
+        attribute :network
+
+        def dataset
+          requires :uuid
+          config["dataset"]
+        end
+
+        #def package
+        #  requires :uuid
+        #  config["package"]
+        #end
+
+        def ips
+          requires :uuid
+          config["networks"].map{|n| n["ip"]}
+        end
+
+        def memory
+          requires :uuid
+          config["ram"]
+        end
+
+        def reboot
+          requires :uuid
+          service.reboot_vm(uuid)
+          true
+        end
+
+        def stopped?
+          requires :uuid
+          self.state == 'stopped'
+        end
+
+        def stop
+          requires :uuid
+          service.stop_vm(uuid)
+          self.wait_for { stopped? }
+          true
+        end
+
+        def ready?
+          self.state == 'running'
+        end
+
+        def start
+          requires :uuid
+          service.start_vm(uuid)
+          self.wait_for { ready? }
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/models/compute/servers.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/fifo/models/compute/server'
+
+module Fog
+  module Compute
+
+    class Fifo
+      class Servers < Fog::Collection
+        model Fog::Compute::Fifo::Server
+
+        def all
+          service.list_vms().body.map{|id| get(id) }
+        end
+
+        def create(params = {})
+          data = service.create_vm(params).body
+          server = new(data)
+          server
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server
+        end
+
+        def get(machine_id)
+          data = service.get_vm(machine_id).body
+          new(data)
+        end
+
+      end
+    end # Fifo
+
+  end # Compute
+end # Fog

data/lib/fog/fifo/requests/compute/create_vm.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def start_vm(uuid)
+          if vm = self.data[:vms][uuid]
+            res = Excon::Response.new
+            res.status = 200
+            res.body = vm
+            res
+          else
+            raise Excon::Errors::NotFound, "Not Found"
+          end
+        end
+      end
+
+      class Real
+        def create_vm(params)
+          pp params
+          request(
+                  :method => "POST",
+                  :path => "vms",
+                  :expects => [200],
+                  :body => params
+                  )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/get_dataset.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def get_dataset(id)
+          if ds = self.data[:datasets][id]
+            res = Excon::Response.new
+            res.status = 200
+            res.body = ds
+          else
+            raise Excon::Errors::NotFound
+          end
+        end
+      end
+
+      class Real
+        def get_dataset(id)
+          request(
+            :method => "GET",
+            :path => "datasets/#{id}"
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/get_iprange.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Fifo
+      class Mock
+
+        def get_iprange(id)
+          if pkg = self.data[:iprange][id]
+            response = Excon::Response.new
+            response.body = pkg
+            response.status = 200
+            response
+          else
+            raise Excon::Errors::NotFound
+          end
+        end
+      end
+
+      class Real
+        def get_iprange(id)
+          request(
+                  :method => "GET",
+                  :path => "ipranges/#{id}",
+                  :expects => 200
+                  )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/get_network.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Fifo
+      class Mock
+
+        def get_network(id)
+          if pkg = self.data[:networks][id]
+            response = Excon::Response.new
+            response.body = pkg
+            response.status = 200
+            response
+          else
+            raise Excon::Errors::NotFound
+          end
+        end
+      end
+
+      class Real
+        def get_network(id)
+          request(
+                  :method => "GET",
+                  :path => "networks/#{id}",
+                  :expects => 200
+                  )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/get_package.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Fifo
+      class Mock
+
+        def get_package(id)
+          if pkg = self.data[:packages][id]
+            response = Excon::Response.new
+            response.body = pkg
+            response.status = 200
+            response
+          else
+            raise Excon::Errors::NotFound
+          end
+        end
+      end
+
+      class Real
+        def get_package(id)
+          request(
+            :method => "GET",
+            :path => "packages/#{id}",
+            :expects => 200
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/get_vm.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def get_vm(uuid)
+          if vm = self.data[:vms][uuid]
+            res = Excon::Response.new
+            res.status = 200
+            res.body = vm
+            res
+          else
+            raise Excon::Errors::NotFound, "Not Found"
+          end
+        end
+      end
+
+      class Real
+        def get_vm(id)
+          request(
+                  :method => "GET",
+                  :path => "vms/#{id}",
+                  :expects => [200]
+                  )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/list_datasets.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def list_datasets
+          res = Excon::Response.new
+          res.status = 200
+          res.body = self.data[:datasets].values
+          res
+        end
+      end
+
+      class Real
+        def list_datasets
+          request(
+            :method => "GET",
+            :path => "datasets"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/list_ipranges.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def list_ipranges
+          res = Excon::Response.new
+          res.status = 200
+          res.body = self.data[:ipranges].values
+          res
+        end
+      end
+
+      class Real
+        def list_ipranges
+          request(
+            :path => "ipranges",
+            :method => "GET",
+            :expects => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/list_networks.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def list_networks
+          res = Excon::Response.new
+          res.status = 200
+          res.body = self.data[:networks].values
+          res
+        end
+      end
+
+      class Real
+        def list_networks
+          request(
+            :path => "networks",
+            :method => "GET",
+            :expects => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/list_packages.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def list_packages
+          response = Excon::Response.new()
+          response.status = 200
+          response.body = self.data[:packages].values
+          response
+        end
+      end
+
+      class Real
+        def list_packages
+          request(
+            :path => "packages",
+            :method => "GET",
+            :expects => 200
+          )
+        end
+      end # Real
+
+    end
+
+  end
+end

data/lib/fog/fifo/requests/compute/list_vms.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def list_vm
+          res = Excon::Response.new
+          res.status = 200
+          res.body = self.data[:machines].values
+          res
+        end
+      end
+
+      class Real
+        def list_vms(options={})
+          request(
+            :path => "vms",
+            :method => "GET",
+            :query => options,
+            :expects => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/reboot_vm.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def remoot_vm(uuid)
+          if vm = self.data[:vms][uuid]
+            res = Excon::Response.new
+            res.status = 200
+            res
+          else
+            raise Excon::Errors::NotFound, "Not Found"
+          end
+        end
+      end
+
+      class Real
+        def reboot_vm(id)
+          request(
+                  :method => "PUT",
+                  :path => "vms/#{id}",
+                  :expects => [200],
+                  :body => {"action" => "reboot"},
+                  )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/start_vm.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def start_vm(uuid)
+          if vm = self.data[:vms][uuid]
+            res = Excon::Response.new
+            res.status = 200
+            res.body = vm
+            res
+          else
+            raise Excon::Errors::NotFound, "Not Found"
+          end
+        end
+      end
+
+      class Real
+        def start_vm(id)
+          request(
+                  :method => "PUT",
+                  :path => "vms/#{id}",
+                  :expects => [200],
+                  :body => {"action" => "start"},
+                  )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo/requests/compute/stop_vm.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Fifo
+
+      class Mock
+        def stop_vm(uuid)
+          if vm = self.data[:vms][uuid]
+            res = Excon::Response.new
+            res.status = 200
+            res.body = vm
+            res
+          else
+            raise Excon::Errors::NotFound, "Not Found"
+          end
+        end
+      end
+
+      class Real
+        def stop_vm(id)
+          request(
+                  :method => "PUT",
+                  :path => "vms/#{id}",
+                  :expects => [200],
+                  :body => {"action" => "stop"},
+                  )
+        end
+      end
+    end
+  end
+end

data/lib/fog/fifo.rb

@@ -0,0 +1,10 @@
+require 'fog/core'
+
+module Fog
+  module Fifo
+    extend Fog::Provider
+
+    service(:compute, 'fifo/compute', 'Compute')
+
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: fog-fifo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brian Akins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+description: fifo support for fog
+email:
+- brian@akins.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- examples/test.rb
+- fog-fifo.gemspec
+- lib/fog/fifo.rb
+- lib/fog/fifo/compute.rb
+- lib/fog/fifo/models/compute/dataset.rb
+- lib/fog/fifo/models/compute/datasets.rb
+- lib/fog/fifo/models/compute/iprange.rb
+- lib/fog/fifo/models/compute/ipranges.rb
+- lib/fog/fifo/models/compute/keys.rb
+- lib/fog/fifo/models/compute/network.rb
+- lib/fog/fifo/models/compute/networks.rb
+- lib/fog/fifo/models/compute/package.rb
+- lib/fog/fifo/models/compute/packages.rb
+- lib/fog/fifo/models/compute/server.rb
+- lib/fog/fifo/models/compute/servers.rb
+- lib/fog/fifo/requests/compute/create_vm.rb
+- lib/fog/fifo/requests/compute/get_dataset.rb
+- lib/fog/fifo/requests/compute/get_iprange.rb
+- lib/fog/fifo/requests/compute/get_network.rb
+- lib/fog/fifo/requests/compute/get_package.rb
+- lib/fog/fifo/requests/compute/get_vm.rb
+- lib/fog/fifo/requests/compute/list_datasets.rb
+- lib/fog/fifo/requests/compute/list_ipranges.rb
+- lib/fog/fifo/requests/compute/list_networks.rb
+- lib/fog/fifo/requests/compute/list_packages.rb
+- lib/fog/fifo/requests/compute/list_vms.rb
+- lib/fog/fifo/requests/compute/reboot_vm.rb
+- lib/fog/fifo/requests/compute/start_vm.rb
+- lib/fog/fifo/requests/compute/stop_vm.rb
+homepage: https://github.com/bakins/fog-fifo
+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: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: fifo support for fog
+test_files: []
+has_rdoc: