cloudn-api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f86deae77bda5227585715b67913482877da788e
+  data.tar.gz: d8e0e476786d624151fc3fb1e594994a3665e58f
+SHA512:
+  metadata.gz: a4d027f6ecbefa5331eda50b8aa0343a2a9343c8679bca94ef98e9e320767caffdd187736b02170b14711c6455d93bdce623f43d937e95b9441e558e74a580a3
+  data.tar.gz: e427b31a12f1f4ab3cc22f9ab68b37b67b84eef70e323f8390f20bd5104663a4fd116f815b73c7c2c1cfb7b242944853a659ce88efe7ed28b35eb96e75b803d1

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+Gemfile.lock
+InstalledFiles
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea
+vendor/bundle
+

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/CloudnAPI.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cloudn-api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cloudn-api"
+  spec.version       = CloudnAPI::VERSION
+  spec.authors       = [""]
+  spec.email         = [""]
+  spec.summary       = %q{Library for manipulate Cloudn API easily}
+  spec.description   = %q{Library for manipulate Cloudn API easily}
+  spec.homepage      = "https://github.com/nttcom/cloudn-api"
+  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_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2015 NTT Communications Corporation, http://www.ntt.com
+
+(The 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,86 @@
+# CloudnAPI
+
+CloudnAPI is a library for manipulating Cloudn API easily.
+
+This library is designed as external library so you can't use CloudAPI alone like `./cloudn-api`.
+If you need an executable one, then check [Cloudn CLI](https://github.com/nttcom/cloudn-cli).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cloudn-api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cloudn-api
+
+Install path option such as '--path vendor/bundle' is recommended in order to limit scope.
+
+
+## Usage
+
+2 steps are required:
+
+#### STEP 1. Set up Cloudn configuration
+You can choose one of methods to write down the configuration:
+
+- a) Create JSON file(*) wherever you like, then specify it when you create instance as STEP 2.
+- b) Create JSON file at ~/.cloudnapi/config, which is the default location Cloudn API gem will seek.
+- c) Set 3 Environmental Variables : 'CLOUDN_API_KEY', 'CLOUDN_SECRET_KEY', 'CLOUDN_URL'. The values of them is same as JSON file as follows.
+
+*JSON file :
+
+```
+{
+  "url" : "CLOUDN API ENDPOINT",
+  "api_key" : "YOUR API KEY",
+  "secret_key" : "YOUR SECRET KEY",
+  "debug_level" : "info"
+}
+```
+
+The string of debug_level is based on Ruby [Logger](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/logger/rdoc/Logger.html).
+
+#### STEP 2. Create instance of Cloudn API (Synopsis)
+Write down some fancy codes with Cloudn API.
+
+```
+require 'cloudn-api'
+
+# Create Cloudn API instance
+client = CloudnAPI::Client.new
+
+# Configuration file can be specified here explicitly.
+## client = CloudnAPI::Client.new('hoge/foobar.json')
+
+# Then use Cloudn API
+
+## when an API doesn't need any options, call method with no argument like this:
+client.listUsers
+
+## when an API needs options, then call method with arguments like this:
+client.listUsers({ keyword: 'YOUR KEY WORD' })
+```
+
+Methods available are checked at :
+
+- http://www.cloudn-service.com/guide/manuals/html/flat-api/
+- http://www.cloudn-service.com/guide/manuals/html/vpcopennw-api/
+
+
+## Misc
+
+- Async query is handled as synced query, which means CloudnAPI library waits for http response from Cloudn.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/CloudnAPI/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,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/lib/cloudn-api.rb

@@ -0,0 +1,3 @@
+require 'cloudn-api/version'
+require 'cloudn-api/client'
+

data/lib/cloudn-api/api.json

@@ -0,0 +1,345 @@
+[
+  "activateProject",
+  "addAccountToProject",
+  "addCluster",
+  "addExternalFirewall",
+  "addExternalLoadBalancer",
+  "addF5LoadBalancer",
+  "addHost",
+  "addNetscalerLoadBalancer",
+  "addNetworkDevice",
+  "addNetworkServiceProvider",
+  "addNiciraNvpDevice",
+  "addNicToVirtualMachine",
+  "addS3",
+  "addSecondaryStorage",
+  "addSrxFirewall",
+  "addSwift",
+  "addTrafficMonitor",
+  "addTrafficType",
+  "addVpnUser",
+  "assignToLoadBalancerRule",
+  "assignVirtualMachine",
+  "associateIpAddress",
+  "associateLun",
+  "attachIso",
+  "attachVolume",
+  "authorizeSecurityGroupEgress",
+  "authorizeSecurityGroupIngress",
+  "cancelHostMaintenance",
+  "cancelStorageMaintenance",
+  "changeServiceForRouter",
+  "changeServiceForSystemVm",
+  "changeServiceForVirtualMachine",
+  "configureF5LoadBalancer",
+  "configureNetscalerLoadBalancer",
+  "configureSrxFirewall",
+  "configureVirtualRouterElement",
+  "copyIso",
+  "copyTemplate",
+  "createAccount",
+  "createAutoScalePolicy",
+  "createAutoScaleVmGroup",
+  "createAutoScaleVmProfile",
+  "createCondition",
+  "createCounter",
+  "createDiskOffering",
+  "createDomain",
+  "createFirewallRule",
+  "createInstanceGroup",
+  "createIpForwardingRule",
+  "createLBStickinessPolicy",
+  "createLoadBalancerRule",
+  "createLunOnFiler",
+  "createNetwork",
+  "createNetworkACL",
+  "createNetworkACLList",
+  "createNetworkOffering",
+  "createPhysicalNetwork",
+  "createPod",
+  "createPool",
+  "createPortForwardingRule",
+  "createPrivateGateway",
+  "createProject",
+  "createRemoteAccessVpn",
+  "createSSHKeyPair",
+  "createSecurityGroup",
+  "createServiceOffering",
+  "createSnapshot",
+  "createSnapshotPolicy",
+  "createStaticRoute",
+  "createStorageNetworkIpRange",
+  "createStoragePool",
+  "createTags",
+  "createTemplate",
+  "createUser",
+  "createVPC",
+  "createVPCOffering",
+  "createVirtualRouterElement",
+  "createVlanIpRange",
+  "createVolume",
+  "createVolumeOnFiler",
+  "createVpnConnection",
+  "createVpnCustomerGateway",
+  "createVpnGateway",
+  "createZone",
+  "deleteAccount",
+  "deleteAccountFromProject",
+  "deleteAutoScalePolicy",
+  "deleteAutoScaleVmGroup",
+  "deleteAutoScaleVmProfile",
+  "deleteCiscoNexusVSM",
+  "deleteCluster",
+  "deleteCondition",
+  "deleteCounter",
+  "deleteDiskOffering",
+  "deleteDomain",
+  "deleteExternalFirewall",
+  "deleteExternalLoadBalancer",
+  "deleteF5LoadBalancer",
+  "deleteFirewallRule",
+  "deleteHost",
+  "deleteInstanceGroup",
+  "deleteIpForwardingRule",
+  "deleteIso",
+  "deleteLBStickinessPolicy",
+  "deleteLoadBalancerRule",
+  "deleteNetscalerLoadBalancer",
+  "deleteNetwork",
+  "deleteNetworkACL",
+  "deleteNetworkDevice",
+  "deleteNetworkOffering",
+  "deleteNetworkServiceProvider",
+  "deleteNiciraNvpDevice",
+  "deletePhysicalNetwork",
+  "deletePod",
+  "deletePool",
+  "deletePortForwardingRule",
+  "deletePrivateGateway",
+  "deleteProject",
+  "deleteProjectInvitation",
+  "deleteRemoteAccessVpn",
+  "deleteSSHKeyPair",
+  "deleteSecurityGroup",
+  "deleteServiceOffering",
+  "deleteSnapshot",
+  "deleteSnapshotPolicies",
+  "deleteSrxFirewall",
+  "deleteStaticRoute",
+  "deleteStorageNetworkIpRange",
+  "deleteStoragePool",
+  "deleteTags",
+  "deleteTemplate",
+  "deleteTrafficMonitor",
+  "deleteTrafficType",
+  "deleteUser",
+  "deleteVPC",
+  "deleteVPCOffering",
+  "deleteVlanIpRange",
+  "deleteVolume",
+  "deleteVpnConnection",
+  "deleteVpnCustomerGateway",
+  "deleteVpnGateway",
+  "deleteZone",
+  "deployVirtualMachine",
+  "destroyLunOnFiler",
+  "destroyRouter",
+  "destroySystemVm",
+  "destroyVirtualMachine",
+  "destroyVolumeOnFiler",
+  "detachIso",
+  "detachVolume",
+  "disableAccount",
+  "disableAutoScaleVmGroup",
+  "disableCiscoNexusVSM",
+  "disableStaticNat",
+  "disableUser",
+  "disassociateIpAddress",
+  "dissociateLun",
+  "enableAccount",
+  "enableAutoScaleVmGroup",
+  "enableCiscoNexusVSM",
+  "enableStaticNat",
+  "enableStorageMaintenance",
+  "enableUser",
+  "extractIso",
+  "extractTemplate",
+  "extractVolume",
+  "generateUsageRecords",
+  "getApiLimit",
+  "getCloudIdentifier",
+  "getUser",
+  "getVMPassword",
+  "ldapConfig",
+  "ldapRemove",
+  "listAccounts",
+  "listAlerts",
+  "listApis",
+  "listAsyncJobs",
+  "listAutoScalePolicies",
+  "listAutoScaleVmGroups",
+  "listAutoScaleVmProfiles",
+  "listCapabilities",
+  "listCapacity",
+  "listCiscoNexusVSMs",
+  "listClusters",
+  "listConditions",
+  "listConfigurations",
+  "listCounters",
+  "listDiskOfferings",
+  "listDomainChildren",
+  "listDomains",
+  "listEventTypes",
+  "listEvents",
+  "listExternalFirewalls",
+  "listExternalLoadBalancers",
+  "listF5LoadBalancerNetworks",
+  "listF5LoadBalancers",
+  "listFirewallRules",
+  "listHosts",
+  "listHypervisorCapabilities",
+  "listHypervisors",
+  "listInstanceGroups",
+  "listIpForwardingRules",
+  "listIsoPermissions",
+  "listIsos",
+  "listLBStickinessPolicies",
+  "listLoadBalancerRuleInstances",
+  "listLoadBalancerRules",
+  "listLunsOnFiler",
+  "listNetscalerLoadBalancerNetworks",
+  "listNetscalerLoadBalancers",
+  "listNetworkACLs",
+  "listNetworkACLLists",
+  "listNetworkDevice",
+  "listNetworkOfferings",
+  "listNetworkServiceProviders",
+  "listNetworks",
+  "listNiciraNvpDeviceNetworks",
+  "listNiciraNvpDevices",
+  "listOsCategories",
+  "listOsTypes",
+  "listPhysicalNetworks",
+  "listPods",
+  "listPools",
+  "listPortForwardingRules",
+  "listPrivateGateways",
+  "listProjectAccounts",
+  "listProjectInvitations",
+  "listProjects",
+  "listPublicIpAddresses",
+  "listRemoteAccessVpns",
+  "listResourceLimits",
+  "listRouters",
+  "listS3s",
+  "listSSHKeyPairs",
+  "listSecurityGroups",
+  "listServiceOfferings",
+  "listSnapshotPolicies",
+  "listSnapshots",
+  "listSrxFirewallNetworks",
+  "listSrxFirewalls",
+  "listStaticRoutes",
+  "listStorageNetworkIpRange",
+  "listStoragePools",
+  "listSupportedNetworkServices",
+  "listSwifts",
+  "listSystemVms",
+  "listTags",
+  "listTemplatePermissions",
+  "listTemplates",
+  "listTrafficMonitors",
+  "listTrafficTypeImplementors",
+  "listTrafficTypes",
+  "listUsageRecords",
+  "listUsageTypes",
+  "listUsers",
+  "listVPCOfferings",
+  "listVPCs",
+  "listVirtualMachines",
+  "listVirtualRouterElements",
+  "listVlanIpRanges",
+  "listVolumes",
+  "listVolumesOnFiler",
+  "listVpnConnections",
+  "listVpnCustomerGateways",
+  "listVpnGateways",
+  "listVpnUsers",
+  "listZones",
+  "lockAccount",
+  "lockUser",
+  "markDefaultZoneForAccount",
+  "migrateSystemVm",
+  "migrateVirtualMachine",
+  "migrateVolume",
+  "modifyPool",
+  "prepareHostForMaintenance",
+  "prepareTemplate",
+  "queryAsyncJobResult",
+  "rebootRouter",
+  "rebootSystemVm",
+  "rebootVirtualMachine",
+  "reconnectHost",
+  "recoverVirtualMachine",
+  "registerIso",
+  "registerSSHKeyPair",
+  "registerTemplate",
+  "registerUserKeys",
+  "removeFromLoadBalancerRule",
+  "removeVpnUser",
+  "resetApiLimit",
+  "resetPasswordForVirtualMachine",
+  "resetVpnConnection",
+  "resizeVolume",
+  "restartNetwork",
+  "restartVPC",
+  "restoreVirtualMachine",
+  "revokeSecurityGroupEgress",
+  "revokeSecurityGroupIngress",
+  "startRouter",
+  "startSystemVm",
+  "startVirtualMachine",
+  "stopRouter",
+  "stopSystemVm",
+  "stopVirtualMachine",
+  "suspendProject",
+  "updateAccount",
+  "updateAutoScalePolicy",
+  "updateAutoScaleVmGroup",
+  "updateAutoScaleVmProfile",
+  "updateCluster",
+  "updateConfiguration",
+  "updateDiskOffering",
+  "updateDomain",
+  "updateHost",
+  "updateHostPassword",
+  "updateHypervisorCapabilities",
+  "updateInstanceGroup",
+  "updateIso",
+  "updateIsoPermissions",
+  "updateLoadBalancerRule",
+  "updateNetwork",
+  "updateNetworkOffering",
+  "updateNetworkServiceProvider",
+  "updatePhysicalNetwork",
+  "updatePod",
+  "updatePortForwardingRule",
+  "updateProject",
+  "updateProjectInvitation",
+  "updateResourceCount",
+  "updateResourceLimit",
+  "updateServiceOffering",
+  "updateStorageNetworkIpRange",
+  "updateStoragePool",
+  "updateTemplate",
+  "updateTemplatePermissions",
+  "updateTrafficType",
+  "updateUser",
+  "updateVPC",
+  "updateVPCOffering",
+  "updateVirtualMachine",
+  "updateVpnCustomerGateway",
+  "updateZone",
+  "uploadCustomCertificate",
+  "uploadVolume"
+]

data/lib/cloudn-api/client.rb

@@ -0,0 +1,232 @@
+module CloudnAPI
+
+  # In the Client class, there is camel-cased methods such as queryAsyncJobResult.
+  # Usually ruby methods are named along with snake-case,
+  # but this class needs to handle Cloudstack methods with Ruby's meta method : method_missing.
+  # So if you find camel-cased methods, you can think of that as calling Cloudstack method internally.
+
+  class Client
+
+    require 'json'
+    require 'openssl'
+    require 'open-uri'
+    require 'uri'
+    require 'base64'
+    require 'logger'
+    require 'erb'
+
+    API_LIST_PATH = '../api.json'
+    SLEEP_TIME_SEC = 5
+    RETRY_COUNT = 360    # wait for max 30 minutes
+    ASYNC_QUERY_FINISHED = 1
+    ASYNC_QUERY_ERROR = 2
+
+    attr_reader :api_key, :secret_key, :url, :api_list, :wait_async
+
+    def initialize(config_file = nil)
+      setup_logger_and_configs config_file
+
+      @api_key = @config_hash[:api_key].freeze
+      @secret_key = @config_hash[:secret_key].freeze
+      @url = URI.parse(@config_hash[:url]).freeze
+      @wait_async = true
+    end
+
+    # to handle CloudStack methods described in
+    #   http://cloudstack.apache.org/docs/api/apidocs-4.0.0/TOC_User.html
+    # Note that I didn't test all methods,so some methods wouldn't work properly.
+    def method_missing(method, *args)
+      super unless @api_list.include? method.to_s
+      hash_response = args ? request_api(method, args.pop) : request_api(method)
+      @logger.info hash_response
+
+      if @wait_async and hash_response.values.pop.has_key? 'jobid'
+        result = wait_for_async_job(hash_response.values.pop.fetch('jobid'))
+        result = result['queryasyncjobresultresponse']
+      else
+        result = hash_response
+      end
+      @logger.debug(result)
+      result
+    end
+
+    def setup_logger_and_configs(config_file)
+      @logger = Logger.new(STDOUT)
+      load_config config_file
+      load_api_list
+      configure_logger
+    end
+
+    # Wait until async job is finished
+    def wait_for_async_job(jobid)
+      RETRY_COUNT.times {
+        result = queryAsyncJobResult(jobid)
+
+        # When async job has finished, let's escape from loop
+        if result['queryasyncjobresultresponse']['jobstatus'] == ASYNC_QUERY_FINISHED
+          # @logger.info result
+          break result
+        elsif result['queryasyncjobresultresponse']['jobstatus'] == ASYNC_QUERY_ERROR
+          @logger.error result
+          raise StandardError.new('Error occurred')
+        end
+        sleep SLEEP_TIME_SEC
+      }
+    end
+
+    # This method is only explicitly defined method for Cloudstack
+    # in order to prevent infinite loop of method_missing.
+    def queryAsyncJobResult(jobid)
+      @logger.info "Requesting :queryAsyncJobResult - jobid=#{jobid}"
+      request_api(:queryAsyncJobResult, {jobid: jobid})
+    end
+
+    # build query string, then issue http request to Cloudn end point
+    def request_api(method, args=nil)
+      if args
+        hash_cloudn_api = args.merge({ command: method.to_s })
+        query_str = build_query_str hash_cloudn_api
+      else
+        query_str = build_query_str({ command:  method.to_s })
+      end
+      @logger.info "#{method} - #{@config_hash[:url]}?#{query_str}"
+      request query_str
+    end
+
+    # Set up logger instance
+    def configure_logger
+      @logger.progname = 'CloudnAPI'
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S "
+      log_level = @config_hash[:log_level] || :error
+      @logger.level =
+          case log_level.to_sym
+            when :info
+              Logger::INFO
+            when :debug
+              Logger::DEBUG
+            when :warn
+              Logger::WARN
+            when :error
+              Logger::ERROR
+            when :fatal
+              Logger::FATAL
+            else
+              Logger::INFO
+          end
+    end
+
+    # Issue HTTP request to API end point (url)
+    def request(query_string)
+      url = @url.dup
+      url.query = query_string
+
+      begin
+        response_text = OpenURI.open_uri(
+            url,
+            :ssl_verify_mode => OpenSSL::SSL::VERIFY_NONE,
+            'User-Agent' => "CloudnAPI/#{RUBY_VERSION}"
+        ).read
+      rescue OpenURI::HTTPError => ex
+        @logger.error url
+        @logger.error ex
+      rescue Exception => ex
+        @logger.error url
+        @logger.error ex
+      end
+      parsed_reponse = JSON.parse(response_text)
+    end
+
+    # Build query string such as
+    #   command=...&response=json&apiKey=...&signature=...
+    # @param hash_cloudn_api [Hash] hash of commands for cloudstack API
+    def build_query_str(hash_cloudn_api)
+      # Prepare to create signature and query string.
+      hash_cloudn_api_with_key = hash_cloudn_api.merge({:response => :json, :apikey => @api_key})
+
+      # Create signature
+      encoded_str = encode(hash_cloudn_api_with_key)
+      signature = create_signature encoded_str
+
+      # Create query string with signature
+      initial_str = hash_cloudn_api_with_key.flat_map {|k, v| "#{k}=#{ERB::Util.url_encode(v.to_s)}" }.join('&')
+      query_string = initial_str + "&signature=#{signature}"
+    end
+
+    # Create signature: Create HMAC with secret key, encode HMAC with Base64, and url-encode it
+    def create_signature(concatenated_str)
+      hmac = OpenSSL::HMAC::digest(::OpenSSL::Digest::SHA1.new, @secret_key, concatenated_str)
+      base64 = Base64.encode64(hmac).chomp
+      ERB::Util.url_encode(base64)
+    end
+
+    # Return url encoded string. Note: only values are url encoded.
+    def encode(param_hash)
+      encoded_hash = param_hash.each_with_object({}) { |(k, v), new_hash|
+        new_hash[k] = ERB::Util.url_encode(v.to_s).downcase
+      }
+      sorted_hash = Hash[encoded_hash.sort]
+      concatnated_str = sorted_hash.flat_map {|k, v| "#{k}=#{v}" }.join('&')
+    end
+
+    def load_api_list
+      api_list_path = File.expand_path(API_LIST_PATH, __FILE__)
+      list = open(api_list_path).read
+      @api_list = JSON.parse(list)
+    end
+
+    # Load configuration to @config_hash as follows
+    #   1. Check config_jfile which is explicitly specified
+    #   2. Check default location, ~/.cloudnapi/config
+    #   3. Check environmental variables
+    # If none of them can't be found, then report errors and exit.
+    def load_config(config_file)
+
+      # If config file is not specified, check default location
+      config_file = search_config_file unless config_file
+
+      # If there are ENV variables, then use them and return from this method.
+      # If none of them, configuration or Env variables, specified,
+      # then report error and exit.
+      unless config_file
+        if ENV['CLOUDN_API_KEY'] and ENV['CLOUDN_SECRET_KEY'] and ENV['CLOUDN_URL']
+          @config_hash = {}
+          @config_hash[:api_key] = ENV['CLOUDN_API_KEY']
+          @config_hash[:secret_key] = ENV['CLOUDN_SECRET_KEY']
+          @config_hash[:url] = ENV['CLOUDN_URL']
+          return
+        else
+          @logger.error("Couldn't find no configuration file.")
+          @logger.error('~/.cloudnapi/config or specify config file.')
+          exit 1
+        end
+      end
+
+      # Read and load @config_hash from config_file
+      config_body = open(config_file).read
+      begin
+        @config_hash = JSON.parse(config_body, {:symbolize_names => true})
+      rescue Exception => e
+        @logger.error("#{config_file} seems broken. Please check that ...")
+        @logger.error e
+        exit 1
+      end
+    end
+
+    # Find config file from HOME/.kneadn/config
+    # @return [String] path of config file
+    def search_config_file
+      default_config_path = ENV['HOME'] + '/.cloudnapi/config'
+      File.exists?(default_config_path) ? default_config_path : nil
+    end
+
+  end
+end
+
+# For Development and Debug
+if __FILE__ == $0
+  require 'pp'
+
+  client = CloudnAPI::Client.new
+  result = client.listVPCs
+  pp result.to_json
+end

data/lib/cloudn-api/version.rb

@@ -0,0 +1,3 @@
+module CloudnAPI
+  VERSION = "0.0.1"
+end

data/spec/CloudnAPI_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+# These RSpec tests expect the configuration file of Cloudn to be in '~/.cloudnapi/config'.
+
+describe CloudnAPI do
+  before do
+    @client = CloudnAPI::Client.new
+  end
+
+  it 'has a version number' do
+    expect(CloudnAPI::VERSION).not_to be nil
+  end
+
+  it 'has Cloudn configurations' do
+    expect(@client.api_key).to be
+    expect(@client.secret_key).to be
+    expect(@client.url).to be
+    expect(@client.api_list).to be
+  end
+
+  it 'can use Cloudn API' do
+    expect(@client.listUsers).to be
+    expect(@client.listUsers({ page: 1, pagesize: 1})).to be
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'cloudn-api'

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: cloudn-api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ''
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: Library for manipulate Cloudn API easily
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- CloudnAPI.gemspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/cloudn-api.rb
+- lib/cloudn-api/api.json
+- lib/cloudn-api/client.rb
+- lib/cloudn-api/version.rb
+- spec/CloudnAPI_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nttcom/cloudn-api
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Library for manipulate Cloudn API easily
+test_files:
+- spec/CloudnAPI_spec.rb
+- spec/spec_helper.rb