knife-scaleway 0.1.0

data/Rakefile

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+desc 'Run RuboCop on the lib directory'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.patterns = ['lib/**/*.rb']
+end
+
+desc 'Display LOC stats'
+task :loc do
+  puts "\n## LOC Stats"
+  sh 'countloc -r lib/chef/knife'
+end
+
+task default: :spec

data/knife-scaleway.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knife-scaleway/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'knife-scaleway'
+  gem.version       = Knife::Scaleway::VERSION
+  gem.authors       = ['Lukas Diener']
+  gem.email         = ['lukas.diener@hotmail.com']
+  gem.description   = "A plugin for chef's knife to manage instances of Scaleway servers"
+  gem.summary       = "A plugin for chef's knife to manage instances of Scaleway servers"
+  gem.homepage      = 'https://github.com/LukasSkywalker/knife-scaleway'
+  gem.license       = 'Apache 2.0'
+
+  gem.add_dependency 'chef', '>= 10.18'
+
+  gem.add_development_dependency 'rspec', '~> 3.1'
+  gem.add_development_dependency 'rubocop', '~> 0.27'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'knife-solo'
+  gem.add_development_dependency 'knife-zero'
+  gem.add_development_dependency 'webmock', '~> 1.20'
+  gem.add_development_dependency 'vcr', '~> 2.9'
+  gem.add_development_dependency 'guard', '~> 2.8'
+  gem.add_development_dependency 'guard-rspec', '~> 4.3'
+  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'countloc'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'simplecov-console'
+
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+end

data/lib/chef/knife/scaleway.rb

@@ -0,0 +1,110 @@
+require 'rest-client'
+require 'json'
+
+module Scaleway
+  class Client
+    attr_accessor :access_key, :token
+
+    def initialize(access_key, token)
+      @host1 = 'https://api.scaleway.com'
+      @host2 = 'https://account.scaleway.com'
+      @access_key = access_key
+      @token = token
+      @instance = self
+    end
+
+    def self.instance
+      #raise StandardError, 'Create client before accessing methods' if @instance.nil?
+      #@instance
+      Scaleway::Client.new(Chef::Config[:knife][:scaleway_access_key], Chef::Config[:knife][:scaleway_token])
+    end
+
+    def request(path, method, payload = nil)
+      host = @host1 if path.index('/servers') || path.index('/images') || path.index('/volumes') || path.index('/ips')
+      host = @host2 if path.index('/organizations')
+      raise StandardError, "Add /#{path.split('/')[1]} to host map" if host.nil?
+
+      headers = {:'X-Auth-Token' => @token, :'Content-Type' => 'application/json'}
+      url = host + path
+
+      options = { url: url, method: method, verify_ssl: false, headers: headers }
+      if method == :post
+        options.merge!(payload: payload)
+        puts payload if ENV['DEBUG']
+      end
+
+      begin
+        puts "### Req #{method.upcase} #{host + path}" if ENV['DEBUG']
+        JSON.parse(RestClient::Request.execute(options).body, object_class: OpenStruct, array_class: Array)
+      rescue => e
+        data = JSON.parse(e.response, object_class: OpenStruct)
+        puts "#{data.type}: #{data.message}"
+      end
+    end
+
+    def get(path)
+      request(path, :get)
+    end
+
+    def post(path, data)
+      request(path, :post, data)
+    end
+
+    def put(path, data)
+      request(path, :put, data)
+    end
+  end
+
+  class Organization
+    def self.all
+      Client.instance.get('/organizations')
+    end
+  end
+
+  class Ip
+    def self.all
+      Client.instance.get('/ips').ips
+    end
+  end
+
+  class Image
+    def self.all
+      Client.instance.get('/images').images
+    end
+
+    def self.find(query)
+      response = Client.instance.get('/images')
+      response.images.select do |image|
+        image.name.downcase.index(query.downcase)
+      end
+    end
+  end
+
+  class Server
+    def self.all
+      Client.instance.get('/servers').servers
+    end
+
+    def self.find(id)
+      Client.instance.get("/servers/#{id}").server
+    end
+
+    def self.create(name, image, commercial_type)
+      Client.instance.post('/servers', { name: name, organization: Client.instance.access_key, image: image, commercial_type: commercial_type}.to_json).server
+    end
+
+    def self.actions(id)
+      Client.instance.get("/servers/#{id}/action")
+    end
+
+    def self.action(id, act)
+      Client.instance.post("/servers/#{id}/action", { action: act }.to_json)
+    end
+  end
+
+  class Volume
+    def self.all
+      Client.instance.get('/volumes').volumes
+    end
+  end
+end

data/lib/chef/knife/scaleway_account_info.rb

@@ -0,0 +1,45 @@
+# 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 'chef/knife/scaleway_base'
+
+class Chef
+  class Knife
+    class ScalewayAccountInfo < Knife
+      include Knife::ScalewayBase
+
+      banner 'knife scaleway account info (options)'
+
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        account_info = [
+          ui.color('UUID',           :bold),
+          ui.color('Email',          :bold),
+          ui.color('Droplet Limit',  :bold),
+          ui.color('Email Verified', :bold)
+        ]
+
+        account = client.account.info
+
+        account_info << account.uuid.to_s
+        account_info << account.email.to_s
+        account_info << account.server_limit.to_s
+        account_info << account.email_verified.to_s
+
+        puts ui.list(account_info, :uneven_columns_across, 4)
+      end
+    end
+  end
+end

data/lib/chef/knife/scaleway_base.rb

@@ -0,0 +1,89 @@
+# lots of awesome stoff stolen from opscode/knife-azure ;-)
+#
+# 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.
+#
+class Chef
+  class Knife
+    module ScalewayBase
+      def self.load_deps
+        require_relative 'scaleway'
+        require 'json'
+        require 'chef/mixin/shell_out'
+      end
+
+      def self.included(includer)
+        includer.class_eval do
+          category 'scaleway'
+
+          # Lazy load our dependencies. Later calls to `Knife#deps` override
+          # previous ones, so if the including class calls it, it needs to also
+          # call our #load_deps, i.e:
+          #
+          #   Include Chef::Knife::ScalewayBase
+          #
+          #   deps do
+          #     require 'foo'
+          #     require 'bar'
+          #     Chef::Knife::ScalewayBase.load_deps
+          #   end
+          #
+          deps { Chef::Knife::ScalewayBase.load_deps }
+
+          option :scaleway_access_token,
+                 short: '-A ACCESS_TOKEN',
+                 long: '--scaleway_access_token ACCESS_TOKEN',
+                 description: 'Your Scaleway ACCESS_TOKEN',
+                 proc: proc { |access_token| Chef::Config[:knife][:scaleway_access_token] = access_token }
+        end
+      end
+
+      def client
+        Scaleway::Client.new(Chef::Config[:knife][:scaleway_access_key], Chef::Config[:knife][:scaleway_token])
+      end
+
+      def validate!(keys = [:scaleway_access_key, :scaleway_token])
+        errors = []
+
+        keys.each do |k|
+          if locate_config_value(k).nil?
+            errors << "You did not provide a valid '#{k}' value. " \
+                      "Please set knife[:#{k}] in your knife.rb or pass as an option."
+          end
+        end
+
+        exit 1 if errors.each { |e| ui.error(e) }.any?
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        config[key] || Chef::Config[:knife][key]
+      end
+
+      def wait_for_status(result, status: 'in-progress', sleep: 3)
+        print "Waiting for state #{status}"
+        result = Scaleway::Server.find(locate_config_value(:id))
+        while result.state != status
+          sleep sleep
+          print('.')
+
+          #if status == 'starting' || status == 'stopping'
+            #break if client.servers.find(id: locate_config_value(:id)).status != 'in-progress'
+          #else
+            break if Scaleway::Server.find(locate_config_value(:id)).state == status
+          #end
+        end
+        ui.info 'OK'
+      end
+    end
+  end
+end

data/lib/chef/knife/scaleway_droplet_create.rb

@@ -0,0 +1,338 @@
+# 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 'chef/knife/scaleway_base'
+
+class Chef
+  class Knife
+    class ScalewayServerCreate < Knife
+      include Knife::ScalewayBase
+
+      deps do
+        require 'socket'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+        Chef::Knife::ScalewayBase.load_deps
+        # Knife loads subcommands automatically, so we can just check if the
+        # class exists.
+        Chef::Knife::SoloBootstrap.load_deps if defined? Chef::Knife::SoloBootstrap
+        if defined? Chef::Knife::ZeroBootstrap
+          Chef::Knife::ZeroBootstrap.load_deps
+          self.options = Chef::Knife::ZeroBootstrap.options.merge(options)
+        end
+      end
+
+      banner 'knife scaleway server create (options)'
+
+      option :server_name,
+             short: '-N NAME',
+             long: '--server-name NAME',
+             description: 'The server name',
+             proc: proc { |server_name| Chef::Config[:knife][:server_name] = server_name }
+
+      option :image,
+             short: '-I IMAGE',
+             long: '--image IMAGE',
+             description: 'Your Scaleway Image',
+             proc: proc { |image| Chef::Config[:knife][:image] = image }
+
+      option :size,
+             short: '-S SIZE',
+             long: '--size SIZE',
+             description: 'Your Scaleway Size',
+             proc: proc { |size| Chef::Config[:knife][:size] = size }
+
+      option :location,
+             short: '-L REGION',
+             long: '--location REGION',
+             description: 'Scaleway Location (Region)',
+             proc: proc { |location| Chef::Config[:knife][:location] = location }
+
+      option :ssh_key_ids,
+             short: '-K KEYID',
+             long: '--ssh-keys KEY_ID',
+             description: 'Comma spearated list of your SSH key ids',
+             proc: ->(o) { o.split(/[\s,]+/) }
+
+      option :identity_file,
+             short: '-i IDENTITY_FILE',
+             long: '--identity-file IDENTITY_FILE',
+             description: 'The SSH identity file used for authentication',
+             proc: proc { |identity| Chef::Config[:knife][:identity_file] = identity }
+
+      option :bootstrap,
+             short: '-B',
+             long: '--bootstrap',
+             description: 'Do a chef-client bootstrap on the created server (for use with chef-server)'
+
+      option :solo,
+             long: '--[no-]solo',
+             description: 'Do a chef-solo bootstrap on the server using knife-solo',
+             proc: proc { |s| Chef::Config[:knife][:solo] = s }
+
+      option :zero,
+             long: '--[no-]zero',
+             description: 'Do a chef-zero bootstrap on the server using knife-zero',
+             proc: proc { |z| Chef::Config[:knife][:zero] = z }
+
+      option :ssh_user,
+             short: '-x USERNAME',
+             long: '--ssh-user USERNAME',
+             description: 'The ssh username; default is "root"',
+             default: 'root'
+
+      option :distro,
+             short: '-d DISTRO',
+             long: '--distro DISTRO',
+             description: 'Chef-Bootstrap a distro using a template; default is "chef-full"',
+             proc: proc { |d| Chef::Config[:knife][:distro] = d },
+             default: 'chef-full'
+
+      option :run_list,
+             short: '-r RUN_LIST',
+             long: '--run-list RUN_LIST',
+             description: 'Comma separated list of roles/recipes to apply',
+             proc: ->(o) { o.split(/[\s,]+/) },
+             default: []
+
+      option :template_file,
+             long: '--template-file TEMPLATE',
+             description: 'Full path to location of template to use',
+             proc: proc { |t| Chef::Config[:knife][:template_file] = t },
+             default: false
+
+      option :host_key_verify,
+             long: '--[no-]host-key-verify',
+             description: 'Verify host key, enabled by default',
+             default: true
+
+      option :prerelease,
+             long: '--prerelease',
+             description: 'Install the pre-release chef gems'
+
+      option :bootstrap_version,
+             long: '--bootstrap-version VERSION',
+             description: 'The version of Chef to install',
+             proc: proc { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+      option :environment,
+             short: '-E ENVIRONMENT',
+             long: '--environment ENVIRONMENT',
+             description: 'The name of the chef environment to use',
+             proc: proc { |e| Chef::Config[:knife][:environment] = e },
+             default: '_default'
+
+      option :json_attributes,
+             short: '-j JSON',
+             long: '--json-attributes JSON',
+             description: 'A JSON string to be added to the first run of chef-client',
+             proc: ->(o) { JSON.parse(o) }
+
+      option :private_networking,
+             long: '--private_networking',
+             description: 'Enables private networking if the selected region supports it',
+             default: false
+
+      option :secret_file,
+             long: '--secret-file SECRET_FILE',
+             description: 'A file containing the secret key to use to encrypt data bag item values',
+             proc: proc { |sf| Chef::Config[:knife][:secret_file] = sf }
+
+      option :ssh_port,
+             short: '-p PORT',
+             long: '--ssh-port PORT',
+             description: 'The ssh port',
+             default: '22',
+             proc: proc { |port| Chef::Config[:knife][:ssh_port] = port }
+
+      option :backups,
+             short: '-b',
+             long: '--backups-enabled',
+             description: 'Enables backups for the created server',
+             default: false
+
+      option :ipv6,
+             short: '-6',
+             long: '--ipv6-enabled',
+             description: 'Enables ipv6 for the created server',
+             default: false
+
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        unless locate_config_value(:server_name)
+          ui.error('Server Name cannot be empty: -N <servername>')
+          exit 1
+        end
+
+        unless locate_config_value(:image)
+          ui.error('Image cannot be empty: -I <image>')
+          exit 1
+        end
+=begin
+        unless locate_config_value(:size)
+          ui.error('Size cannot be empty: -S <size>')
+          exit 1
+        end
+
+        unless locate_config_value(:location)
+          ui.error('Location cannot be empty: -L <region>')
+          exit 1
+        end
+
+        unless locate_config_value(:ssh_key_ids)
+          ui.error('One or more Scaleway SSH key ids missing: -K <KEY1>, <KEY2> ...')
+          exit 1
+        end
+=end
+        if solo_bootstrap? && !defined?(Chef::Knife::SoloBootstrap)
+          ui.error [
+            'Knife plugin knife-solo was not found.',
+            'Please add the knife-solo gem to your Gemfile or',
+            'install it manually with `gem install knife-solo`.'
+          ].join(' ')
+          exit 1
+        end
+
+        if zero_bootstrap? && !defined?(Chef::Knife::ZeroBootstrap)
+          ui.error [
+            'Knife plugin knife-zero was not found.',
+            'Please add the knife-zero gem to your Gemfile or',
+            'install it manually with `gem install knife-zero`.'
+          ].join(' ')
+          exit 1
+        end
+=begin
+        server = DropletKit::Droplet.new(name: locate_config_value(:server_name),
+                                          size: locate_config_value(:size),
+                                          image: locate_config_value(:image),
+                                          region: locate_config_value(:location),
+                                          ssh_keys: locate_config_value(:ssh_key_ids),
+                                          private_networking: locate_config_value(:private_networking),
+                                          backups: locate_config_value(:backups),
+                                          ipv6: locate_config_value(:ipv6)
+                                         )
+=end
+        server = Scaleway::Server.create(locate_config_value(:server_name), locate_config_value(:image), 'VC1S')
+
+        #server = client.servers.create(server)
+
+        if Scaleway::Server.find(server.id).state != 'stopped'
+          ui.error("Droplet could not be started #{server.inspect}")
+          exit 1
+        end
+
+        puts "Droplet creation for #{locate_config_value(:server_name)} started. Droplet-ID is #{server.id}"
+
+        unless !config.key?(:json_attributes) || config[:json_attributes].empty?
+          puts ui.color("JSON Attributes: #{config[:json_attributes]}", :magenta)
+        end
+
+        puts "Starting server #{server.id}"
+
+        Scaleway::Server.action(server.id, 'poweron')
+
+        print ui.color('Waiting for IPv4-Address', :magenta)
+        print('.') until ip_address = ip_address_available(server.id) do
+          puts 'done'
+        end
+
+        puts ui.color("IPv4 address is: #{ip_address.address}", :green)
+
+        print ui.color('Waiting for sshd:', :magenta)
+        print('.') until tcp_test_ssh(ip_address.address) do
+          sleep 2
+          puts 'done'
+        end
+
+        if locate_config_value(:bootstrap) || solo_bootstrap? || zero_bootstrap?
+          bootstrap_for_node(ip_address.address).run
+        else
+          puts ip_address.address
+          exit 0
+        end
+      end
+
+      def ip_address_available(server_id)
+        server = Scaleway::Server.find(server_id)
+        if server.public_ip
+          yield
+          server.public_ip
+        else
+          sleep @initial_sleep_delay ||= 10
+          false
+        end
+      end
+
+      def tcp_test_ssh(hostname)
+        port = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+        tcp_socket = TCPSocket.new(hostname, port)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
+          yield
+          true
+        else
+          false
+        end
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        sleep 2
+        false
+      rescue Errno::EHOSTUNREACH
+        sleep 2
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+
+      def bootstrap_for_node(ip_address)
+        bootstrap = bootstrap_class.new
+        bootstrap.name_args = [ip_address]
+        bootstrap.config.merge! config
+        bootstrap.config[:chef_node_name] = locate_config_value(:server_name)
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        bootstrap.config[:environment] = locate_config_value(:environment)
+        bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes) || {}
+        bootstrap.config[:secret_file] = locate_config_value(:secret_file) || {}
+        bootstrap
+      end
+
+      def bootstrap_class
+        if solo_bootstrap?
+          Chef::Knife::SoloBootstrap
+        elsif zero_bootstrap?
+          Chef::Knife::ZeroBootstrap
+        else
+          Chef::Knife::Bootstrap
+        end
+      end
+
+      def solo_bootstrap?
+        config[:solo] || (config[:solo].nil? && Chef::Config[:knife][:solo])
+      end
+
+      def zero_bootstrap?
+        config[:zero] || (config[:zero].nil? && Chef::Config[:knife][:zero])
+      end
+    end
+  end
+end