kitchen-softlayer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4968babda5beee11922c354ef309c24370736ca
+  data.tar.gz: 501dab415d0b3b622b9ec4ddeba644794c8b24af
+SHA512:
+  metadata.gz: bfeb3f59a937cde441bc39c5760aee572b120fb7845ed4e521308230d7a599dac822808b9c0d9da6a1b8a65fc41ee35fc80dbd62ecfd9ba5dc093be728600bb2
+  data.tar.gz: 4c2394ecfb7a1cf5bc2456378274fbb6c85bedb411118e16b6dd1b99c31db81bd98805771e14ff645a481d58c99fe6993f4ff4de8a9d0ece293d385760c24b2a

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# ?.?.? / ????-??-??
+
+# 0.1.0 / 2015-09-10
+
+* Initial release
+
+### Bug Fixes
+
+* PR [#99][] - ??????????
+
+### New Features
+
+[#99]: https://github.com/neillturner/kitchen-softlayer/pull/99

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Author:: Neill Turner (<neillwturner.com>)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,137 @@
+[![Gem Version](https://badge.fury.io/rb/kitchen-softlayer.svg)](http://badge.fury.io/rb/kitchen-softlayer)
+[![Gem Downloads](http://ruby-gem-downloads-badge.herokuapp.com/kitchen-softlayer?type=total&color=brightgreen)](https://rubygems.org/gems/kitchen-softlayer)
+[![Build Status](https://travis-ci.org/neillturner/kitchen-softlayer.png)](https://travis-ci.org/neillturner/kitchen-softlayer)
+
+# Kitchen::Softlayer
+
+A Test Kitchen Driver for Softlayer
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kitchen-softlayer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kitchen-softlayer
+
+## Usage
+
+By default set the following environment variables to your softlayer credentials:
+
+```
+      softlayer_username
+      softlayer_api_key
+      softlayer_default_datacenter    (optional)
+      softlayer_default_domain        (optional)
+```
+
+So you don't need to code these in the .kitchen.yml file which is much better from a security point
+of view as the kitchen.yml file can be checked in to source control without containing key data.
+
+
+An example of the driver options in your `.kitchen.yml` file:
+
+```yaml
+    driver:
+      name: softlayer
+        key_name: 'myuploadedsshkeylabel'
+        ssh_key: C:/mykeys/my_private_sshkey.pem
+        username: root
+        server_name: 'myserver-test'
+        hostname: 'MyProject-test01'
+        flavor_id: m1.tiny
+     #  image_id: '3b235124-a190-40b5-9720-c020e61b99e1'
+        os_code: 'CENTOS_7_64'
+        domain: softlayer.com
+        private_network_only: true
+        cpu: 1,
+        ram: 1024,
+        datacenter: lon02
+```
+
+### os_code and image_id
+you need to either specify softlayer's operating System Reference Code via parameter os_code
+or an image_id.
+
+### private_network_only
+By default this parameter is set to false so no public network with be created.
+For test-kitchen to access the server via ssh it needs to be on the softlayer private VPN. See:
+
+[Using SSL VPN](http://knowledgelayer.softlayer.com/procedure/using-ssl-vpn)
+
+### ssh_key
+ Currently the driver only supports using SSH keys to access servers. This requires that you upload an SSH Key in Softlayer see:
+
+[SSH Keys](http://knowledgelayer.softlayer.com/procedure/ssh-keys-0)
+
+ in the kitchen.yml file specify the label of the ssh key as the parameter key_name
+ and specify the private key for the uploaded public key as parameter ssh_key.
+
+The `image_ref` and `flavor_ref` options can be specified as an exact id,
+an exact name, or as a regular expression matching the name of the image or flavor.
+
+### hostname
+
+the driver checks for a server with the hostname and will use that server instead of creating another one.
+
+### disable_ssl_validation
+
+the driver uses the fog-softlayer ruby client to communicate with softlayer.
+If you get SSL certificate validation errors then the workaround is to set disable SSL cert validation to true
+however it is better to set the environment variable 'SSL_CERT_FILE' to a valid certificate file.
+
+# Softlayer Driver Options
+
+key | default value | Notes
+----|---------------|--------
+softlayer_username | ENV['softlayer_username']
+softlayer_api_key | ENV['softlayer_api_key']
+softlayer_default_datacenter | ENV['softlayer_default_datacenter']
+softlayer_default_domain | ENV['softlayer_default_domain']
+server_name | nil | Server Name
+key_name | nil | the label of the uploaded key
+ssh_key| nil | file location of private key
+disable_ssl_validation | false | ssl validation for fg softlayer api
+username | 'root' | server's administration user
+password | nil | server's administration password
+port | '22' | ssh port of servef
+hostname| nil | hostname of server
+domain | ENV['softlayer_default_domain'] | domain nane of server
+fqdn | nil | fully qualified domain name
+cpu | nil | no of cpus
+ram | nil | memory size
+disk | nil | disk size
+flavor_id | nil | type of server i.e. m1.tiny
+bare_metal | false | server to be created on bare metal (takes longer)
+os_code | nil | softlayer's operating System Reference Code
+image_id | nil | image id for server
+ephemeral_storage | nil | storage
+network_components | nil | network
+ssh_timeout | 300 | timeout to ssh when server starting
+account_id | nil | softlayer account id
+datacenter | ENV['softlayer_default_datacenter'] | datacenter code
+single_tenant | false | don't share server
+global_identifier | nil | softlayer global id
+hourly_billing_flag | true
+tags | [] | tags for the server
+private_network_only | true | if only a private network
+user_data | nil | user data for server
+uid | nil | softlayer global id
+vlan | nil | numeric id of private_vlan for server
+private_vlan | nil | numeric id of private_vlan for server
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run style checks and RSpec tests (`bundle exec rake`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/kitchen-softlayer.gemspec

@@ -0,0 +1,24 @@
+# Encoding: UTF-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kitchen/driver/softlayer_version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kitchen-softlayer'
+  spec.version       = Kitchen::Driver::SOFTLAYER_VERSION
+  spec.authors       = ['Neill Turner']
+  spec.email         = ['neillwturner@gmail.com']
+  spec.description   = 'A Test Kitchen Softlayer driver'
+  spec.summary       = 'Test Kitchen Softlayer driver'
+  spec.homepage      = 'https://github.com/test-kitchen/kitchen-softlayer'
+  spec.license       = 'Apache'
+  candidates = Dir.glob('{lib}/**/*') + ['README.md', 'LICENSE.txt']
+  candidates += ['CHANGELOG.md', 'kitchen-softlayer.gemspec']
+  spec.files = candidates.sort
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.add_dependency 'test-kitchen', '~> 1.4'
+  spec.add_dependency 'fog', '~> 1.18'
+  spec.add_dependency 'fog-softlayer', '~> 0.4'
+end

data/lib/kitchen/driver/softlayer.rb

@@ -0,0 +1,333 @@
+# Encoding: utf-8
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'fog'
+require 'kitchen'
+require 'socket'
+require 'fog/softlayer'
+
+module Kitchen
+  module Driver
+    # Softlayer driver for Kitchen.
+    # rubocop:disable Metrics/LineLength
+    class Softlayer < Kitchen::Driver::SSHBase
+      default_config :server_name, nil
+      default_config :key_name, nil
+      required_config :key_name
+      default_config :ssh_key do
+        %w(id_rsa id_dsa).map do |k|
+          f = File.expand_path("~/.ssh/#{k}")
+          f if File.exist?(f)
+        end.compact.first
+      end
+
+      required_config :ssh_key
+      default_config :disable_ssl_validation, false
+      default_config :username, 'root'
+      default_config :password, nil
+      default_config :port, '22'
+      default_config :hostname, nil
+      default_config :domain, ENV['softlayer_default_domain']
+      default_config :fqdn, nil
+      default_config :cpu, nil
+      default_config :ram, nil
+      default_config :disk, nil
+      default_config :flavor_id, nil
+      default_config :bare_metal, false
+      default_config :os_code, nil
+      default_config :image_id, nil
+      default_config :ephemeral_storage, nil
+      # keypair found from keyname
+      # default_config :key_pairs, nil
+      default_config :network_components, nil
+      default_config :softlayer_username, ENV['softlayer_username']
+      default_config :softlayer_api_key, ENV['softlayer_api_key']
+      default_config :softlayer_default_datacenter, ENV['softlayer_default_datacenter']
+      default_config :softlayer_default_domain, ENV['softlayer_default_domain']
+      default_config :ssh_timeout, 300
+      default_config :account_id, nil
+      default_config :datacenter, ENV['softlayer_default_datacenter']
+      default_config :single_tenant, false
+      default_config :global_identifier, nil
+      default_config :hourly_billing_flag, true
+      default_config :tags, nil
+      default_config :private_network_only, true
+      default_config :user_data, nil
+      default_config :uid, nil
+      default_config :tags, []
+      default_config :vlan, nil
+      default_config :private_vlan, nil
+
+      def create(state)
+        config[:server_name] = default_name unless config[:server_name]
+        config[:disable_ssl_validation] && disable_ssl_validation
+        server = find_server(config[:hostname])
+        server = create_server unless server
+        state[:server_id] = server.id
+        info "Softlayer instance <#{state[:server_id]}> created."
+        server.wait_for do
+          print '.'
+          ready?
+        end
+        info "\n(server ready)"
+        tag_server(server)
+        state[:hostname] = get_ip(server)
+        setup_ssh(server, state)
+        wait_for_ssh_key_access(state)
+      rescue Fog::Errors::Error, Excon::Errors::Error => ex
+        raise ActionFailed, ex.message
+      end
+
+      def destroy(state)
+        return if state[:server_id].nil?
+
+        config[:disable_ssl_validation] && disable_ssl_validation
+        server = compute.servers.get(state[:server_id])
+        server.destroy unless server.nil?
+        info "Softlayer instance <#{state[:server_id]}> destroyed."
+        state.delete(:server_id)
+        state.delete(:hostname)
+      end
+
+      private
+
+      def wait_for_ssh_key_access(state)
+        new_state = build_ssh_args(state)
+        new_state[2][:number_of_password_prompts] = 0
+        info 'Checking ssh key authentication'
+
+        (config[:ssh_timeout].to_i).times do
+          ssh = Fog::SSH.new(*new_state)
+          begin
+            ssh.run([%(uname -a)])
+          rescue => e
+            info "Server not yet accepting SSH key: #{e.message}"
+            sleep 1
+          else
+            info 'SSH key authetication successful'
+            return
+          end
+        end
+        fail "#{config[:ssh_timeout]} seconds went by and we couldn't connect, somethings broken"
+      end
+
+      def compute
+        @compute_connection ||= Fog::Compute.new(
+          provider: :softlayer,
+          softlayer_username: config[:softlayer_username],
+          softlayer_api_key: config[:softlayer_api_key],
+          softlayer_default_datacenter: config[:softlayer_datacenter],
+          softlayer_default_domain: config[:softlayer_domain]
+        )
+      end
+
+      def network
+        @network_connection ||= Fog::Network.new(
+          provider: :softlayer,
+          softlayer_username: config[:softlayer_username],
+          softlayer_api_key: config[:softlayer_api_key]
+        )
+      end
+
+      def find_server(hostname)
+        s = nil
+        servers = compute.servers.all
+        servers.each do |server|
+          if server.name == hostname
+            s = server
+            info "Server with hostname #{hostname} already created"
+          end
+        end
+        s
+      end
+
+      def create_server
+        server_def = init_configuration
+        #   TODO: figure out network options
+        #    if config[:network_ref]
+        #      networks = [].concat([config[:network_ref]])
+        #      server_def[:nics] = networks.flatten.map do |net|
+        #        { 'net_id' => find_network(net).id }
+        #      end
+        #    end
+        [
+          :username,
+          :password,
+          :port,
+          :domain,
+          :fqdn,
+          :cpu,
+          :ram,
+          :disk,
+          :flavor_id,
+          :bare_metal,
+          :os_code,
+          :image_id,
+          :ephemeral_storage,
+          :network_components,
+          :account_id,
+          :single_tenant,
+          :global_identifier,
+          :tags,
+          :user_data,
+          :uid,
+          :vlan,
+          :private_vlan
+        ].each do |c|
+          server_def[c] = optional_config(c) if config[c]
+        end
+        debug "server_def: #{server_def}"
+        compute.servers.create(server_def)
+      end
+
+      def init_configuration
+        {
+          name: config[:server_name],
+          key_pairs: [compute.key_pairs.by_label(config[:key_name])],
+          hostname: config[:hostname],
+          datacenter: config[:datacenter],
+          hourly_billing_flag: config[:hourly_billing_flag],
+          private_network_only: config[:private_network_only]
+        }
+      end
+
+      def optional_config(c)
+        case c
+        when :user_data
+          File.open(config[c]).read if File.exist?(config[c])
+        else
+          config[c]
+        end
+      end
+
+      # Generate what should be a unique server name up to 63 total chars
+      # Base name:    15
+      # Username:     15
+      # Hostname:     23
+      # Random string: 7
+      # Separators:    3
+      # ================
+      # Total:        63
+      def default_name
+        [
+          instance.name.gsub(/\W/, '')[0..14],
+          (Etc.getlogin || 'nologin').gsub(/\W/, '')[0..14],
+          Socket.gethostname.gsub(/\W/, '')[0..22],
+          Array.new(7) { rand(36).to_s(36) }.join
+        ].join('-')
+      end
+
+      # TODO: code has support for multiple ips but not used.
+
+      def get_public_private_ips(server)
+        pub = server.public_ip
+        priv = server.private_ip
+        [pub, priv]
+      end
+
+      def get_ip(server)
+        pub, priv = get_public_private_ips(server)
+        pub, priv = parse_ips(pub, priv)
+        pub[config[:public_ip_order].to_i] ||
+          priv[config[:private_ip_order].to_i] ||
+          fail(ActionFailed, 'Could not find an IP')
+        if config[:private_network_only]
+          return priv[0]
+        else
+          return pub[0]
+        end
+      end
+
+      def parse_ips(pub, priv)
+        pub = Array(pub)
+        priv = Array(priv)
+        if config[:use_ipv6]
+          [pub, priv].each { |n| n.select! { |i| IPAddr.new(i).ipv6? } }
+        else
+          [pub, priv].each { |n| n.select! { |i| IPAddr.new(i).ipv4? } }
+        end
+        [pub, priv]
+      end
+
+      def setup_ssh(server, state)
+        tcp_check(state)
+        info "Using Softlayer keypair <#{config[:key_name]}>"
+        info "Using private SSH key <#{config[:ssh_key]}>"
+        state[:ssh_key] = config[:ssh_key]
+        # we don't call this as key_name must be set.
+        do_ssh_setup(state, config, server) unless config[:key_name]
+      end
+
+      def tcp_check(state)
+        # allow driver config to bypass SSH tcp check -- because
+        # it doesn't respect ssh_config values that might be required
+        if config[:no_ssh_tcp_check]
+          sleep(config[:no_ssh_tcp_check_sleep])
+        else
+          debug("wait_for_sshd hostname: #{state[:hostname]},username: #{config[:username]},port: #{config[:port]}")
+          wait_for_sshd(state[:hostname],
+                        config[:username],
+                        port: config[:port])
+        end
+        info '(ssh ready)'
+      end
+
+      def disable_ssl_validation
+        require 'excon'
+        Excon.defaults[:ssl_verify_peer] = false
+      end
+
+      def tag_server(server)
+        server.add_tags(config[:tags])
+      end
+
+      #   TODO: add these checks
+      #    def find_image(image_ref)
+      #      image = find_matching(compute.images, image_ref)
+      #      fail(ActionFailed, 'Image not found') unless image
+      #      debug "Selected image: #{image.id} #{image.name}"
+      #      image
+      #    end
+
+      #    def find_flavor(flavor_ref)
+      #      flavor = find_matching(compute.flavors, flavor_ref)
+      #      fail(ActionFailed, 'Flavor not found') unless flavor
+      #      debug "Selected flavor: #{flavor.id} #{flavor.name}"
+      #      flavor
+      #    end
+
+      #    def find_network(network_ref)
+      #      net = find_matching(network.networks.all, network_ref)
+      #      fail(ActionFailed, 'Network not found') unless net
+      #      debug "Selected net: #{net.id} #{net.name}"
+      #      net
+      #    end
+
+      #    def find_matching(collection, name)
+      #      name = name.to_s
+      #      if name.start_with?('/') && name.end_with?('/')
+      #        regex = Regexp.new(name[1...-1])
+      #      # check for regex name match
+      #        collection.each { |single| return single if regex =~ single.name }
+      #      else
+      #      # check for exact id match
+      #        collection.each { |single| return single if single.id == name }
+      #      # check for exact name match
+      #        collection.each { |single| return single if single.name == name }
+      #      end
+      #      nil
+      #    end
+    end
+  end
+end

data/lib/kitchen/driver/softlayer_version.rb

@@ -0,0 +1,20 @@
+# Encoding: UTF-8
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Kitchen
+  # Version string for Softlayer Kitchen driver
+  module Driver
+    SOFTLAYER_VERSION = '0.0.1'
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: kitchen-softlayer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Neill Turner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-kitchen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+- !ruby/object:Gem::Dependency
+  name: fog-softlayer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: A Test Kitchen Softlayer driver
+email:
+- neillwturner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- kitchen-softlayer.gemspec
+- lib/kitchen/driver/softlayer.rb
+- lib/kitchen/driver/softlayer_version.rb
+homepage: https://github.com/test-kitchen/kitchen-softlayer
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+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: Test Kitchen Softlayer driver
+test_files: []