knife-clc 0.0.1 → 0.0.2.pre

data/lib/knife-clc/cloud_extensions/cloud_adapter.rb

@@ -0,0 +1,35 @@
+module Knife
+  module Clc
+    module CloudExtensions
+      class CloudAdapter < SimpleDelegator
+        attr_reader :connection
+
+        def initialize(params)
+          @connection = params.fetch(:connection)
+          super(@connection)
+        end
+
+        def get_server_credentials(server)
+          creds_link = server['links'].find { |link| link['rel'] == 'credentials' }
+          connection.follow(creds_link) if creds_link
+        end
+
+        def ensure_server_powered_on(server)
+          return unless server['details']['powerState'] == 'stopped'
+          links = connection.power_on_server(server['id'])
+          connection.wait_for(links['operation']['id'])
+        end
+
+        def get_private_ip(server)
+          private_ips = server['details']['ipAddresses'].map { |addr| addr['internal'] }.compact
+          private_ips.first
+        end
+
+        def get_public_ip(server)
+          public_ips = server['details']['ipAddresses'].map { |addr| addr['public'] }.compact
+          public_ips.first
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/cloud_extensions.rb

@@ -0,0 +1,11 @@
+require_relative 'cloud_extensions/cloud_adapter'
+
+module Knife
+  module Clc
+    module CloudExtensions
+      def cloud_adapter
+        @cloud_adapter ||= CloudAdapter.new(:connection => connection)
+      end
+    end
+  end
+end

data/lib/knife-clc/ip_assignment/config_options.rb

@@ -0,0 +1,29 @@
+module Knife
+  module Clc
+    module IpAssignment
+      class ConfigOptions
+        def self.attach(command_class)
+          command_class.class_eval do
+            option :clc_allowed_protocols,
+              :long => '--allow PROTOCOL:FROM[-TO]',
+              :description => 'Assigns public IP with permissions for specified protocol',
+              :on => :head,
+              :proc => ->(param) do
+                Chef::Config[:knife][:clc_allowed_protocols] ||= []
+                Chef::Config[:knife][:clc_allowed_protocols] << param
+              end
+
+            option :clc_sources,
+              :long => '--source CIDR',
+              :description => 'The source IP address range allowed to access the new public IP address',
+              :on => :head,
+              :proc => ->(param) do
+                Chef::Config[:knife][:clc_sources] ||= []
+                Chef::Config[:knife][:clc_sources] << param
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/ip_assignment/ip_assigner.rb

@@ -0,0 +1,41 @@
+require_relative 'validator'
+require_relative 'mapper'
+
+module Knife
+  module Clc
+    module IpAssignment
+      class IpAssigner
+        attr_reader :connection, :config, :errors
+
+        def initialize(params)
+          @connection = params.fetch(:connection)
+          @config = params.fetch(:config)
+          @errors = params.fetch(:errors)
+        end
+
+        # TODO: Params ordering dependency
+        def execute(server_id)
+          connection.create_ip_address(server_id, ip_params)
+        end
+
+        def prepare
+          validator.validate
+        end
+
+        private
+
+        def ip_params
+          mapper.prepare_ip_params
+        end
+
+        def validator
+          @validator ||= Validator.new(:config => config, :errors => errors)
+        end
+
+        def mapper
+          @mapper ||= Mapper.new(:config => config, :errors => errors)
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/ip_assignment/mapper.rb

@@ -0,0 +1,20 @@
+module Knife
+  module Clc
+    module IpAssignment
+      class Mapper
+        attr_reader :config
+
+        def initialize(params)
+          @config = params.fetch(:config)
+        end
+
+        def prepare_ip_params
+          {
+            'ports' => config[:clc_allowed_protocols],
+            'sourceRestrictions' => config[:clc_sources]
+          }.delete_if { |_, value| value.nil? || value.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/ip_assignment/validator.rb

@@ -0,0 +1,74 @@
+module Knife
+  module Clc
+    module IpAssignment
+      class Validator
+        attr_reader :config, :errors
+
+        def initialize(params)
+          @config = params.fetch(:config)
+          @errors = params.fetch(:errors)
+        end
+
+        def validate
+          parse_protocol_permissions
+          parse_sources
+        end
+
+        private
+
+        def parse_protocol_permissions
+          permissions = config[:clc_allowed_protocols]
+
+          return unless permissions && permissions.any?
+
+          permissions.map! do |param|
+            protocol, port_range = param.split(':', 2)
+
+            case protocol.downcase
+            when 'ssh', 'sftp' then { 'protocol' => 'tcp', 'port' => 22 }
+            when 'rdp' then { 'protocol' => 'tcp', 'port' => 3389 }
+            when 'icmp' then { 'protocol' => 'icmp' }
+            when 'http' then [{ 'protocol' => 'tcp', 'port' => 80 }, { 'protocol' => 'tcp', 'port' => 8080 }]
+            when 'https' then { 'protocol' => 'tcp', 'port' => 443 }
+            when 'ftp' then { 'protocol' => 'tcp', 'port' => 21 }
+            when 'ftps' then { 'protocol' => 'tcp', 'port' => 990 }
+            when 'winrm' then [{ 'protocol' => 'tcp', 'port' => 5985 }, { 'protocol' => 'tcp', 'port' => 5986 }]
+            when 'udp', 'tcp'
+              unless port_range
+                errors << "No ports specified for #{param}"
+              else
+                ports = port_range.split('-').map do |port_string|
+                  Integer(port_string) rescue nil
+                end
+
+                if ports.any?(&:nil?) || ports.size > 2 || ports.size < 1
+                  errors << "Malformed port range for #{param}"
+                end
+
+                {
+                  'protocol' => protocol.downcase,
+                  'port' => ports[0],
+                  'portTo' => ports[1]
+                }.keep_if { |_, value| value }
+              end
+            else
+              errors << "Unsupported protocol for #{param}"
+            end
+          end
+
+          permissions.flatten!
+        end
+
+        def parse_sources
+          sources = config[:clc_sources]
+
+          return unless sources && sources.any?
+
+          sources.map! do |cidr|
+            { 'cidr' => cidr }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/ip_assignment.rb

@@ -0,0 +1,20 @@
+require_relative 'ip_assignment/config_options'
+require_relative 'ip_assignment/ip_assigner'
+
+module Knife
+  module Clc
+    module IpAssignment
+      def self.included(command_class)
+        ConfigOptions.attach(command_class)
+      end
+
+      def ip_assigner
+        @ip_assigner ||= IpAssigner.new(
+          :connection => connection,
+          :config => config,
+          :errors => errors
+        )
+      end
+    end
+  end
+end

data/lib/knife-clc/server_launch/config_options.rb

@@ -0,0 +1,145 @@
+module Knife
+  module Clc
+    module ServerLaunch
+      class ConfigOptions
+        def self.attach(command_class)
+          command_class.class_eval do
+            option :clc_name,
+              :long => '--name NAME',
+              :description => 'Name of the server to create',
+              :on => :head
+
+            option :clc_description,
+              :long => '--description DESCRIPTION',
+              :description => 'User-defined description of this server',
+              :on => :head
+
+            option :clc_group,
+              :long => '--group ID',
+              :description => 'ID of the parent group',
+              :on => :head
+
+            option :clc_source_server,
+              :long => '--source-server ID',
+              :description => 'ID of the server to use a source. May be the ID of a template, or when cloning, an existing server ID',
+              :on => :head
+
+            option :clc_managed,
+              :long => '--managed',
+              :boolean => true,
+              :description => 'Whether to create the server as managed or not',
+              :on => :head
+
+            option :clc_managed_backup,
+              :long => '--managed-backup',
+              :boolean => true,
+              :description => 'Whether to add managed backup to the server',
+              :on => :head
+
+            option :clc_primary_dns,
+              :long => '--primary-dns ADDRESS',
+              :description => 'Primary DNS to set on the server',
+              :on => :head
+
+            option :clc_secondary_dns,
+              :long => '--secondary-dns ADDRESS',
+              :description => 'Secondary DNS to set on the server',
+              :on => :head
+
+            option :clc_network,
+              :long => '--network ID',
+              :description => 'ID of the network to which to deploy the server',
+              :on => :head
+
+            option :clc_ip,
+              :long => '--ip ADDRESS',
+              :description => 'IP address to assign to the server',
+              :on => :head
+
+            option :clc_server_password,
+              :long => '--server-password PASSWORD',
+              :description => 'Password of administrator or root user on server',
+              :on => :head
+
+            option :clc_source_server_password,
+              :long => '--source-server-password PASSWORD',
+              :description => 'Password of the source server, used only when creating a clone from an existing server',
+              :on => :head
+
+            option :clc_cpu,
+              :long => '--cpu COUNT',
+              :description => 'Number of processors to configure the server with',
+              :on => :head
+
+            option :clc_cpu_autoscale_policy,
+              :long => '--cpu-autoscale-policy ID',
+              :description => 'ID of the vertical CPU Autoscale policy to associate the server with',
+              :on => :head
+
+            option :clc_memory,
+              :long => '--memory COUNT',
+              :description => 'Number of GB of memory to configure the server with',
+              :on => :head
+
+            option :clc_type,
+              :long => '--type TYPE',
+              :description => 'Whether to create a standard or hyperscale server',
+              :on => :head
+
+            option :clc_storage_type,
+              :long => '--storage-type TYPE',
+              :description => 'For standard servers, whether to use standard or premium storage',
+              :on => :head
+
+            option :clc_anti_affinity_policy,
+              :long => '--anti-affinity-policy ID',
+              :description => 'ID of the Anti-Affinity policy to associate the server with',
+              :on => :head
+
+            option :clc_custom_fields,
+              :long => '--custom-field KEY=VALUE',
+              :description => 'Custom field key-value pair',
+              :on => :head,
+              :proc => ->(param) do
+                Chef::Config[:knife][:clc_custom_fields] ||= []
+                Chef::Config[:knife][:clc_custom_fields] << param
+              end
+
+            option :clc_disks,
+              :long => '--disk PATH,SIZE,TYPE',
+              :description => 'Configuration for an additional server disk',
+              :on => :head,
+              :proc => ->(param) do
+                Chef::Config[:knife][:clc_disks] ||= []
+                Chef::Config[:knife][:clc_disks] << param
+              end
+
+            option :clc_ttl,
+              :long => '--ttl DATETIME',
+              :description => 'Date/time that the server should be deleted',
+              :on => :head
+
+            option :clc_packages,
+              :long => '--package ID,KEY_1=VALUE[,KEY_2=VALUE]',
+              :description => 'Package to run on the server after it has been built',
+              :on => :head,
+              :proc => ->(param) do
+                Chef::Config[:knife][:clc_packages] ||= []
+                Chef::Config[:knife][:clc_packages] << param
+              end
+
+            option :clc_configuration,
+              :long => '--configuration ID',
+              :description => 'Specifies the identifier for the specific configuration type of bare metal server to deploy',
+              :on => :head
+
+            option :clc_os_type,
+              :long => '--os-type TYPE',
+              :description => 'Specifies the OS to provision with the bare metal server',
+              :on => :head
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/server_launch/mapper.rb

@@ -0,0 +1,40 @@
+module Knife
+  module Clc
+    module ServerLaunch
+      class Mapper
+        attr_reader :config
+
+        def initialize(params)
+          @config = params.fetch(:config)
+        end
+
+        def prepare_launch_parameters
+          {
+            'name' => config[:clc_name],
+            'description' => config[:clc_description],
+            'groupId' => config[:clc_group],
+            'sourceServerId' => config[:clc_source_server],
+            'isManagedOS' => config[:clc_managed],
+            'isManagedBackup' => config[:clc_managed_backup],
+            'primaryDns' => config[:clc_primary_dns],
+            'secondaryDns' => config[:clc_secondary_dns],
+            'networkId' => config[:clc_network],
+            'ipAddress' => config[:clc_ip],
+            'password' => config[:clc_server_password],
+            'sourceServerPassword' => config[:clc_source_server_password],
+            'cpu' => config[:clc_cpu].to_i,
+            'cpuAutoscalePolicyId' => config[:clc_cpu_autoscale_policy],
+            'memoryGB' => config[:clc_memory].to_i,
+            'type' => config[:clc_type],
+            'storageType' => config[:clc_storage_type],
+            'antiAffinityPolicyId' => config[:clc_anti_affinity_policy],
+            'customFields' => config[:clc_custom_fields],
+            'additionalDisks' => config[:clc_disks],
+            'ttl' => config[:clc_ttl],
+            'packages' => config[:clc_packages],
+          }.delete_if { |_, value| !value.kind_of?(Integer) && (value.nil? || value.empty?) }
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/server_launch/server_launcher.rb

@@ -0,0 +1,40 @@
+require_relative 'validator'
+require_relative 'mapper'
+
+module Knife
+  module Clc
+    module ServerLaunch
+      class ServerLauncher
+        attr_reader :config, :connection, :errors
+
+        def initialize(params)
+          @config = params.fetch(:config)
+          @connection = params.fetch(:connection)
+          @errors = params.fetch(:errors)
+        end
+
+        def execute
+          connection.create_server(launch_parameters)
+        end
+
+        def prepare
+          validator.validate
+        end
+
+        def launch_parameters
+          @launch_parameters ||= mapper.prepare_launch_parameters
+        end
+
+        private
+
+        def validator
+          @validator ||= Validator.new(:config => config, :errors => errors)
+        end
+
+        def mapper
+          @mapper ||= Mapper.new(:config => config)
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/server_launch/validator.rb

@@ -0,0 +1,100 @@
+module Knife
+  module Clc
+    module ServerLaunch
+      class Validator
+        attr_reader :config, :errors
+
+        def initialize(params)
+          @config = params.fetch(:config)
+          @errors = params.fetch(:errors)
+        end
+
+        def validate
+          unless config[:clc_name]
+            errors << 'Name is required'
+          end
+
+          unless config[:clc_group]
+            errors << 'Group ID is required'
+          end
+
+          unless config[:clc_source_server]
+            errors << 'Source server ID is required'
+          end
+
+          unless config[:clc_cpu]
+            errors << 'Number of CPUs is required'
+          end
+
+          unless config[:clc_memory]
+            errors << 'Number of memory GBs is required'
+          end
+
+          unless config[:clc_type]
+            errors << 'Type is required'
+          end
+
+          custom_fields = config[:clc_custom_fields]
+          if custom_fields && custom_fields.any?
+            parse_custom_fields(custom_fields)
+          end
+
+          disks = config[:clc_disks]
+          if disks && disks.any?
+            parse_disks(disks)
+          end
+
+          packages = config[:clc_packages]
+          if packages && packages.any?
+            parse_packages(packages)
+          end
+        end
+
+        private
+
+        def parse_custom_fields(custom_fields)
+          custom_fields.map! do |param|
+            key, value = param.split('=', 2)
+
+            unless key && value
+              errors << "Custom field definition #{param} is malformed"
+              next
+            end
+
+            { 'id' => key, 'value' => value }
+          end
+        end
+
+        def parse_disks(disks)
+          disks.map! do |param|
+            path, size, type = param.split(',', 3)
+
+            unless path && size && type
+              errors << "Disk definition #{param} is malformed"
+            end
+
+            { 'path' => path, 'sizeGB' => size, 'type' => type }
+          end
+        end
+
+        def parse_packages(packages)
+          packages.map! do |param|
+            begin
+              id, raw_params = param.split(',', 2)
+
+              parsed_params = {}
+              raw_params.split(',').each do |raw_pair|
+                key, value = raw_pair.split('=', 2)
+                parsed_params[key] = value
+              end
+
+              { 'packageId' => id, 'parameters' => parsed_params }
+            rescue Exception => e
+              errors << "Package definition #{param} is malformed"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/server_launch.rb

@@ -0,0 +1,21 @@
+require_relative 'server_launch/config_options'
+require_relative 'server_launch/server_launcher'
+
+module Knife
+  module Clc
+    module ServerLaunch
+      def self.included(command_class)
+        ConfigOptions.attach(command_class)
+      end
+
+      def server_launcher
+        @server_launcher ||= ServerLauncher.new(
+          :config => config,
+          :ui => ui,
+          :connection => connection,
+          :errors => errors
+        )
+      end
+    end
+  end
+end

data/lib/knife-clc/version.rb

@@ -1,5 +1,5 @@
 module Knife
   module Clc
-    VERSION = '0.0.1'
+    VERSION = '0.0.2.pre'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-clc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2.pre
 platform: ruby
 authors:
 - Alexander Sologub
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-06 00:00:00.000000000 Z
+date: 2016-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -67,6 +67,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: knife-windows
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -222,6 +236,32 @@ files:
 - lib/clc.rb
 - lib/clc/client.rb
 - lib/clc/cloud_exceptions.rb
+- lib/knife-clc/async.rb
+- lib/knife-clc/async/config_options.rb
+- lib/knife-clc/base.rb
+- lib/knife-clc/base/config_options.rb
+- lib/knife-clc/bootstrap.rb
+- lib/knife-clc/bootstrap/bootstrapper.rb
+- lib/knife-clc/bootstrap/config_options.rb
+- lib/knife-clc/bootstrap/connectivity_helper.rb
+- lib/knife-clc/bootstrap/methods/async_linux_package.rb
+- lib/knife-clc/bootstrap/methods/async_windows_package.rb
+- lib/knife-clc/bootstrap/methods/sync_linux_ssh.rb
+- lib/knife-clc/bootstrap/methods/sync_windows_winrm.rb
+- lib/knife-clc/bootstrap/subcommand_loader.rb
+- lib/knife-clc/bootstrap/validator.rb
+- lib/knife-clc/cloud_extensions.rb
+- lib/knife-clc/cloud_extensions/cloud_adapter.rb
+- lib/knife-clc/ip_assignment.rb
+- lib/knife-clc/ip_assignment/config_options.rb
+- lib/knife-clc/ip_assignment/ip_assigner.rb
+- lib/knife-clc/ip_assignment/mapper.rb
+- lib/knife-clc/ip_assignment/validator.rb
+- lib/knife-clc/server_launch.rb
+- lib/knife-clc/server_launch/config_options.rb
+- lib/knife-clc/server_launch/mapper.rb
+- lib/knife-clc/server_launch/server_launcher.rb
+- lib/knife-clc/server_launch/validator.rb
 - lib/knife-clc/version.rb
 homepage: https://github.com/CenturyLinkCloud/clc-knife
 licenses:
@@ -238,9 +278,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.6