knife-clc 0.0.1.pre

data/lib/chef/knife/clc_group_create.rb

@@ -0,0 +1,111 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcGroupCreate < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc group create (options)'
+
+      option :clc_name,
+        :long => '--name NAME',
+        :description => 'Name of the group to create',
+        :on => :head
+
+      option :clc_description,
+        :long => '--description DESCRIPTION',
+        :description => 'User-defined description of this group',
+        :on => :head
+
+      option :clc_parent,
+        :long => '--parent ID',
+        :description => "ID of the parent group. Retrieved from query to parent group, or by looking at the URL on the UI pages in the Control Portal",
+        :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
+
+      def parse_and_validate_parameters
+        unless config[:clc_name]
+          errors << 'Name is required'
+        end
+
+        unless config[:clc_parent]
+          errors << 'Parent Group ID is required'
+        end
+
+        custom_fields = config[:clc_custom_fields]
+        if custom_fields && custom_fields.any?
+          parse_custom_fields(custom_fields)
+        end
+      end
+
+      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 prepare_group_params
+        {
+          'name' => config[:clc_name],
+          'description' => config[:clc_description],
+          'parentGroupId' => config[:clc_parent],
+          'customFields' => config[:clc_custom_fields]
+        }.delete_if { |_, value| value.nil? || value.empty? }
+      end
+
+      def execute
+        group = connection.create_group(prepare_group_params)
+        parent_link = group['links'].detect { |link| link['rel'] == 'parentGroup' }
+        group['parent'] = parent_link['id']
+
+        context[:group] = group
+
+        render
+      end
+
+      def fields
+        %w(name id locationId description type status parent)
+      end
+
+      def headers
+        {
+          'name' => 'Name',
+          'id' => 'ID',
+          'locationId' => 'Location',
+          'description' => 'Description',
+          'type' => 'Type',
+          'status' => 'Status',
+          'parent' => 'Parent'
+        }
+      end
+
+      def render
+        group = context[:group]
+
+        fields.each do |field|
+          header = headers.fetch(field, field.capitalize)
+          value = group.fetch(field, '-')
+
+          if value
+            ui.info ui.color(header, :bold) + ': ' + value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_group_list.rb

@@ -0,0 +1,109 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcGroupList < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc group list (options)'
+
+      option :clc_datacenter,
+        :long => '--datacenter ID',
+        :short => '-D ID',
+        :description => 'Datacenter ID to show templates from',
+        :on => :head
+
+      option :clc_view,
+        :long => '--view VIEW',
+        :default => 'tree',
+        :description => 'Display output either as a table or a tree',
+        :on => :head
+
+      def parse_and_validate_parameters
+        unless config[:clc_datacenter]
+          errors << 'Datacenter ID is required'
+        end
+
+        unless %w(tree table).include?(config[:clc_view])
+          errors << 'View parameter should be either table or a tree'
+        end
+      end
+
+      def execute
+        context[:groups] = connection.list_groups(config[:clc_datacenter]).map do |group|
+          parent_link = group['links'].find { |link| link['rel'] == 'parentGroup' }
+          group['parentId'] = parent_link['id'] if parent_link
+          group
+        end
+
+        render
+      end
+
+      def filters
+        {
+          'serversCount' => ->(count) { count.zero? ? '-' : count },
+          'parentId' => ->(id) { id ? id : '-' },
+          'description' => ->(description) { description.to_s.empty? ? '-' : description }
+        }
+      end
+
+      def width_limits
+        {
+          'description' => 0.2
+        }
+      end
+
+      def fields
+        # TODO AS: Displaying shortened list of fields for now
+        # %w(name id parentId description serversCount type status)
+        %w(name id serversCount type)
+      end
+
+      def headers
+        {
+          'name' => 'Name',
+          'id' => 'ID',
+          'parentId' => 'Parent',
+          'description' => 'Description',
+          'serversCount' => 'Servers',
+          'type' => 'Type',
+          'status' => 'Status'
+        }
+      end
+
+      def render
+        case config[:clc_view]
+        when 'tree' then render_tree
+        when 'table' then render_table
+        end
+      end
+
+      def render_tree
+        display_value = ->(group) { "#{group['name']} (#{group['id']})" }
+
+        group_children = ->(parent_group) do
+          context[:groups].select { |group| group['parentId'] == parent_group['id'] }
+        end
+
+        root = context[:groups].find { |group| group['parentId'].nil? }
+
+        return unless root
+
+        ui.info Hirb::Helpers::ParentChildTree.render(root,
+          :type => :directory,
+          :value_method => display_value,
+          :children_method => group_children)
+      end
+
+      def render_table
+        ui.info Hirb::Helpers::AutoTable.render(context[:groups],
+          :fields => fields,
+          :headers => headers,
+          :filters => filters,
+          :max_fields => width_limits,
+          :resize => false,
+          :description => false)
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_ip_create.rb

@@ -0,0 +1,129 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcIpCreate < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc ip create (options)'
+
+      option :clc_server,
+        :long => '--server ID',
+        :description => 'ID of the server to assign IP to',
+        :on => :head
+
+      option :clc_internal_ip,
+        :long => '--internal IP',
+        :description => 'The internal (private) IP address to map to the new public IP address',
+        :on => :head
+
+      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
+
+      option :clc_wait,
+        :long => '--wait',
+        :description => 'Wait for operation completion',
+        :boolean => true,
+        :default => false,
+        :on => :head
+
+      def parse_and_validate_parameters
+        unless config[:clc_server]
+          errors << 'Server ID is required'
+        end
+
+        permissions = config[:clc_allowed_protocols]
+        if permissions && permissions.any?
+          parse_protocol_permissions(permissions)
+        else
+          errors << 'At least one protocol permission is required'
+        end
+
+        sources = config[:clc_sources]
+        if sources && sources.any?
+          parse_sources(sources)
+        end
+      end
+
+      def parse_protocol_permissions(permissions)
+        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 '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)
+        sources.map! { |cidr| { 'cidr' => cidr } }
+      end
+
+      def prepare_ip_params
+        {
+          'ports' => config[:clc_allowed_protocols],
+          'sourceRestrictions' => config[:clc_sources],
+          'internalIPAddress' => config[:clc_internal_ip]
+        }.delete_if { |_, value| value.nil? || value.empty? }
+      end
+
+      def execute
+        ui.info 'Requesting public IP...'
+        links = connection.create_ip_address(config[:clc_server], prepare_ip_params)
+
+        if config[:clc_wait]
+          connection.wait_for(links['operation']['id']) { putc '.' }
+          ui.info "\n"
+          ui.info 'Public IP has been assigned'
+          ui.info "You can look at new network configuration with `knife clc server show #{config[:clc_server]} --ports"
+        else
+          ui.info 'IP assignment request has been sent'
+          ui.info "You can check assignment operation status with 'knife clc operation show #{links['operation']['id']}'"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_ip_delete.rb

@@ -0,0 +1,48 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcIpDelete < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc ip delete IP (options)'
+
+      option :clc_server,
+        :long => '--server ID',
+        :description => 'ID of the server to assign IP to',
+        :on => :head
+
+      option :clc_wait,
+        :long => '--wait',
+        :description => 'Wait for operation completion',
+        :boolean => true,
+        :default => false,
+        :on => :head
+
+      def parse_and_validate_parameters
+        unless name_args[0]
+          errors << 'IP string is required'
+        end
+
+        unless config[:clc_server]
+          errors << 'Server ID is required'
+        end
+      end
+
+      def execute
+        ui.info 'Requesting IP deletion...'
+        links = connection.delete_ip_address(config[:clc_server], name_args[0])
+
+        if config[:clc_wait]
+          connection.wait_for(links['operation']['id']) { putc '.' }
+          ui.info "\n"
+          ui.info 'IP address has been deleted'
+          ui.info "You can look at new network configuration with `knife clc server show #{config[:clc_server]} --ports"
+        else
+          ui.info 'Deletion request has been sent'
+          ui.info "You can check deletion operation status with 'knife clc operation show #{links['operation']['id']}'"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_operation_show.rb

@@ -0,0 +1,38 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcOperationShow < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc operation show ID (options)'
+
+      option :clc_wait,
+        :long => '--wait',
+        :description => 'Wait for operation completion',
+        :boolean => true,
+        :default => false,
+        :on => :head
+
+      def parse_and_validate_parameters
+        unless name_args[0]
+          errors << 'Operation ID is required'
+        end
+      end
+
+      def execute
+        operation_id = name_args[0]
+
+        if config[:clc_wait]
+          ui.info 'Waiting for operation completion...'
+          connection.wait_for(operation_id) { putc '.' }
+          ui.info "\n"
+          ui.info 'Operation has been completed'
+        else
+          status = connection.show_operation(operation_id)['status']
+          ui.info "#{ui.color('Status', :bold)}: #{status}"
+        end
+      end
+    end
+  end
+end