kitchen-centurylink 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1821d66ff0a94e3a052c27b42e0501b2aa6f9fb1
-  data.tar.gz: c8cd6ac814d6dbfebeedd441f4f84ab302eca857
+  metadata.gz: 3c1b7b56a75b965b7083266464c9e43b50af14a4
+  data.tar.gz: 18189c2362d18b70a272ede67ea17b8e055ce7c9
 SHA512:
-  metadata.gz: 7897a40d338de81821764484d0d6ee14e027465c8c0c2313a109d8ad8a249e93a99e91fb8702848e69e909376715bdc4924931bba7dbc746abcbbc58c91a13b7
-  data.tar.gz: 426af5620cd504d8736a357cb5d63293b0f8748a0b57fea417a1a95d6ccf0586d35320858ca19a163c8ce17e6653038a6199586bb6739cc066445e151284fbe8
+  metadata.gz: 3f414724337c3ca213f0d40a226bd26d4c845e4b44ab28cedf0ae1cda42917c5753b9598eae1e616a64735c5caff09189fab188c65e926be799ce4a8b2468246
+  data.tar.gz: 4c5fd3ece1a26cc05c3dab7c54f29503c0a1cd47cdb365372a5bba021988e989fad38ed2eb1cbc0460fae1116b8906be08e36ce15b821731fe7185f4a27fc16c

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 gemspec
-gem 'clc_ruby_api', :path=> "C:/Users/Main/intellij projects/clc-ruby-api"
+
 

data/README.md

@@ -4,59 +4,30 @@ A Test Kitchen Driver for Centurylink.
 
 ## <a name="requirements"></a> Requirements
 
-You will need a <a href="www.centurylinkcloud.com" >CenturyLink Cloud account</a>s
+You will need a [CenturyLink Cloud](http://centurylinkcloud.com) account
 
 ## <a name="installation"></a> Installation and Setup
 
-Please read the [Driver usage][driver_usage] page for more details.
-
-## <a name="config"></a> Configuration
-
-**TODO:** Write descriptions of all configuration options
-
-### <a name="config-require-chef-omnibus"></a> require\_chef\_omnibus
-
-Determines whether or not a Chef [Omnibus package][chef_omnibus_dl] will be
-installed. There are several different behaviors available:
-
-* `true` - the latest release will be installed. Subsequent converges
-  will skip re-installing if chef is present.
-* `latest` - the latest release will be installed. Subsequent converges
-  will always re-install even if chef is present.
-* `<VERSION_STRING>` (ex: `10.24.0`) - the desired version string will
-  be passed the the install.sh script. Subsequent converges will skip if
-  the installed version and the desired version match.
-* `false` or `nil` - no chef is installed.
-
-The default value is unset, or `nil`.
-
-## <a name="development"></a> Development
-
-* Source hosted at [GitHub][repo]
-* Report issues/questions/feature requests on [GitHub Issues][issues]
-
-Pull requests are very welcome! Make sure your patches are well tested.
-Ideally create a topic branch for every separate change you make. For
-example:
-
-1. Fork the repo
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-## <a name="authors"></a> Authors
-
-Created and maintained by [TODO: Write your name][author] (<TODO: Write your email>)
-
-## <a name="license"></a> License
-
-Apache 2.0 (see [LICENSE][license])
-
-
-[author]:           https://github.com/enter-github-user
-[issues]:           https://github.com/enter-github-user/kitchen-centurylink/issues
-[license]:          https://github.com/enter-github-user/kitchen-centurylink/blob/master/LICENSE
-[repo]:             https://github.com/enter-github-user/kitchen-centurylink
-[driver_usage]:     http://docs.kitchen-ci.org/drivers/usage
-[chef_omnibus_dl]:  http://www.getchef.com/chef/install/
+    gem install kitchen-centurylink
+
+Example .kitchen.yml file:
+```yaml
+---
+driver:
+  name: centurylink
+
+provisioner:
+  name: chef_solo
+
+platforms:
+  - name: ubuntu
+    driver_config:
+      accountAlias: ALIAS
+      groupId: 123456789
+      server_name: test
+      cpu:  1
+      memoryGB: 4
+      serverTemplate: UBUNTU-14-64-TEMPLATE
+      
+```
+See the [CenturyLink Cloud API documentation](http://www.centurylinkcloud.com/api-docs/v2/#servers-create-server) for more info on how to set these values. 

data/kitchen-centurylink.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'test-kitchen', '~> 1.3.1'
-  spec.add_dependency 'clc_ruby_api'
+  spec.add_dependency 'highline'
 
   spec.add_development_dependency 'clc_ruby_api'
   spec.add_development_dependency 'bundler', '~> 1.3'

data/lib/kitchen/driver/centurylink.rb

@@ -17,9 +17,9 @@
 # limitations under the License.
 
 require 'kitchen'
-require 'clc_ruby_api.rb'
-require "highline/import"
-require 'pp'
+require 'clc_client.rb'
+require 'highline/import'
+
 module Kitchen
 
   module Driver
@@ -38,31 +38,31 @@ module Kitchen
       default_config :type, 'standard'
       default_config :assign_public_ip, false
 
-      @@client = ClcRubyApi
+      @@client = ClcClient
 
       def create(state)
 
         if !config[:token] && !state[:token]
-          puts "No CLC API token was found. Please enter your credentials to have one generated."
+          puts 'No CLC API token was found. Please enter your credentials to have one generated.'
           generateToken(state)
         end
 
         if !config[:groupId]
-          puts "No groupId was set. Please set groupId in .kitchen.yml and try again"
-          puts "See --> http://www.centurylinkcloud.com/api-docs/v2/#servers-create-server#request"
-          raise "Incorrect config"
+          puts 'No groupId was set. Please set groupId in .kitchen.yml and try again'
+          puts 'See --> http://www.centurylinkcloud.com/api-docs/v2/#servers-create-server#request'
+          raise 'Incorrect config'
         end
 
         @@client.setToken(config[:token] || state[:token])
 
         queueId = create_server
-        serverInfo = @@client.getServerDetails(config[:alias], queueId + "?uuid=True")
+        serverInfo = @@client.getServerDetails(config[:alias], queueId + '?uuid=True')
 
-        info "Checking server status before continuing"
+        info 'Checking server status before continuing'
 
-        while serverInfo["status"] != "active" do
-          info "Server not up. Server status is: #{serverInfo["status"]}."
-          serverInfo = @@client.getServerDetails(config[:alias], queueId + "?uuid=True")
+        while serverInfo['status'] != 'active' do
+          info "Server not up. Server status is: #{serverInfo['status']}."
+          serverInfo = @@client.getServerDetails(config[:alias], queueId + '?uuid=True')
           sleep 20
         end
         info serverInfo
@@ -70,7 +70,7 @@ module Kitchen
         info "Created server with id #{state[:server_id]}"
 
         if config[:assign_public_ip]
-          info "Assigning public IP"
+          info 'Assigning public IP'
           assign_public_ip(state)
         else
           state[:hostname] = serverInfo['details']['ipAddresses'][0]['internal']
@@ -86,14 +86,14 @@ module Kitchen
         @@client.setToken(config[:token])
         response = @@client.deleteServer(config[:alias], state[:server_id])
         if response['isQueued'] == true
-          info "Delete request is queued up"
+          info 'Delete request is queued up'
           state.delete(:server_id)
           state.delete(:hostname)
         end
       end
 
       def create_server
-        info "Sending create server request"
+        info 'Sending create server request'
         response = @@client.createServer(config[:alias],
         {
             :name => config[:server_name],
@@ -116,16 +116,16 @@ module Kitchen
       end
       def assign_public_ip(state)
        response = @@client.addPublicIpAddress(config[:alias], state[:server_id], {
-             :ports => [ {:protocol => "TCP", :port => 80},
-                         {:protocol => "TCP", :port => 8080},
-                         {:protocol => "TCP", :port => 443},
-                         {:protocol => "TCP", :port => 22},
+             :ports => [ {:protocol => 'TCP', :port => 80},
+                         {:protocol => 'TCP', :port => 8080},
+                         {:protocol => 'TCP', :port => 443},
+                         {:protocol => 'TCP', :port => 22},
              ]})
         puts response
-       statusId = response["id"]
+       statusId = response['id']
        status = @@client.getQueueStatus(config[:alias], statusId)
 
-       while status["status"] != "succeeded" do
+       while status['status'] != 'succeeded' do
 
          info "Waiting for public IP job to complete. Status is #{status["status"]}"
          sleep 20
@@ -138,11 +138,11 @@ module Kitchen
 
       def generateToken(state)
           if !config[:clc_username]
-            username = ask "Username:"
+            username = ask 'Username:'
           end
-          password = ask ("Password:") { |q| q.echo = false }
+          password = ask ('Password:') { |q| q.echo = false }
           token = @@client.login username, password
-          info "Generated new token:"
+          info 'Generated new token:'
           info token
           info "Save this to your project's .kitchen.yml file to use for future logins"
 

data/lib/kitchen/driver/centurylink_version.rb

@@ -21,6 +21,6 @@ module Kitchen
   module Driver
 
     # Version string for Centurylink Kitchen driver
-    CENTURYLINK_VERSION = "0.1.0"
+    CENTURYLINK_VERSION = "0.1.2"
   end
 end

data/lib/kitchen/driver/clc_client.rb

@@ -0,0 +1,332 @@
+require "clc_client/version"
+require "rest-client"
+
+module ClcClient
+
+  createServerRequest = {
+    :name => "DFT",
+    :groupId => "a163d30b196f436aac885f2e28ad28b9",
+    :sourceServerId => "UBUNTU-14-64-TEMPLATE",
+    :cpu => 1,
+    :memoryGB => 2,
+    :type => "standard",
+  }
+
+  CLC_API = "https://api.ctl.io"
+    
+  def self.setToken(token)
+    $token = token
+  end
+
+  def self.login(username, password)
+    begin
+      response = RestClient.post("https://api.ctl.io/v2/authentication/login",
+                                 {:username => username,
+                                  :password => password
+                                  }.to_json,
+                                 :content_type => :json, :accept => :json
+                                 )
+    rescue => e
+      puts e.response
+    end
+    $token = JSON.parse(response)['bearerToken']
+  end
+
+  def self.getServerDetails(accountAlias, serverId)
+    begin
+      response = RestClient.get("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}", :authorization => "Bearer #{$token}")
+    rescue => e
+      puts e
+    end
+    JSON.parse(response)
+  end
+
+  def self.createServer(accountAlias, payload = {})
+    response = RestClient.post("https://api.ctl.io/v2/servers/#{accountAlias}",
+                               payload.to_json,
+                               :content_type => :json, :accept => :json,
+                               :authorization => "Bearer #{$token}"
+                               )
+    puts response
+    JSON.parse(response)
+    end
+
+    def self.deleteServer(accountAlias, serverId)
+      response = RestClient.delete("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}", :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getServerCredentials(accountAlias, serverId)
+      response = RestClient.get("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}/credentials", :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.setServerCpuOrMemory(accountAlias, serverId, payload = {})
+      response = RestClient.patch("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}",
+                                  payload.to_json,
+                                  :content_type => :json,
+                                  :accept => :json,
+                                  :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.setServerCredentials(accountAlias, serverId, payload = {})
+      response = RestClient.patch("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}",
+                                  payload.to_json,
+                                  :content_type => :json, :accept => :json,
+                                  :authorization => "Bearer #{$token}"
+                                  )
+      JSON.parse(response)
+    end
+
+    def self.setServerCustomsFields(accountAlias, serverId, payload = {})
+        response = RestClient.patch("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}",
+
+                                    payload.to_json,
+                                    :content_type => :json, :accept => :json,
+                                    :authorization => "Bearer #{$token}"
+                                    )
+        JSON.parse(response)
+    end
+
+    def self.setServerDescriptionOrGroup(accountAlias, serverId, payload = {})
+        response = RestClient.patch("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}",
+                                    payload.to_json,
+                                    :content_type => :json, :accept => :json,
+                                    :authorization => "Bearer #{$token}"
+                                    )
+        JSON.parse(response)
+    end
+
+    def self.setServerDisks(accountAlias, serverId, payload = {})
+        response = RestClient.patch("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}",
+                                    payload.to_json,
+                                    :content_type => :json, :accept => :json,
+                                    :authorization => "Bearer #{$token}"
+                                    )
+        JSON.parse(response)
+    end
+
+    def self.getQueueStatus(accountAlias, serverId)
+      response = RestClient.get("https://api.ctl.io/v2/operations/#{acctAlias}/status/#{statusId}",
+                                :authorization => "Bearer #{$token}"
+                                )
+    end
+
+    def self.addPublicIpAddress(accountAlias, serverId, payload = {})
+        response = RestClient.post("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}/publicIPAddresses",
+                                   payload.to_json,
+                                   :content_type => :json, :accept => :json,
+                                   :authorization => "Bearer #{$token}"
+                                   )
+        JSON.parse(response)
+    end
+
+    def self.getPublicIpAddress(accountAlias, serverId, publicIP)
+      response = RestClient.get("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}/publicIPAddresses/#{publicIP}", :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.deletePublicIpAddress(accountAlias, serverId, publicIP)
+      response = RestClient.get("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}/publicIPAddresses/#{publicIP}", :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.updatePublicIpAddress(accountAlias, serverId, publicIP, payload = {})
+      response = RestClient.post("https://api.ctl.io/v2/servers/#{accountAlias}/#{serverId}/publicIPAddresses",
+                                 payload.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}"
+                                 )
+      JSON.parse(response)
+    end
+
+    def self.archiveServer(accountAlias, serverIds = {})
+      response = RestClient.post("https://api.ctl.io/v2/operations/#{accountAlias}/servers/archive",
+                                 serversIds.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}"
+                                 )
+      JSON.parse(response)
+    end
+
+    def self.createSnapshot(accountAlias, payload = {})
+      response = RestClient.post("https://api.ctl.io/v2/operations/{accountAlias}/servers/createSnapshot",
+                                 payload.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}"
+                                 )
+    end
+
+    def self.executePackage(accountAlias, payload = {})
+      response = RestClient.post("https://api.ctl.io/v2/operations/#{accountAlias}/servers/executePackage",
+                                 payload.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}"
+                                 )
+      JSON.parse(response)
+    end
+
+    def self.restoreServer(accountAlias, targetGroupId)
+      response = RestClient.post("https://api.ctl.io/v2/servers/{accountAlias}/{serverId}/restore",
+                                 {:targetGroupId => targetGroupId}.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.setPowerOperation(accountAlias, powerOperation, serverIds = {})
+      response = RestClient.post("https://api.ctl.io/v2/operations/#{accountAlias}/servers/#{powerOperation}",
+                                 {:serverIds => serverIds}.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.setMaintenanceMode(accountAlias, servers = {})
+      response = RestClient.post("https://api.ctl.io/v2/operations/#{accountAlias}/servers/setMaintenance",
+                                 servers.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.archiveGroup(accountAlias, groupId, payload = {})
+      response = RestClient.post("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}/archive",
+                                 payload.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => authorization
+                                 )
+      JSON.parse(response)
+    end
+
+    def self.restoreGroup(accountAlias, groupId, targetGroupId)
+      response = RestClient.post("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}/restore",
+                                 {:targetGroupId => targetGroupId}.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}")
+    end
+
+    def self.createGroup(accountAlias, payload)
+      response = RestClient.post("https://api.ctl.io/v2/groups/#{accountAlias}",
+                                 payload.to_json,
+                                 :content_type => :json, :accept => :json,
+                                 :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.deleteGroup(accountAlias, groupId)
+      response = RestClient.delete("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}",
+                                   :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getGroup(accountAlias, groupId)
+      response = RestClient.get("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getGroupBillingDetails(accountAlias, groupId)
+      response = RestClient.get("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}/billing",
+                                :authorization => authorization)
+      JSON.parse(response)
+    end
+
+    def self.getGroupMonitorinfStatistics(accountAlias, groupId)
+      response = RestClient.get("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}/statistics?start=#{datetime}&sampleInterval=dd:hh:mm:ss",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.setCustomFields(accountAlias, groupId, patchOperation = {})
+      response = RestClient.get("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}",
+                                {:patchOperation => patchOperation}.to_json,
+                                :content_type => :json, :accept => :json,
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.setGroupNameOrDescription(accountAlias, groupId, patchOperation = {})
+      response = RestClient.patch("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}",
+                                  {:patchOperation => patchOperation}.to_json,
+                                  :content_type => :json, :accept => :json,
+                                  :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+
+    def self.setGroupParent(accountAlias, groupId, patchOperation = {})
+      response = RestClient.patch("https://api.ctl.io/v2/groups/#{accountAlias}/#{groupId}",
+                                  {:patchOperation => patchOperation}.to_json,
+                                  :content_type => :json, :accept => :json,
+                                  :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getCustomGroups(accountAlias)
+      response = RestClient.get("https://api.ctl.io/v2/accounts/#{accountAlias}/customFields",
+                                :authorization => "Bearer #{$token}"
+                                )
+      JSON.parse(response)
+    end
+
+    def self.getDataCenter(accountAlias, dataCenter)
+      response = RestClient.get("https://api.ctl.io/v2/datacenters/#{accountAlias}/#{dataCenter}?groupLinks=true|false",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getDataCentereploymentCapalities(accountAlias, datacenter)
+      response = RestClient.get("https://api.ctl.io/v2/datacenters/#{accountAlias}/#{dataCenter}/deploymentCapabilities",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getDataCenterList(accountAlias)
+      response = RestClient.get("https://api.ctl.io/v2/datacenters/#{accountAlias}",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getCustomFields(accountAlias)
+      response = RestClient.get("https://api.ctl.io/v2/accounts/#{accountAlias}/customFields",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.createAntiAffinityPolicy(accountAlias)
+      response = RestClient.get("https://api.ctl.io/v2/antiAffinityPolicies/#{accountAlias}",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.deleteAntiAffinityPolicy(accountAlias, policyId, payload = {})
+      response = RestClient.get("https://api.ctl.io/v2/antiAffinityPolicies/#{accountAlias}/#{policyId}",
+                                payload.to_json,
+                                :content_type => :json, :accept => :json,
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.updateAntiAffinityPolicy(accountAlias, policyId, name)
+      response = RestClient.get("https://api.ctl.io/v2/antiAffinityPolicies/#{accountAlias}/#{policyId}",
+                                {:name => name}.to_json,
+                                :content_type => :json, :accept => :json,
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getAntiAffinityPolicy(accountAlias, policyId)
+      response = RestClient.get("https://api.ctl.io/v2/antiAffinityPolicies/#{accountAlias}/#{policyId}",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+    def self.getAntiAffinityPolicies(accountAlias)
+      response = RestClient.get("https://api.ctl.io/v2/antiAffinityPolicies/#{accountAlias}",
+                                :authorization => "Bearer #{$token}")
+      JSON.parse(response)
+    end
+
+  end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-centurylink
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Anthony Howell
@@ -26,7 +26,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.3.1
 - !ruby/object:Gem::Dependency
-  name: clc_ruby_api
+  name: highline
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -143,6 +143,7 @@ files:
 - kitchen-centurylink.gemspec
 - lib/kitchen/driver/centurylink.rb
 - lib/kitchen/driver/centurylink_version.rb
+- lib/kitchen/driver/clc_client.rb
 homepage: ''
 licenses:
 - Apache 2.0