yao 0.0.2.rc3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04c45b85c7164bc9cd7bac93189eec8c2aff4712
+  data.tar.gz: cb05d894031f89862beba5e27c372ba7ec09d8e3
+SHA512:
+  metadata.gz: a4745f172f77fd7fa273f2253ab94394b6223d5d26fd0d10c42cd809bea46b05b3059cf9cb260acb8fdc7eb6cad0303aff87c68321ebbb15dda2a86b615a47ec
+  data.tar.gz: 415e8fcd67ca260f14ec1105d83197680c0c999a7d1c5f07ee2ea00263a0c99d9c5401aaddde7b7d77b7d99153d2c858914481f885d9ed98fb3ab0fa83b6b258

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+tmp
+
+/vendor/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yao.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Uchio, KONDO
+
+MIT License
+
+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,61 @@
+# Yao
+
+YAO is a Yet Another OpenStack API Wrapper that rocks!!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yao'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yao
+
+## Usage
+
+```ruby
+require 'yao'
+
+Yao.configure do
+  auth_url    "http://keystone.example.local:8080/v2.0/tokens"
+  tenant_name "fooproject"
+  username    "udzura"
+  password    "tonk0tsu-r@men"
+end
+
+Yao::Network.list # list up networks...
+Yao::Server.list_detail # list up instances...
+```
+
+## Pro tips
+
+You can use a prittier namespace:
+
+```ruby
+# Instead of require-ing 'yao'
+require 'yao/is_openstack_client'
+
+OpenStack.configure do
+  auth_url    "http://keystone.example.local:8080/v2.0/tokens"
+  tenant_name "fooproject"
+  username    "udzura"
+  password    "tonk0tsu-r@men"
+end
+
+OpenStack::Server.list_detail # And let's go on
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/udzura/yao/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/yao/auth.rb

@@ -0,0 +1,74 @@
+require 'yao'
+require 'json'
+require 'time'
+
+module Yao::Auth
+  %i(tenant_name username password).each do |name|
+    Yao.config.param name, nil do |_|
+      Yao::Auth.try_new
+    end
+  end
+
+  class << self
+    def try_new
+      if Yao.config.tenant_name && Yao.config.username && Yao.config.password && Yao.default_client
+        Yao::Auth.new
+      end
+    end
+
+    def new(
+        tenant_name: Yao.config.tenant_name,
+        username: Yao.config.username,
+        password: Yao.config.password
+    )
+      authinfo = {
+        auth: {
+          passwordCredentials: {
+            username: username, password: password
+          }
+        }
+      }
+      authinfo[:auth][:tenantName] = tenant_name if tenant_name
+
+      reply = Yao.default_client.default.post('/v2.0/tokens') do |req|
+        req.body = authinfo.to_json
+        req.headers['Content-Type'] = 'application/json'
+      end
+
+      body = reply.body["access"]
+
+      token = Token.new(body["token"])
+      token.register_endpoints(body["serviceCatalog"])
+      return token
+    end
+  end
+
+  class Token
+    def initialize(token_data)
+      @token = token_data["id"]
+      @issued_at = Time.parse token_data["issued_at"]
+      @expire_at = Time.parse token_data["expires"]
+
+      @endpoints = {}
+    end
+    attr_accessor :token, :issued_at, :expire_at, :endpoints
+    alias expires expire_at
+
+    def register_endpoints(_endpoints)
+      return unless _endpoints
+
+      _endpoints.each do |endpoint_data|
+        key = endpoint_data["type"]
+        value = if d = endpoint_data["endpoints"].first
+                  d["publicURL"]
+                else
+                  nil
+                end
+        if value
+          @endpoints[key] = value
+        end
+      end
+      Yao.default_client.register_endpoints(@endpoints, token: @token)
+    end
+  end
+end

data/lib/yao/client.rb

@@ -0,0 +1,70 @@
+require 'yao'
+require 'yao/config'
+require 'faraday'
+require 'faraday_middleware'
+require 'yao/faraday_middlewares'
+
+module Yao
+  module Client
+    class ClientSet
+      def initialize
+        @pool = {}
+      end
+      attr_reader :pool
+
+      %w(default compute network image metering volume orchestration identity).each do |type|
+        define_method(type) do
+          self.pool[type]
+        end
+      end
+
+      def register_endpoints(endpoints, token: nil)
+        endpoints.each_pair do |type, endpoint|
+          # XXX: neutron just have v2.0 API and endpoint may not have version prefix
+          if type == "network" && URI.parse(endpoint).path == "/"
+            endpoint = File.join(endpoint, "v2.0")
+          end
+
+          self.pool[type] = Yao::Client.gen_client(endpoint, token: token)
+        end
+      end
+    end
+
+    class << self
+      attr_accessor :default_client
+
+      def gen_client(endpoint, token: nil)
+        Faraday.new( endpoint ) do |f|
+          f.request :url_encoded
+          f.request :json
+
+          if token
+            f.request :os_token, token
+          end
+
+          f.response :json, :content_type => /\bjson$/
+          f.response :logger
+
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def reset_client(new_endpoint=nil)
+        set = ClientSet.new
+        set.register_endpoints("default" => (new_endpoint || Yao.config.endpoint))
+        self.default_client = set
+      end
+    end
+
+    Yao.config.param :auth_url, nil do |endpoint|
+      if endpoint
+        Yao::Client.reset_client(endpoint)
+        Yao::Auth.try_new
+      end
+    end
+  end
+
+  def self.default_client
+    Yao::Client.default_client
+  end
+end

data/lib/yao/config.rb

@@ -0,0 +1,52 @@
+require 'yao'
+
+module Yao
+  class Config
+    def _configuration_defaults
+      @_configuration_defaults ||= {}
+    end
+
+    def _configuration_hooks
+      @_configuration_hooks ||= {}
+    end
+
+    def configuration
+      @configuration ||= {}
+    end
+
+    def param(name, default, &hook)
+      raise("Duplicate definition of #{name}") if self.respond_to?(name)
+
+      name = name.to_sym
+      _configuration_defaults[name] = default
+      _configuration_hooks[name] = hook if block_given?
+      self.define_singleton_method(name) do |*a|
+        case a.size
+        when 0
+          configuration[name] || _configuration_defaults[name]
+        when 1
+          set(name, a.first)
+        else
+          raise ArgumentError, "wrong number of arguments (#{a.size} for 0, 1)"
+        end
+      end
+    end
+
+    def set(name, value)
+      raise("Undefined config key #{name}") unless self.respond_to?(name)
+      configuration[name.to_sym] = value
+      _configuration_hooks[name].call(value) if _configuration_hooks[name]
+      value
+    end
+  end
+
+  def self.config(&blk)
+    @__config ||= Config.new
+    @__config.instance_eval(&blk) if blk
+    @__config
+  end
+
+  def self.configure(&blk)
+    config &blk
+  end
+end

data/lib/yao/faraday_middlewares.rb

@@ -0,0 +1,14 @@
+require 'faraday'
+
+class Faraday::Request::OSToken
+  def initialize(app, token)
+    @app = app
+    @token = token
+  end
+
+  def call(env)
+    env[:request_headers]['X-Auth-Token'] = @token
+    @app.call(env)
+  end
+end
+Faraday::Request.register_middleware os_token: -> { Faraday::Request::OSToken }

data/lib/yao/is_openstack_client.rb

@@ -0,0 +1,14 @@
+unless defined? OpenStack
+  module OpenStack
+  end
+
+  Yao = OpenStack
+
+  # XXX: Some case, 'yao/version' is pre-required and
+  # will delete Yao::VERSION const by reassign in L5
+  unless require('yao/version')
+    load 'yao/version.rb'
+  end
+end
+
+require 'yao'

data/lib/yao/resources/base.rb

@@ -0,0 +1,69 @@
+require 'yao/resources/restfully_accessible'
+require 'time'
+
+module Yao::Resources
+  class Base
+    def self.friendly_attributes(*names)
+      names.map(&:to_s).each do |name|
+        define_method(name) do
+          self[name]
+        end
+      end
+    end
+
+    def self.map_attribute_to_attribute(k_and_v)
+      as_json, as_method = *k_and_v.to_a.first.map(&:to_s)
+      define_method(as_method) do
+        self[as_json]
+      end
+    end
+
+    def self.map_attribute_to_resource(k_and_v)
+      _name, klass = *k_and_v.to_a.first
+      name = _name.to_s
+      define_method(name) do
+        self[[name, klass].join("__")] ||= klass.new(self[name])
+      end
+    end
+
+    def self.map_attribute_to_resources(k_and_v)
+      _name, klass = *k_and_v.to_a.first
+      name = _name.to_s
+      define_method(name) do
+        self[[name, klass].join("__")] ||= self[name].map {|d|
+          klass.new(d)
+        }
+      end
+    end
+
+    def initialize(data_via_json)
+      @data = data_via_json
+    end
+
+    def [](name)
+      @data[name]
+    end
+
+    def []=(name, value)
+      @data[name] = value
+    end
+
+    def id
+      self["id"]
+    end
+
+    def created
+      if date = self["created"]
+        Time.parse(date)
+      end
+    end
+
+    def updated
+      if date = self["updated"]
+        Time.parse(date)
+      end
+    end
+
+    extend RestfullyAccessible
+  end
+end

data/lib/yao/resources/flavor.rb

@@ -0,0 +1,21 @@
+module Yao::Resources
+  class Flavor < Base
+    friendly_attributes :name, :vcpus, :disk, :swap
+    map_attribute_to_attribute "os-flavor-access:is_public" => :public?
+    map_attribute_to_attribute "OS-FLV-DISABLED:disabled"   => :disabled?
+
+    def ram(unit='M')
+      case unit
+      when 'M'
+        self["ram"]
+      when 'G'
+        self["ram"] / 1024.0
+      end
+    end
+    alias memory ram
+
+    self.service        = "compute"
+    self.resource_name  = "flavor"
+    self.resources_name = "flavors"
+  end
+end

data/lib/yao/resources/floating_ip.rb

@@ -0,0 +1,9 @@
+module Yao::Resources
+  class FloatingIP < Base
+    friendly_attributes :fixed_ip, :instance_id, :ip, :pool
+
+    self.service        = "compute"
+    self.resource_name  = "os-floating-ip"
+    self.resources_name = "os-floating-ips"
+  end
+end

data/lib/yao/resources/hypervisor.rb

@@ -0,0 +1,20 @@
+module Yao::Resources
+  class Hypervisor < Base
+    friendly_attributes :hypervisor_hostname, :hypervisor_type, :hypervisor_version, :running_vms, :current_workload
+                        :vcpus, :vcpus_used,
+                        :memory_mb, :memory_mb_used, :free_disk_gb,
+                        :local_gb, :local_gb_used, :free_disk_gb
+
+    def cpu_info
+      JSON.parse self["cpu_info"]
+    end
+
+    alias hostname hypervisor_hostname
+    alias type     hypervisor_hostname
+    alias version  hypervisor_version
+
+    self.service        = "compute"
+    self.resource_name  = "os-hypervisor"
+    self.resources_name = "os-hypervisors"
+  end
+end

data/lib/yao/resources/image.rb

@@ -0,0 +1,28 @@
+require 'yao/resources/metadata_available'
+module Yao::Resources
+  class Image < Base
+    friendly_attributes :name, :status, :progress, :metadata
+    map_attribute_to_attribute :minDisk => :min_disk
+    map_attribute_to_attribute :minRam  => :min_ram
+
+    def size(unit=nil)
+      size = self["OS-EXT-IMG-SIZE:size"]
+      case unit
+      when 'K'
+        size / 1024.0
+      when 'M'
+        size / 1024.0 / 1024.0
+      when 'G'
+        size / 1024.0 / 1024.0 / 1024.0
+      else
+        size
+      end
+    end
+
+    self.service        = "compute"
+    self.resource_name  = "image"
+    self.resources_name = "images"
+
+    extend MetadataAvailable
+  end
+end

data/lib/yao/resources/keypair.rb

@@ -0,0 +1,13 @@
+module Yao::Resources
+  class Keypair < Base
+    friendly_attributes :name, :public_key, :fingerprint
+
+    self.service        = "compute"
+    self.resource_name  = "os-keypair"
+    self.resources_name = "os-keypairs"
+
+    def self.list
+      super.map{|r| r[resource_name_in_json] }
+    end
+  end
+end

data/lib/yao/resources/metadata_available.rb

@@ -0,0 +1,50 @@
+module Yao::Resources
+  module MetadataAvailable
+    def list_metadata(id)
+      GET(metadata_path(id)).body["metadata"]
+    end
+
+    def create_metadata(id, metadata)
+      res = POST(metadata_path(id)) do |req|
+        req.body = {"metadata" => metadata}.to_json
+        req.headers['Content-Type'] = 'application/json'
+      end
+      res.body["metadata"]
+    end
+    alias append_metadata create_metadata
+
+    def update_metadata(id, metadata)
+      res = PUT(metadata_path(id)) do |req|
+        req.body = {"metadata" => metadata}.to_json
+        req.headers['Content-Type'] = 'application/json'
+      end
+      res.body["metadata"]
+    end
+    alias replace_metadata update_metadata
+
+    def get_metadata(id, key)
+      GET(metadata_key_path(id, key)).body["meta"]
+    end
+
+    def set_metadata(id, key, value)
+      res = PUT(metadata_key_path(id, key)) do |req|
+        req.body = {"meta" => {key => value}}.to_json
+        req.headers['Content-Type'] = 'application/json'
+      end
+      res.body["meta"]
+    end
+
+    def delete_metadata(id, key)
+      DELETE(metadata_key_path(id, key)).body
+    end
+
+    private
+    def metadata_path(id)
+      ["servers", id, "metadata"].join("/")
+    end
+
+    def metadata_key_path(id, key)
+      ["servers", id, "metadata", key].join("/")
+    end
+  end
+end

data/lib/yao/resources/network.rb

@@ -0,0 +1,14 @@
+module Yao::Resources
+  class Network < Base
+    friendly_attributes :name, :status, :shared, :tenant_id, :subnets, :admin_state_up
+    map_attribute_to_attribute "provider:physical_network" => :physical_network
+    map_attribute_to_attribute "provider:network_type"     => :type
+    map_attribute_to_attribute "provider:segmentation_id"  => :segmentation_id
+
+    alias shared? shared
+
+    self.service        = "network"
+    self.resource_name  = "network"
+    self.resources_name = "networks"
+  end
+end

data/lib/yao/resources/port.rb

@@ -0,0 +1,24 @@
+module Yao::Resources
+  class Port < Base
+    friendly_attributes :name, :mac_address, :status, :allowed_address_pairs,
+                        :device_owner, :fixed_ips, :security_groups, :device_id,
+                        :network_id, :tenant_id, :admin_state_up
+    map_attribute_to_attribute "binding:host_id" => :host_id
+
+    def primary_ip
+      fixed_ips.first["ip_address"]
+    end
+
+    def primary_subnet
+      Yao::Subnet.find fixed_ips.first["subnet_id"]
+    end
+
+    def network
+      Yao::Network.find network_id
+    end
+
+    self.service        = "network"
+    self.resource_name  = "port"
+    self.resources_name = "ports"
+  end
+end

data/lib/yao/resources/restfully_accessible.rb

@@ -0,0 +1,91 @@
+require "forwardable"
+
+module Yao::Resources
+  module RestfullyAccessible
+    def self.extended(base)
+      base.class_eval do
+        class << self
+          attr_reader   :client
+          attr_accessor :resource_name, :resources_name
+
+          extend Forwardable
+          %w(get post put delete).each do |method_name|
+            def_delegator :client, method_name, method_name.upcase
+          end
+        end
+      end
+    end
+
+    def service=(name)
+      @service = name
+      @client = Yao.default_client.pool[name]
+    end
+
+    def service
+      @service
+    end
+
+    # restful methods
+    def list
+      return_resources(GET(resources_name).body[resources_name_in_json])
+    end
+
+    def list_detail
+      return_resources(GET([resources_name, "detail"].join("/")).body[resources_name_in_json])
+    end
+
+    def get(id_or_permalink)
+      res = if id_or_permalink =~ /^https?:\/\//
+              GET(id_or_permalink)
+            else
+              GET([resources_name, id_or_permalink].join("/"))
+            end
+      return_resource(res.body[resource_name_in_json])
+    end
+    alias find get
+
+    def create(resource_params)
+      params = {
+        resource_name_in_json => resource_params
+      }
+      res = POST(resources_name) do |req|
+        req.body = params.to_json
+        req.headers['Content-Type'] = 'application/json'
+      end
+      return_resource(res.body[resource_name_in_json])
+    end
+
+    def update(id, resource_params)
+      params = {
+        resource_name_in_json => resource_params
+      }
+      res = PUT([resources_name, id].join("/")) do |req|
+        req.body = params.to_json
+        req.headers['Content-Type'] = 'application/json'
+      end
+      return_resource(res.body[resource_name_in_json])
+    end
+
+    def destroy(id)
+      res = DELETE([resources_name, id].join("/"))
+      res.body
+    end
+
+    private
+    def resource_name_in_json
+      @resource_name_in_json  ||= resource_name.sub(/^os-/, "").tr("-", "_")
+    end
+
+    def resources_name_in_json
+      @resources_name_in_json ||= resources_name.sub(/^os-/, "").tr("-", "_")
+    end
+
+    def return_resource(d)
+      new(d)
+    end
+
+    def return_resources(arr)
+      arr.map{|d| return_resource(d) }
+    end
+  end
+end

data/lib/yao/resources/security_group.rb

@@ -0,0 +1,40 @@
+require 'yao/resources/security_group_rule'
+module Yao::Resources
+  class SecurityGroup < Base
+    friendly_attributes :name, :description, :tenant_id
+
+    def rules
+      self[["rules", SecurityGroupRule].join("__")] ||= (case self.class.service
+      when "compute"
+        self["rules"].map{|r| SecurityGroupRule.new(r) }
+      when "network"
+        self["security_group_rules"].map{|r| SecurityGroupRule.new(r) }
+      end)
+    end
+
+    self.service        = "compute"
+    self.resource_name  = "os-security-group"
+    self.resources_name = "os-security-groups"
+  end
+end
+
+Yao.config.param :security_group_service, "compute" do |service|
+  case service
+  when "compute"
+    Yao::Resources::SecurityGroup.service        = service
+    Yao::Resources::SecurityGroup.resource_name  = "os-security-group"
+    Yao::Resources::SecurityGroup.resources_name = "os-security-groups"
+
+    Yao::Resources::SecurityGroupRule.service        = service
+    Yao::Resources::SecurityGroupRule.resource_name  = "os-security-group-rule"
+    Yao::Resources::SecurityGroupRule.resources_name = "os-security-group-rules"
+  when "network"
+    Yao::Resources::SecurityGroup.service        = service
+    Yao::Resources::SecurityGroup.resource_name  = "security-group"
+    Yao::Resources::SecurityGroup.resources_name = "security-groups"
+
+    Yao::Resources::SecurityGroupRule.service        = service
+    Yao::Resources::SecurityGroupRule.resource_name  = "security-group-rule"
+    Yao::Resources::SecurityGroupRule.resources_name = "security-group-rules"
+  end
+end

data/lib/yao/resources/security_group_rule.rb

@@ -0,0 +1,55 @@
+require 'yao/resources/security_group'
+module Yao::Resources
+  class SecurityGroupRule < Base
+    friendly_attributes :ethertype
+
+    def self.define_attribute_with_guard(_name, _guard_name)
+      name = _name.to_s
+      guard_name = _guard_name.to_s
+      define_method name do
+        self[name] || self[guard_name]
+      end
+    end
+
+    define_attribute_with_guard :port_range_max, :from_port
+    define_attribute_with_guard :port_range_min, :to_port
+    define_attribute_with_guard :protocol, :ip_protocol
+    define_attribute_with_guard :security_group_id, :parent_group_id
+
+    def security_group
+      SecurityGroup.find(security_group_id)
+    end
+
+    def port
+      if port_range_max == port_range_min
+        port_range_max
+      else
+        port_range
+      end
+    end
+
+    def remote_ip_cidr
+      if cidr = self["remote_ip_prefix"]
+        cidr
+      elsif ip_range = self["ip_range"]
+        ip_range["cidr"]
+      end
+    end
+
+    def port_range
+      port_range_max..port_range_min
+    end
+
+    def remote_group
+      return nil if self["remote_group_id"].nil? && (self["group"].nil? || self["group"].empty?)
+
+      SecurityGroup.new(
+        {"id" => self["remote_group_id"]}.merge(self["group"] || {})
+      )
+    end
+
+    self.service        = "compute"
+    self.resource_name  = "os-security-group-rule"
+    self.resources_name = "os-security-group-rules"
+  end
+end

data/lib/yao/resources/server.rb

@@ -0,0 +1,17 @@
+require 'yao/resources/metadata_available'
+module Yao::Resources
+  class Server < Base
+    friendly_attributes :addresses, :metadata, :name, :progress,
+                        :status, :tenant_id, :user_id, :key_name
+    map_attribute_to_attribute :hostId => :host_id
+    map_attribute_to_resource  :flavor => Flavor
+    map_attribute_to_resource  :image  => Image
+    map_attribute_to_resources :security_groups => SecurityGroup
+
+    self.service        = "compute"
+    self.resource_name  = "server"
+    self.resources_name = "servers"
+
+    extend MetadataAvailable
+  end
+end

data/lib/yao/resources/subnet.rb

@@ -0,0 +1,22 @@
+module Yao::Resources
+  class Subnet < Base
+    friendly_attributes :name, :cidr, :gateway_ip, :network_id, :tenant_id, :ip_version,
+                        :dns_nameservers, :host_routes, :enable_dhcp
+
+    def allocation_pools
+      self["allocation_pools"].map do |pool|
+        pool["start"]..pool["end"]
+      end
+    end
+
+    def network
+      Yao::Network.find network_id
+    end
+
+    alias dhcp_enabled? enable_dhcp
+
+    self.service        = "network"
+    self.resource_name  = "subnet"
+    self.resources_name = "subnets"
+  end
+end

data/lib/yao/resources.rb

@@ -0,0 +1,25 @@
+module Yao
+  module Resources
+    require "yao/resources/base"
+
+    autoload :Server,            "yao/resources/server"
+    autoload :Flavor,            "yao/resources/flavor"
+    autoload :Image,             "yao/resources/image"
+    autoload :SecurityGroup,     "yao/resources/security_group"
+    autoload :SecurityGroupRule, "yao/resources/security_group_rule"
+    autoload :Hypervisor,        "yao/resources/hypervisor"
+    autoload :Keypair,           "yao/resources/keypair"
+    autoload :FloatingIP,        "yao/resources/floating_ip"
+    autoload :Network,           "yao/resources/network"
+    autoload :Subnet,            "yao/resources/subnet"
+    autoload :Port,              "yao/resources/port"
+
+  end
+
+  def self.const_missing(name)
+    new_klass = Yao::Resources.const_get(name)
+    Yao.const_set(name, new_klass)
+  rescue NameError
+    super
+  end
+end

data/lib/yao/version.rb

@@ -0,0 +1,3 @@
+module Yao
+  VERSION = "0.0.2.rc3"
+end

data/lib/yao.rb

@@ -0,0 +1,9 @@
+require "yao/version"
+
+module Yao
+end
+
+require 'yao/config'
+require 'yao/client'
+require 'yao/auth'
+require 'yao/resources'

data/yao.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yao/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "yao"
+  spec.version       = Yao::VERSION
+  spec.authors       = ["Uchio, KONDO"]
+  spec.email         = ["udzura@udzura.jp"]
+  spec.summary       = %q{Yet Another OpenStack API Wrapper that rocks!!}
+  spec.description   = %q{YAO is a Yet Another OpenStack API Wrapper that rocks!!}
+  spec.homepage      = "https://github.com/udzura/yao"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.add_dependency "json"
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday_middleware"
+
+  spec.add_development_dependency "bundler", ">= 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "test-unit", ">= 3"
+  spec.add_development_dependency "test-unit-rr"
+  spec.add_development_dependency "power_assert"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: yao
+version: !ruby/object:Gem::Version
+  version: 0.0.2.rc3
+platform: ruby
+authors:
+- Uchio, KONDO
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: test-unit-rr
+  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: power_assert
+  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: 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'
+description: YAO is a Yet Another OpenStack API Wrapper that rocks!!
+email:
+- udzura@udzura.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/yao.rb
+- lib/yao/auth.rb
+- lib/yao/client.rb
+- lib/yao/config.rb
+- lib/yao/faraday_middlewares.rb
+- lib/yao/is_openstack_client.rb
+- lib/yao/resources.rb
+- lib/yao/resources/base.rb
+- lib/yao/resources/flavor.rb
+- lib/yao/resources/floating_ip.rb
+- lib/yao/resources/hypervisor.rb
+- lib/yao/resources/image.rb
+- lib/yao/resources/keypair.rb
+- lib/yao/resources/metadata_available.rb
+- lib/yao/resources/network.rb
+- lib/yao/resources/port.rb
+- lib/yao/resources/restfully_accessible.rb
+- lib/yao/resources/security_group.rb
+- lib/yao/resources/security_group_rule.rb
+- lib/yao/resources/server.rb
+- lib/yao/resources/subnet.rb
+- lib/yao/version.rb
+- yao.gemspec
+homepage: https://github.com/udzura/yao
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.3
+signing_key: 
+specification_version: 4
+summary: Yet Another OpenStack API Wrapper that rocks!!
+test_files: []