knife-oneandone 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/knife-oneandone.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knife-oneandone/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'knife-oneandone'
+  spec.version       = Knife::Oneandone::VERSION
+  spec.authors       = ['Nurfet Becirevic']
+  spec.email         = ['nurfet@stackpointcloud.com']
+
+  spec.summary       = 'Chef Knife plugin for 1&1 Cloud server'
+  spec.description   = 'Official Chef Knife plugin for managing 1&1 Cloud servers'
+  spec.homepage      = 'https://github.com/1and1/oneandone-cloudserver-chef'
+  spec.license       = 'Apache-2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency '1and1', '~> 1.1'
+  spec.add_runtime_dependency 'chef', '~> 12'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.39'
+  spec.add_development_dependency 'webmock', '~> 1.24'
+  spec.add_development_dependency 'vcr', '~> 3.0'
+end

data/lib/1and1/helpers.rb

@@ -0,0 +1,29 @@
+module Oneandone
+  module Helpers
+    def split_delimited_input(input)
+      return [] if input.nil?
+
+      if input.is_a? String
+        input.strip!
+
+        delimiter = ','
+        # Knife is reading --option value1,value2 as "value1 value2"
+        # on Windows PowerShell interface
+        delimiter = ' ' if input.include? ' '
+
+        values = input.split(delimiter)
+        values
+      else
+        # return array of whatever
+        [input]
+      end
+    end
+
+    def validate(param, msg)
+      if param.nil? || param.empty?
+        ui.error("You must supply #{msg}!")
+        exit 1
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_appliance_list.rb

@@ -0,0 +1,39 @@
+require 'chef/knife/oneandone_base'
+
+class Chef
+  class Knife
+    class OneandoneApplianceList < Knife
+      include Knife::OneandoneBase
+
+      banner 'knife oneandone appliance list'
+
+      def run
+        $stdout.sync = true
+
+        init_client
+
+        response = OneAndOne::ServerAppliance.new.list
+        formated_output(response, true)
+
+        sizes = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Type', :bold),
+          ui.color('OS', :bold),
+          ui.color('Version', :bold),
+          ui.color('Architecture', :bold)
+        ]
+        response.each do |fs|
+          sizes << fs['id']
+          sizes << fs['name']
+          sizes << fs['type']
+          sizes << fs['os']
+          sizes << fs['version']
+          sizes << fs['os_architecture'].to_s
+        end
+
+        puts ui.list(sizes, :uneven_columns_across, 6)
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_base.rb

@@ -0,0 +1,32 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module OneandoneBase
+      def self.included(includer)
+        includer.class_eval do
+          deps do
+            require 'oneandone'
+          end
+
+          option :oneandone_api_key,
+                 short: '-A API_KEY',
+                 long: '--oneandone-api-key API_KEY',
+                 description: 'Your 1&1 API access key',
+                 proc: proc { |api_token| Chef::Config[:knife][:oneandone_api_key] = api_token }
+        end
+      end
+
+      def init_client
+        OneAndOne.start(Chef::Config[:knife][:oneandone_api_key])
+      end
+
+      def formated_output(data, is_exit)
+        if config[:format] != default_config[:format]
+          ui.output(data)
+          exit 0 if is_exit
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_datacenter_list.rb

@@ -0,0 +1,33 @@
+require 'chef/knife/oneandone_base'
+
+class Chef
+  class Knife
+    class OneandoneDatacenterList < Knife
+      include Knife::OneandoneBase
+
+      banner 'knife oneandone datacenter list'
+
+      def run
+        $stdout.sync = true
+
+        init_client
+
+        response = OneAndOne::Datacenter.new.list
+        formated_output(response, true)
+
+        datacenters = [
+          ui.color('ID', :bold),
+          ui.color('Location', :bold),
+          ui.color('Country Code', :bold)
+        ]
+        response.each do |dc|
+          datacenters << dc['id']
+          datacenters << dc['location']
+          datacenters << dc['country_code']
+        end
+
+        puts ui.list(datacenters, :uneven_columns_across, 3)
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_firewall_create.rb

@@ -0,0 +1,97 @@
+require 'chef/knife/oneandone_base'
+require '1and1/helpers'
+
+class Chef
+  class Knife
+    class OneandoneFirewallCreate < Knife
+      include Knife::OneandoneBase
+      include Oneandone::Helpers
+
+      banner 'knife oneandone firewall create (options)'
+
+      option :name,
+             short: '-n NAME',
+             long: '--name NAME',
+             description: 'Name of the firewall (required)'
+
+      option :description,
+             long: '--description DESCRIPTION',
+             description: 'Description of the firewall'
+
+      option :port_from,
+             long: '--port-from [PORT_FROM]',
+             description: 'A comma separated list of the first firewall ports in range (80,161,443)'
+
+      option :port_to,
+             long: '--port-to [PORT_TO]',
+             description: 'A comma separated list of the second firewall ports in range (80,162,443)'
+
+      option :protocol,
+             short: '-p [PROTOCOL]',
+             long: '--protocol [PROTOCOL]',
+             description: 'A comma separated list of the firewall protocols (TCP,UDP,TCP/UDP,ICMP,IPSEC,GRE)'
+
+      option :source,
+             short: '-S [SOURCE_IP]',
+             long: '--source [SOURCE_IP]',
+             description: 'A comma separated list of the source IPs allowed to access though the firewall'
+
+      option :wait,
+             short: '-W',
+             long: '--wait',
+             description: 'Wait for the operation to complete.'
+
+      def run
+        $stdout.sync = true
+
+        validate(config[:name], '-n NAME')
+        validate(config[:protocol], 'at least one value for --protocol [PROTOCOL]')
+
+        protocols = split_delimited_input(config[:protocol])
+        ports_from = split_delimited_input(config[:port_from])
+        ports_to = split_delimited_input(config[:port_to])
+        sources = split_delimited_input(config[:source])
+
+        validate_rules(ports_from, ports_to, protocols)
+
+        rules = []
+
+        for i in 0..(protocols.length - 1)
+          rule = {
+            'protocol' => protocols[i].upcase,
+            'port_from' => ports_from[i].nil? ? nil : ports_from[i].to_i,
+            'port_to' => ports_to[i].nil? ? nil : ports_to[i].to_i,
+            'source' => sources[i]
+          }
+          rules << rule
+        end
+
+        init_client
+
+        firewall = OneAndOne::Firewall.new
+        response = firewall.create(name: config[:name], description: config[:description], rules: rules)
+
+        if config[:wait]
+          firewall.wait_for
+          formated_output(firewall.get, true)
+          puts "Firewall policy #{response['id']} is #{ui.color('created', :bold)}"
+        else
+          formated_output(response, true)
+          puts "Firewall policy #{response['id']} is #{ui.color('being created', :bold)}"
+        end
+      end
+
+      def validate_rules(ports_from, ports_to, protocols)
+        if ports_from.length != ports_to.length
+          ui.error('You must supply equal number of --port-from and --port-to values!')
+          exit 1
+        end
+
+        if protocols.length < ports_from.length
+          ui.error('It is required that the value count of --protocol >= --port-from value count!')
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_firewall_delete.rb

@@ -0,0 +1,59 @@
+require 'chef/knife/oneandone_base'
+
+class Chef
+  class Knife
+    class OneandoneFirewallDelete < Knife
+      include Knife::OneandoneBase
+
+      banner 'knife oneandone firewall delete FIREWALL_ID [FIREWALL_ID] (options)'
+
+      option :wait,
+             short: '-W',
+             long: '--wait',
+             description: 'Wait for the operation to complete.'
+
+      def run
+        $stdout.sync = true
+
+        init_client
+
+        name_args.each do |firewall_id|
+          firewall = OneAndOne::Firewall.new
+
+          begin
+            firewall.get(firewall_id: firewall_id)
+          rescue StandardError => e
+            if e.message.include? 'NOT_FOUND'
+              ui.error("Firewall ID #{firewall_id} not found. Skipping.")
+            else
+              ui.error(e.message)
+            end
+            next
+          end
+
+          firewall_name = firewall.specs['name']
+
+          confirm("Do you really want to delete firewall policy '#{firewall_name}'")
+
+          firewall.delete
+
+          if config[:wait]
+            begin
+              puts ui.color('Deleting, wait for the operation to complete...', :cyan).to_s
+              firewall.wait_for
+              puts "Firewall policy '#{firewall_name}' is #{ui.color('deleted', :bold)}"
+            rescue StandardError => e
+              if e.message.include? 'NOT_FOUND'
+                puts "Firewall policy '#{firewall_name}' is #{ui.color('deleted', :bold)}"
+              else
+                ui.error(e.message)
+              end
+            end
+          else
+            puts "Firewall policy '#{firewall_name}' is #{ui.color('being deleted', :bold)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_firewall_list.rb

@@ -0,0 +1,33 @@
+require 'chef/knife/oneandone_base'
+
+class Chef
+  class Knife
+    class OneandoneFirewallList < Knife
+      include Knife::OneandoneBase
+
+      banner 'knife oneandone firewall list'
+
+      def run
+        $stdout.sync = true
+
+        init_client
+
+        response = OneAndOne::Firewall.new.list
+        formated_output(response, true)
+
+        firewall_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('State', :bold)
+        ]
+        response.each do |fw|
+          firewall_list << fw['id']
+          firewall_list << fw['name']
+          firewall_list << fw['state']
+        end
+
+        puts ui.list(firewall_list, :uneven_columns_across, 3)
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_ip_list.rb

@@ -0,0 +1,39 @@
+require 'chef/knife/oneandone_base'
+
+class Chef
+  class Knife
+    class OneandoneIpList < Knife
+      include Knife::OneandoneBase
+
+      banner 'knife oneandone ip list'
+
+      def run
+        $stdout.sync = true
+
+        init_client
+
+        response = OneAndOne::PublicIP.new.list
+        formated_output(response, true)
+
+        ip_list = [
+          ui.color('ID', :bold),
+          ui.color('IP Address', :bold),
+          ui.color('DHCP', :bold),
+          ui.color('State', :bold),
+          ui.color('Data Center', :bold),
+          ui.color('Assigned To', :bold)
+        ]
+        response.each do |ip|
+          ip_list << ip['id']
+          ip_list << ip['ip']
+          ip_list << ip['is_dhcp'].to_s
+          ip_list << ip['state']
+          ip_list << ip['datacenter']['country_code']
+          ip_list << (ip['assigned_to'].nil? ? '' : ip['assigned_to']['name'])
+        end
+
+        puts ui.list(ip_list, :uneven_columns_across, 6)
+      end
+    end
+  end
+end

data/lib/chef/knife/oneandone_loadbalancer_create.rb

@@ -0,0 +1,147 @@
+require 'chef/knife/oneandone_base'
+require '1and1/helpers'
+
+class Chef
+  class Knife
+    class OneandoneLoadbalancerCreate < Knife
+      include Knife::OneandoneBase
+      include Oneandone::Helpers
+
+      banner 'knife oneandone loadbalancer create (options)'
+
+      option :datacenter_id,
+             short: '-D DATACENTER_ID',
+             long: '--datacenter-id DATACENTER_ID',
+             description: 'ID of the virtual data center',
+             proc: proc { |datacenter_id| Chef::Config[:knife][:datacenter_id] = datacenter_id }
+
+      option :name,
+             short: '-n NAME',
+             long: '--name NAME',
+             description: 'Name of the load balancer (required)'
+
+      option :description,
+             long: '--description DESCRIPTION',
+             description: 'Description of the load balancer'
+
+      option :health_check,
+             long: '--health-check HEALTH_CHECK',
+             description: 'Health check test: TCP, ICMP or NONE. Default is TCP.',
+             default: 'TCP'
+
+      option :health_int,
+             long: '--health-int HEALTH_INTERVAL',
+             description: 'Health check interval (sec.). Default is 15.',
+             default: 15
+
+      option :health_path,
+             long: '--health-path HEALTH_PATH',
+             description: 'URL to call for the health checking'
+
+      option :health_regex,
+             long: '--health-regex HEALTH_REGEX',
+             description: 'Regular expression to check for the health checking'
+
+      option :method,
+             short: '-m METHOD',
+             long: '--method METHOD',
+             description: 'Balancing procedure: ROUND_ROBIN or LEAST_CONNECTIONS. Default is ROUND_ROBIN.',
+             default: 'ROUND_ROBIN'
+
+      option :persistence,
+             short: '-P',
+             long: '--persistence',
+             description: 'Enable load balancer persistence (true by default)',
+             boolean: true,
+             default: true
+
+      option :persistence_int,
+             long: '--persistence-int PERSISTENCE_INTERVAL',
+             description: 'Persistence interval (sec.). Default is 1200.',
+             default: 1200
+
+      option :port_balancer,
+             long: '--port-balancer [PORT_BALANCER]',
+             description: 'A comma separated list of the load balancer ports (80,161,443)'
+
+      option :port_server,
+             long: '--port-server [PORT_SERVER]',
+             description: 'A comma separated list of the servers ports (8080,161,443)'
+
+      option :protocol,
+             short: '-p [PROTOCOL]',
+             long: '--protocol [PROTOCOL]',
+             description: 'A comma separated list of the load balancer protocols (TCP,UDP)'
+
+      option :source,
+             short: '-S [SOURCE_IP]',
+             long: '--source [SOURCE_IP]',
+             description: 'A comma separated list of the source IPs from which the access is allowed'
+
+      option :wait,
+             short: '-W',
+             long: '--wait',
+             description: 'Wait for the operation to complete.'
+
+      def run
+        $stdout.sync = true
+
+        validate(config[:name], '-n NAME')
+        validate(config[:protocol], 'at least one value for --protocol [PROTOCOL]')
+
+        protocols = split_delimited_input(config[:protocol])
+        ports_balancer = split_delimited_input(config[:port_balancer])
+        ports_server = split_delimited_input(config[:port_server])
+        sources = split_delimited_input(config[:source])
+
+        validate_rules(protocols, ports_balancer, ports_server)
+
+        rules = []
+
+        for i in 0..(protocols.length - 1)
+          rule = {
+            'protocol' => protocols[i].upcase,
+            'port_balancer' => ports_balancer[i].to_i,
+            'port_server' => ports_server[i].to_i,
+            'source' => sources[i]
+          }
+          rules << rule
+        end
+
+        init_client
+
+        load_balancer = OneAndOne::LoadBalancer.new
+        response = load_balancer.create(
+          name: config[:name],
+          description: config[:description],
+          health_check_test: config[:health_check].to_s.upcase,
+          health_check_interval: config[:health_int].to_i,
+          persistence: config[:persistence],
+          persistence_time: config[:persistence_int].to_i,
+          method: config[:method].to_s.upcase,
+          rules: rules,
+          health_check_path: config[:health_path],
+          health_check_parse: config[:health_regex],
+          datacenter_id: config[:datacenter_id]
+        )
+
+        if config[:wait]
+          puts ui.color('Creating, wait for the operation to complete...', :cyan).to_s
+          load_balancer.wait_for
+          formated_output(load_balancer.get, true)
+          puts "Load balancer #{response['id']} is #{ui.color('created', :bold)}"
+        else
+          formated_output(response, true)
+          puts "Load balancer #{response['id']} is #{ui.color('being created', :bold)}"
+        end
+      end
+
+      def validate_rules(protocols, ports_balancer, ports_server)
+        if (ports_balancer.length != ports_server.length) || (ports_balancer.length != protocols.length)
+          ui.error('You must supply equal number of --protocol, --port-balancer and --port-server values!')
+          exit 1
+        end
+      end
+    end
+  end
+end