knife-clc 0.0.1.pre

data/lib/chef/knife/clc_server_list.rb

@@ -0,0 +1,119 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcServerList < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc server list (options)'
+
+      option :clc_datacenter,
+        :long => '--datacenter ID',
+        :description => 'Short string representing the data center you are querying',
+        :on => :head
+
+      option :clc_all,
+        :long => '--all',
+        :boolean => true,
+        :default => false,
+        :description => 'The attribute to return a list of all servers from all datacenters',
+        :on => :head
+
+      option :clc_chef_nodes,
+        :long => '--chef-nodes',
+        :boolean => true,
+        :default => false,
+        :description => 'Wherever to include Chef node names in the listing or not',
+        :on => :head
+
+      def execute
+        servers = cloud_servers
+        merge_public_ips!(servers)
+        merge_chef_nodes!(servers) if config[:clc_chef_nodes]
+
+        context[:servers] = servers
+
+        render
+      end
+
+      def merge_public_ips!(servers)
+        servers.map! do |server|
+          ip_link = server['links'].find { |link| link['rel'] == 'publicIPAddress' }
+          server['publicIP'] = ip_link['id'] if ip_link
+          server
+        end
+      end
+
+      def merge_chef_nodes!(servers)
+        nodes = Chef::Node.list(true).values
+        servers.map! do |server|
+          existing_node = nodes.find { |node| node['machinename'] == server['name'] }
+          server['chefNode'] = existing_node.name if existing_node
+          server
+        end
+      end
+
+      def cloud_servers
+        if config[:clc_datacenter]
+          connection.list_servers(config[:clc_datacenter])
+        elsif config[:clc_all]
+          datacenters = connection.list_datacenters
+
+          datacenters.map do |dc|
+            connection.list_servers(dc['id'])
+          end.flatten
+        end
+      end
+
+      def headers
+        {
+          'id' => 'ID',
+          'name' => 'Name',
+          'publicIP' => 'Public IP',
+          'chefNode' => 'Chef Node',
+          'groupId' => 'Group',
+          'osType' => 'OS Type',
+          'status' => 'Status',
+          'locationId' => 'DC'
+        }
+      end
+
+      def fields
+        # TODO AS: Displaying shortened list of fields for now
+        # default_fields = %w(id name publicIP groupId locationId osType status)
+        default_fields = %w(name publicIP status)
+        config[:clc_chef_nodes] ? default_fields.insert(3, 'chefNode') : default_fields
+      end
+
+      def filters
+        {
+          'publicIP' => ->(ip) { ip || '-' },
+          'chefNode' => ->(name) { name || '-' }
+        }
+      end
+
+      def width_limits
+        {
+          'chefNode' => 21,
+          'status' => 15
+        }
+      end
+
+      def render
+        ui.info Hirb::Helpers::AutoTable.render(context[:servers],
+          :headers => headers,
+          :fields => fields,
+          :filters => filters,
+          :max_fields => width_limits,
+          :resize => false,
+          :description => false)
+      end
+
+      def parse_and_validate_parameters
+        if config[:clc_datacenter].nil? && !config[:clc_all]
+          errors << 'Datacenter ID is required'
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_server_power_off.rb

@@ -0,0 +1,38 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcServerPowerOff < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc server power_off 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 << 'Server ID is required'
+        end
+      end
+
+      def execute
+        ui.info 'Requesting server power off...'
+        links = connection.power_off_server(name_args[0])
+
+        if config[:clc_wait]
+          connection.wait_for(links['operation']['id']) { putc '.' }
+          ui.info "\n"
+          ui.info 'Server has been powered off'
+        else
+          ui.info 'Power off request has been sent'
+          ui.info "You can check power off operation status with 'knife clc operation show #{links['operation']['id']}'"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_server_power_on.rb

@@ -0,0 +1,38 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcServerPowerOn < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc server power_on 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 << 'Server ID is required'
+        end
+      end
+
+      def execute
+        ui.info 'Requesting server power on...'
+        links = connection.power_on_server(name_args[0])
+
+        if config[:clc_wait]
+          connection.wait_for(links['operation']['id']) { putc '.' }
+          ui.info "\n"
+          ui.info 'Server has been powered on'
+        else
+          ui.info 'Power on request has been sent'
+          ui.info "You can check power on operation status with 'knife clc operation show #{links['operation']['id']}'"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_server_reboot.rb

@@ -0,0 +1,38 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcServerReboot < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc server reboot 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 << 'Server ID is required'
+        end
+      end
+
+      def execute
+        ui.info 'Requesting server reboot...'
+        links = connection.reboot_server(name_args[0])
+
+        if config[:clc_wait]
+          connection.wait_for(links['operation']['id']) { putc '.' }
+          ui.info "\n"
+          ui.info 'Server has been rebooted'
+        else
+          ui.info 'Reboot request has been sent'
+          ui.info "You can check reboot operation status with 'knife clc operation show #{links['operation']['id']}'"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_server_show.rb

@@ -0,0 +1,188 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcServerShow < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc server show ID (options)'
+
+      option :clc_uuid,
+        :long => '--uuid',
+        :description => 'Use primary argument as server UUID instead of just ID',
+        :boolean => true,
+        :default => false,
+        :on => :head
+
+      option :clc_creds,
+        :long => '--creds',
+        :description => 'Show server credentials',
+        :boolean => true,
+        :default => false,
+        :on => :head
+
+      option :clc_ports,
+        :long => '--ports',
+        :description => 'Show opened ports and restrictions',
+        :boolean => true,
+        :default => false,
+        :on => :head
+
+      def parse_and_validate_parameters
+        unless name_args[0]
+          errors << 'Server ID is required'
+        end
+      end
+
+      def execute
+        ui.info 'Requesting server info...'
+
+        context[:server] = get_server
+        context[:creds] = get_creds if config[:clc_creds]
+        context[:ip_addresses] = get_ip_addresses if config[:clc_ports]
+
+        render
+      end
+
+      def get_server
+        server = connection.show_server(name_args[0], config[:clc_uuid])
+
+        server['details'] ||= {}
+        server['details'].tap do |details|
+          details['ipAddresses'] ||= []
+          public_ips = server['details']['ipAddresses'].map { |addr| addr['public'] }.compact
+          private_ips = server['details']['ipAddresses'].map { |addr| addr['internal'] }.compact
+          details.merge!('publicIps' => public_ips, 'privateIps' => private_ips)
+        end
+
+        server
+      end
+
+      def get_creds
+        creds_link = context[:server]['links'].find { |link| link['rel'] == 'credentials' }
+        connection.follow(creds_link) if creds_link
+      end
+
+      def get_ip_addresses
+        context[:ip_addresses] = connection.list_ip_addresses(context[:server]['id'])
+      end
+
+      def render
+        render_properties
+        render_creds if config[:clc_creds]
+        render_addresses if config[:clc_ports]
+      end
+
+      def server_properties
+        %w(id name description groupId locationId osType status)
+      end
+
+      def server_detail_properties
+        %w(powerState cpu memoryMB storageGB publicIps privateIps)
+      end
+
+      def property_labels
+        {
+          'id' => 'ID',
+          'name' => 'Name',
+          'description' => 'Description',
+          'groupId' => 'Group',
+          'locationId' => 'Location',
+          'osType' => 'OS Type',
+          'cpu' => 'CPUs',
+          'memoryMB' => 'Memory',
+          'storageGB' => 'Storage',
+          'status' => 'Status',
+          'powerState' => 'Power State',
+          'publicIps' => 'Public IPs',
+          'privateIps' => 'Private IPs',
+          'userName' => 'Username',
+          'password' => 'Password'
+        }
+      end
+
+      def property_filters
+        {
+          'description' => ->(description) { description.empty? ? '-' : description },
+          'memoryMB' => ->(memory) { "#{memory} MB" },
+          'storageGB' => ->(storage) { "#{storage} GB" },
+          'publicIps' => ->(ips) { ips.empty? ? '-' : ips.join(', ') },
+          'privateIps' => ->(ips) { ips.empty? ? '-' : ips.join(', ') }
+        }
+      end
+
+      def render_properties
+        server = context[:server]
+
+        render_fields(:fields => server_properties, :container => server)
+        render_fields(:fields => server_detail_properties, :container => server['details'])
+      end
+
+      def render_addresses
+        if context[:ip_addresses].empty?
+          ui.info 'No additional networking info available'
+        else
+          ui.info Hirb::Helpers::AutoTable.render(context[:ip_addresses],
+            :headers => ip_headers,
+            :fields => ip_fields,
+            :filters => ip_filters,
+            :resize => false,
+            :description => false)
+        end
+      end
+
+      def ip_fields
+        %w(id internalIPAddress ports sourceRestrictions)
+      end
+
+      def ip_headers
+        {
+          'id' => 'Public IP',
+          'internalIPAddress' => 'Internal IP',
+          'ports' => 'Ports',
+          'sourceRestrictions' => 'Sources'
+        }
+      end
+
+      def ip_filters
+        {
+          'sourceRestrictions' => ->(sources) { sources.empty? ? '-' : sources.map { |source| source['cidr'] }.join(', ') },
+          'ports' => ->(ports) { ports.map { |permission| format_permission(permission) }.join(', ') }
+        }
+      end
+
+      def format_permission(permission)
+        protocol = permission['protocol']
+
+        if %w(tcp udp).include? protocol.downcase
+          ports = permission.values_at('port', 'portTo').compact
+          [protocol, ports.join('-')].join(':')
+        else
+          protocol
+        end
+      end
+
+      def render_creds
+        render_fields(fields: %w(userName password), container: context[:creds] || {})
+      end
+
+
+      def render_fields(fields: [], labels: property_labels, filters: property_filters, container: {})
+        fields.each do |field|
+          value = container[field]
+          filter = filters[field]
+
+          formatted_value = if value
+            filter ? filter.call(value) : value
+          else
+            '-'
+          end
+
+          label = labels[field] || field
+
+          ui.info "#{ui.color(label + ':', :bold)} #{formatted_value}"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/clc_template_list.rb

@@ -0,0 +1,91 @@
+require 'chef/knife/clc_base'
+
+class Chef
+  class Knife
+    class ClcTemplateList < Knife
+      include Knife::ClcBase
+
+      banner 'knife clc template list (options)'
+
+      option :clc_datacenter,
+        :long => '--datacenter ID',
+        :short => '-D ID',
+        :description => 'Datacenter ID to show templates from',
+        :on => :head
+
+      option :clc_all,
+        :long => '--all',
+        :boolean => true,
+        :default => false,
+        :description => 'The attribute to return a list of all templates from all datacenters',
+        :on => :head
+
+      def execute
+        context[:templates] = cloud_templates
+        render
+      end
+
+      def cloud_templates
+        if config[:clc_datacenter]
+          connection.list_templates(config[:clc_datacenter])
+        elsif config[:clc_all]
+          datacenters = connection.list_datacenters
+
+          datacenters.map do |dc|
+            connection.list_templates(dc['id'])
+          end.flatten
+        end
+      end
+
+      def parse_and_validate_parameters
+        if config[:clc_datacenter].nil? && !config[:clc_all]
+          errors << 'Datacenter ID is required'
+        end
+      end
+
+      def filters
+        {
+          'storageSizeGB' => ->(size) { (size.zero? ? '-' : "#{size} GB").rjust(7) },
+          'apiOnly' => ->(api_flag) { (api_flag ? '+' : '-').center(9) },
+          'capabilities' => ->(capabilities) { capabilities.empty? ? '-' : capabilities.join(', ') }
+        }
+      end
+
+      def width_limits
+        {
+          'description' => 0.2,
+          'storageSizeGB' => 7,
+          'capabilities' => 15,
+          'apiOnly' => 9
+        }
+      end
+
+      def fields
+        # TODO AS: Displaying shortened list of fields for now
+        # %w(name osType description storageSizeGB capabilities apiOnly)
+        %w(name storageSizeGB capabilities)
+      end
+
+      def headers
+        {
+          'name' => 'Name',
+          'osType' => 'OS Type',
+          'description' => 'Description',
+          'storageSizeGB' => 'Storage',
+          'capabilities' => 'Capabilities',
+          'apiOnly' => 'API Only'
+        }
+      end
+
+      def render
+        ui.info Hirb::Helpers::AutoTable.render(context[:templates],
+          :headers => headers,
+          :fields => fields,
+          :filters => filters,
+          :max_fields => width_limits,
+          :resize => false,
+          :description => false)
+      end
+    end
+  end
+end