knife-cosmic 0.2.0

data/lib/chef/knife/cosmic_server_remove_nic.rb

@@ -0,0 +1,101 @@
+#
+# Original knife-cloudstack author:: John E. Vincent (<lusis.org+github.com@gmail.com>)
+# Copyright:: Copyright (c) 2013 John E. Vincent
+# License:: Apache License, Version 2.0
+#
+# 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/cosmic_base'
+require 'chef/knife/cosmic_baselist'
+
+module Knifecosmic
+  class CosmicServerRemoveNic < Chef::Knife
+
+    include Chef::Knife::KnifecosmicBase
+    include Chef::Knife::KnifecosmicBaseList
+
+    deps do
+      require 'knife-cosmic/connection'
+      require 'chef/knife'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cosmic server remove nic SERVERID NICID"
+
+
+    def run
+      validate_base_options
+
+      @server_id, @nic_id = name_args
+
+      if @server_id.nil? || @nic_id.nil?
+        show_usage
+        ui.fatal("You must provide both a nic id and a server id")
+        exit(1)
+      end
+
+
+      object_list = []
+      if locate_config_value(:fields)
+        locate_config_value(:fields).split(',').each { |n| object_list << ui.color(("#{n}").strip, :bold) }
+      else
+        object_list << ui.color('Server', :bold)
+        object_list << ui.color('Network', :bold)
+        object_list << ui.color('Type', :bold)
+        object_list << ui.color('Default', :bold)
+        object_list << ui.color('Address', :bold)
+        object_list << ui.color('Gateway', :bold)
+        object_list << ui.color('Netmask', :bold)
+        object_list << ui.color('ID', :bold)
+      end
+
+      columns = object_list.count
+
+      connection_result = connection.remove_nic_from_vm(
+        @nic_id,
+        @server_id
+      )
+
+      output_format(connection_result)
+
+      object_list << connection_result['name']
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      if connection_result['nic']
+        connection_result['nic'].each do |r|
+            if locate_config_value(:fields)
+              locate_config_value(:fields).downcase.split(',').each { |n| object_list << ((r[("#{n}").strip]).to_s || 'N/A') }
+            else
+              object_list << ''
+              object_list << r['networkname'].to_s
+              object_list << r['type'].to_s
+              object_list << (r['isdefault'] ? r['isdefault'].to_s : 'false')
+              object_list << (r['ipaddress'] || '')
+              object_list << (r['gateway'] || '')
+              object_list << (r['netmask'] || '')
+              object_list << (r['networkid'] || '')
+            end
+        end
+        puts ui.list(object_list, :uneven_columns_across, columns)
+        list_object_fields(connection_result) if locate_config_value(:fieldlist)
+      else
+        ui.error("No nicosmic returned in response")
+      end
+    end
+  end
+end

data/lib/chef/knife/cosmic_server_start.rb

@@ -0,0 +1,104 @@
+#
+# Original knife-cloudstack author:: Ryan Holmes (<rholmes@edmunds.com>)
+# Original knife-cloudstack author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
+# Original knife-cloudstack author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2011 Edmunds, Inc.
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# License:: Apache License, Version 2.0
+#
+# 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/cosmic_base'
+
+module Knifecosmic
+  class CosmicServerStart < Chef::Knife
+
+    include Chef::Knife::KnifecosmicBase
+
+    deps do
+      require 'chef/knife'
+      require 'knife-cosmic/connection'
+      require 'chef/api_client'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cosmic server start SERVER_NAME [SERVER_NAME ...] (options)"
+
+    option :confirm,
+           :long => "--confirm",
+           :description => "Dont ask for confirmation.",
+           :boolean => true
+
+    def run
+    validate_base_options
+
+      @name_args.each do |hostname|
+        server = connection.get_server(hostname)
+
+        if !server then
+          ui.error("Server '#{hostname}' not found")
+          next
+        end
+
+        rules = connection.list_port_forwarding_rules
+       
+        show_object_details(server, connection, rules)
+
+        result = config[:confirm] ? true : confirm_action("Do you really want to start this server")
+        if result
+          print "#{ui.color("Waiting for startup", :magenta)}"
+          connection.start_server(hostname)
+          puts "\n"
+          ui.msg("Started server #{hostname}")
+        end
+      end
+
+    end
+
+    def show_object_details(s, connection, rules)
+      return if locate_config_value(:yes)
+
+      object_fields = []
+      object_fields << ui.color("Name:", :cyan)
+      object_fields << s['name'].to_s
+      object_fields << ui.color("Public IP:", :cyan)
+      object_fields << (connection.get_server_public_ip(s, rules) || '')
+      object_fields << ui.color("Service:", :cyan)
+      object_fields << s['serviceofferingname'].to_s
+      object_fields << ui.color("Template:", :cyan)
+      object_fields << s['templatename']
+      object_fields << ui.color("Domain:", :cyan)
+      object_fields << s['domain']
+      object_fields << ui.color("Zone:", :cyan)
+      object_fields << s['zonename']
+      object_fields << ui.color("State:", :cyan)
+      object_fields << s['state']
+
+      puts "\n"
+      puts ui.list(object_fields, :uneven_columns_across, 2)
+      puts "\n"
+    end
+
+    def confirm_action(question)
+      return true if locate_config_value(:yes)
+      result = ui.ask_question(question, :default => "Y" )
+      if result == "Y" || result == "y" then
+        return true
+      else
+        return false
+      end
+    end
+
+  end
+end

data/lib/chef/knife/cosmic_server_stop.rb

@@ -0,0 +1,118 @@
+#
+# Original knife-cloudstack author:: Ryan Holmes (<rholmes@edmunds.com>)
+# Original knife-cloudstack author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
+# Original knife-cloudstack author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2011 Edmunds, Inc.
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# License:: Apache License, Version 2.0
+#
+# 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/cosmic_base'
+
+module Knifecosmic
+  class CosmicServerStop < Chef::Knife
+
+    include Chef::Knife::KnifecosmicBase
+
+    deps do
+      require 'knife-cosmic/connection'
+      require 'chef/api_client'
+      require 'chef/knife'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cosmic server stop SERVER_NAME [SERVER_NAME ...] (options)"
+
+    option :cosmic_force_stop,
+           :long => "--force",
+           :description => "Force stop the VM. The caller knows the VM is stopped.",
+           :boolean => true
+
+    option :confirm,
+           :long => "--confirm",
+           :description => "Dont ask for confirmation.",
+           :boolean => true
+
+    def run
+      validate_base_options
+
+      @name_args.each do |hostname|
+        server = connection.get_server(hostname)
+
+        if !server then
+          ui.error("Server '#{hostname}' not found")
+          next
+        end
+
+        rules = connection.list_port_forwarding_rules
+       
+        show_object_details(server, connection, rules) 
+
+        if config[:cosmic_force_stop]
+          result = config[:confirm] ? true : confirm_action("Do you really want to force stop this server")
+          if result
+            print "#{ui.color("Forcefully stopping", :magenta)}"
+            connection.stop_server(hostname,config[:cosmic_force_stop])
+            puts "\n"
+            ui.msg("Stopped server #{hostname}")
+          end
+        else
+          result = config[:confirm] ? true : confirm_action("Do you really want to stop this server")
+          if result
+            print "#{ui.color("Stopping", :magenta)}"
+            connection.stop_server(hostname)
+            puts "\n"
+            ui.msg("Stopped server #{hostname}")
+          end 
+        end
+      end
+    end
+
+    def show_object_details(s, connection, rules)
+      return if locate_config_value(:yes)
+      
+      object_fields = []
+      object_fields << ui.color("Name:", :cyan)
+      object_fields << s['name'].to_s
+      object_fields << ui.color("Public IP:", :cyan)
+      object_fields << (connection.get_server_public_ip(s, rules) || '')
+      object_fields << ui.color("Service:", :cyan)
+      object_fields << s['serviceofferingname'].to_s
+      object_fields << ui.color("Template:", :cyan)
+      object_fields << s['templatename']
+      object_fields << ui.color("Domain:", :cyan)
+      object_fields << s['domain']
+      object_fields << ui.color("Zone:", :cyan)
+      object_fields << s['zonename']
+      object_fields << ui.color("State:", :cyan)
+      object_fields << s['state']
+
+      puts "\n"
+      puts ui.list(object_fields, :uneven_columns_across, 2)
+      puts "\n"
+    end
+
+    def confirm_action(question)
+      return true if locate_config_value(:yes)
+      result = ui.ask_question(question, :default => "Y" )
+      if result == "Y" || result == "y" then
+        return true
+      else
+        return false
+      end
+    end
+
+  end
+end

data/lib/chef/knife/cosmic_server_update.rb

@@ -0,0 +1,47 @@
+#
+# knife-cosmic author:: Robbert-Jan Sperna Weiland (<rspernaweiland@schubergphilis.com>)
+# Copyright:: Copyright (c) 2018 Robbert-Jan Sperna Weiland.
+# License:: Apache License, Version 2.0
+#
+# 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/cosmic_base'
+require 'chef/knife/winrm_base'
+
+module Knifecosmic
+  class CosmicServerUpdate < Chef::Knife
+
+    include Chef::Knife::KnifecosmicBase
+
+    deps do
+      require 'chef/knife'
+      require 'chef/json_compat'
+      require 'knife-cosmic/connection'
+      require 'httpclient'
+    end
+
+    banner "knife cosmic server update [SERVER_NAME] (options)"
+
+    def run
+      validate_base_options
+
+      params = {}
+      for key in config.keys
+        params["#{key}"] = config[:"#{key}"]
+      end
+      @server = connection.server_update(params)
+    end
+
+  end
+end

data/lib/chef/knife/cosmic_service_list.rb

@@ -0,0 +1,74 @@
+#
+# Original knife-cloudstack author:: Ryan Holmes (<rholmes@edmunds.com>)
+# Original knife-cloudstack author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2011 Edmunds, Inc.
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# License:: Apache License, Version 2.0
+#
+# 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'
+require 'chef/knife/cosmic_baselist'
+
+module Knifecosmic
+  class CosmicServiceList < Chef::Knife
+
+    include Chef::Knife::KnifecosmicBaseList
+
+    banner "knife cosmic service list (options)"
+
+    option :name,
+           :long => "--name NAME",
+           :description => "Specify servicename to list"
+
+    option :keyword,
+           :long => "--keyword NAME",
+           :description => "Specify part of servicename to list"
+
+    def run
+      validate_base_options
+
+      columns = [
+        'Name      :name',
+        'Memory    :memory',
+        'CPUs      :cpunumber',
+        'CPU Speed :cpuspeed',
+        'Created   :created'
+      ]
+
+      params = { 'command' => "listServiceOfferings" }
+      params['filter']  = locate_config_value(:filter)  if locate_config_value(:filter)
+      params['keyword'] = locate_config_value(:keyword) if locate_config_value(:keyword)
+      params['name']    = locate_config_value(:name)    if locate_config_value(:name)
+      
+      result = connection.list_object(params, "serviceoffering")
+
+      result.each do |r|
+        r['memory'] = human_memory(r['memory']) if r['memory']
+      end
+
+      list_object(columns, result)
+    end
+
+    def human_memory n
+      count = 0
+      while  n >= 1024 and count < 2
+        n /= 1024.0
+        count += 1
+      end
+      format("%.0f", n) + %w(MB GB TB)[count]
+    end
+
+  end
+end

data/lib/chef/knife/cosmic_stack_create.rb

@@ -0,0 +1,298 @@
+#
+# Original knife-cloudstack author:: Ryan Holmes (<rholmes@edmunds.com>)
+# Copyright:: Copyright (c) 2011 Edmunds, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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/cosmic_base'
+require 'chef/knife/cosmic_baselist'
+
+module Knifecosmic
+  class CosmicStackCreate < Chef::Knife
+
+    attr_accessor :current_stack
+
+    include Chef::Knife::KnifecosmicBase
+    include Chef::Knife::KnifecosmicBaseList
+
+    deps do
+      require 'chef/json_compat'
+      require 'chef/mash'
+      require 'chef/search/query'
+      require 'chef/knife/node_run_list_remove'
+      require 'net/ssh'
+      require 'net/ssh/multi'
+      require 'knife-cosmic/connection'
+      Chef::Knife.load_deps
+      Chef::Knife::Ssh.load_deps
+      Chef::Knife::NodeRunListRemove.load_deps
+      Knifecosmic::CosmicServerCreate.load_deps
+    end
+
+    banner "knife cosmic stack create JSON_FILE (options)"
+
+    option :ssh_user,
+           :short => "-x USERNAME",
+           :long => "--ssh-user USERNAME",
+           :description => "The ssh username"
+
+    option :ssh_password,
+           :short => "-P PASSWORD",
+           :long => "--ssh-password PASSWORD",
+           :description => "The ssh password"
+
+    option :identity_file,
+           :short => "-i IDENTITY_FILE",
+           :long => "--identity-file IDENTITY_FILE",
+           :description => "The SSH identity file used for authentication"
+
+    option :skip_existing,
+           :long => "--skip-existing",
+           :default => false,
+           :description => "Skip creating existing server(s)"
+
+    def run
+      validate_base_options
+      if @name_args.first.nil?
+        ui.error "Please specify json file eg: knife cosmic stack create JSON_FILE"
+        exit 1
+      end
+      file_path = File.expand_path(@name_args.first)
+      unless File.exist?(file_path) then
+        ui.error "Stack file '#{file_path}' not found. Please check the path."
+        exit 1
+      end
+
+      data = File.read file_path
+      stack = Chef::JSONCompat.from_json data
+      create_stack stack
+    end
+
+    def create_stack(stack)
+      @current_stack = Mash.new(stack)
+      current_stack[:servers].each do |server|
+        if server[:name]
+          # create server(s)
+          names = server[:name].split(/[\s,]+/)
+          names.each do |n|
+            if (config[:skip_existing] && connection.get_server(n))
+              ui.msg(ui.color("\nServer #{n} already exists; skipping create...", :yellow))
+            else
+              s = Mash.new(server)
+              s[:name] = n
+              create_server(s)
+            end
+          end
+
+        end
+
+        # execute actions
+        run_actions server[:actions]
+      end
+
+      print_local_hosts
+    end
+
+    def create_server(server)
+
+      cmd = Knifecosmic::CosmicServerCreate.new([server[:name]])
+      # configure and run command
+      # TODO: validate parameters
+      cmd.config[:cosmic_url] = config[:cosmic_url]
+      cmd.config[:cosmic_api_key] = config[:cosmic_api_key]
+      cmd.config[:cosmic_secret_key] = config[:cosmic_secret_key]
+      cmd.config[:cosmic_proxy] = config[:cosmic_proxy]
+      cmd.config[:cosmic_no_ssl_verify] = config[:cosmic_no_ssl_verify]
+      cmd.config[:cosmic_project] = config[:cosmic_project]
+      cmd.config[:ssh_user] = config[:ssh_user]
+      cmd.config[:ssh_password] = config[:ssh_password]
+      cmd.config[:ssh_port] = server[:ssh_port] || locate_config_value(:ssh_port) || "22"
+      cmd.config[:identity_file] = config[:identity_file]
+      cmd.config[:keypair] = server[:keypair]
+      cmd.config[:cosmic_template] = server[:template] if server[:template]
+      cmd.config[:cosmic_service] = server[:service] if server[:service]
+      cmd.config[:cosmic_zone] = server[:zone] if server[:zone]
+      server.has_key?(:public_ip) ? cmd.config[:public_ip] = server[:public_ip] : cmd.config[:no_public_ip] = true
+      cmd.config[:ik_private_ip] = server[:private_ip] if server[:private_ip]
+      cmd.config[:bootstrap] = server[:bootstrap] if server.has_key?(:bootstrap)
+      cmd.config[:bootstrap_protocol] = server[:bootstrap_protocol] || "ssh"
+      cmd.config[:distro] = server[:distro] || "chef-full"
+      cmd.config[:template_file] = server[:template_file] if server.has_key?(:template_file)
+      cmd.config[:no_host_key_verify] = server[:no_host_key_verify] if server.has_key?(:no_host_key_verify)
+      cmd.config[:cosmic_networks] = server[:networks].split(/[\s,]+/) if server[:networks]
+      cmd.config[:run_list] = server[:run_list].split(/[\s,]+/) if server[:run_list]
+      cmd.config[:port_rules] = server[:port_rules].split(/[\s,]+/) if server[:port_rules]
+      if current_stack[:environment]
+        cmd.config[:environment] = current_stack[:environment]
+        Chef::Config[:environment] = current_stack[:environment]
+      end
+
+      cmd.run_with_pretty_exceptions
+    end
+
+    def run_actions(actions)
+      return if actions.nil? || actions.empty?
+      puts "\n"
+      ui.msg("Processing actions...")
+      sleep 1 # pause for e.g. chef solr indexing
+      actions ||= []
+      actions.each do |cmd|
+        cmd ||= {}
+        cmd.each do |name, args|
+          case name
+            when 'knife_ssh'
+              knife_ssh_action(*args)
+            when 'http_request'
+              http_request(args)
+            when 'run_list_remove'
+              run_list_remove(*args)
+            when 'sleep'
+              dur = args || 5
+              sleep dur
+          end
+        end
+      end
+
+    end
+
+    def search_nodes(query, attribute=nil)
+      if get_environment
+        query = "(#{query})" + " AND chef_environment:#{get_environment}"
+      end
+
+      Chef::Log.debug("Searching for nodes: #{query}")
+
+      q = Chef::Search::Query.new
+      nodes = Array(q.search(:node, query))
+
+      # the array of nodes is the first item in the array returned by the search
+      if nodes.length > 1
+        nodes = nodes.first || []
+      end
+
+      # return attribute values instead of nodes
+      if attribute
+        nodes.map do |node|
+          node[attribute.to_s]
+        end
+      else
+        nodes
+      end
+    end
+
+    def knife_ssh(host_list, command)
+      ssh = Chef::Knife::Ssh.new
+      ssh.name_args = [host_list, command]
+      ssh.config[:ssh_user] = config[:ssh_user]
+      ssh.config[:ssh_password] = config[:ssh_password]
+      ssh.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+      ssh.config[:identity_file] = config[:identity_file]
+      ssh.config[:manual] = true
+      ssh.config[:no_host_key_verify] = config[:no_host_key_verify]
+      ssh
+    end
+
+    def knife_ssh_with_password_auth(host_list, command)
+      ssh = knife_ssh(host_list, command)
+      ssh.config[:identity_file] = nil
+      ssh.config[:ssh_password] = ssh.get_password
+      ssh
+    end
+
+    def knife_ssh_action(query, command)
+      public_ips = find_public_ips(query)
+      return if public_ips.nil? || public_ips.empty?
+      host_list = public_ips.join(' ')
+
+      ssh = knife_ssh(host_list, command)
+      begin
+        ssh.run
+      rescue Net::SSH::AuthenticationFailed
+        unless config[:ssh_password]
+          puts "Failed to authenticate #{config[:ssh_user]} - trying password auth"
+          ssh = knife_ssh_with_password_auth(host_list, command)
+          ssh.run
+        end
+      end
+    end
+
+    def http_request(url)
+      match_data = /\$\{([a-zA-Z0-9-]+)\}/.match url
+      if match_data
+        server_name = match_data[1]
+        ip = public_ip_for_host(server_name)
+        url = url.sub(/\$\{#{server_name}\}/, ip)
+      end
+
+      puts "HTTP Request: #{url}"
+      puts `curl -s -m 5 #{url}`
+    end
+
+    def run_list_remove(query, entry)
+      nodes = search_nodes(query)
+      return unless nodes
+
+      nodes.each do |n|
+        cmd = Chef::Knife::NodeRunListRemove.new([n.name, entry])
+        cmd.run_with_pretty_exceptions
+      end
+    end
+
+    def find_public_ips(query)
+      hostnames = search_nodes(query, 'hostname')
+      puts "Found hostnames: #{hostnames.inspect}"
+      ips = hostnames.map { |h|
+        public_ip_for_host h
+      }
+      ips.compact.uniq
+    end
+
+    def public_ip_for_host(name)
+      return nil unless name
+      @public_ip_cache ||= {}
+
+      if !@public_ip_cache[name] then
+        server = connection.get_server(name)
+        return nil unless server
+
+        ip = connection.get_server_public_ip(server)
+        @public_ip_cache[name] = ip if ip
+      end
+
+      @public_ip_cache[name]
+    end
+
+    def get_environment
+      current_stack[:environment]
+    end
+
+    def print_local_hosts
+      hosts = []
+      current_stack[:servers].each do |server|
+        next unless server[:local_hosts]
+        name = server[:name].split(' ').first
+        ip = public_ip_for_host(name)
+        server[:local_hosts].each { |host|
+          hostname = host.sub(/\$\{environment\}/, get_environment)
+          hosts << "#{ip}    #{hostname}"
+        }
+      end
+      unless hosts.empty?
+        puts "\nAdd this to your /etc/hosts file:"
+        puts hosts.join("\n")
+      end
+    end
+  end
+end