openstudio-aws 0.1.22 → 0.1.23

data/lib/openstudio/lib/openstudio_aws_logger.rb

@@ -1,18 +1,18 @@
 # NOTE: Do not modify this file as it is copied over. Modify the source file and rerun rake import_files
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.  
+#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
 #  All rights reserved.
-#  
+#
 #  This library is free software; you can redistribute it and/or
 #  modify it under the terms of the GNU Lesser General Public
 #  License as published by the Free Software Foundation; either
 #  version 2.1 of the License, or (at your option) any later version.
-#  
+#
 #  This library is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #  Lesser General Public License for more details.
-#  
+#
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library; if not, write to the Free Software
 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
@@ -53,7 +53,7 @@ module Logging
     end
 
     def configure_logger_for(classname)
-      logger = Logger.new(File.expand_path("~/.aws.log"))
+      logger = Logger.new(File.expand_path('~/.aws.log'))
       logger.progname = classname
       logger
     end

data/lib/openstudio/lib/openstudio_aws_methods.rb

@@ -1,18 +1,18 @@
 # NOTE: Do not modify this file as it is copied over. Modify the source file and rerun rake import_files
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.  
+#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
 #  All rights reserved.
-#  
+#
 #  This library is free software; you can redistribute it and/or
 #  modify it under the terms of the GNU Lesser General Public
 #  License as published by the Free Software Foundation; either
 #  version 2.1 of the License, or (at your option) any later version.
-#  
+#
 #  This library is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #  Lesser General Public License for more details.
-#  
+#
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library; if not, write to the Free Software
 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
@@ -26,63 +26,62 @@
 # == Usage
 #
 #  Inside the class in which this file is included make sure to implement the following
-#  
+#
 #  Member Variables:
 #    private_key : the in memory private key
 #    logger : logger class in which to write log messages
-#    @proxy : proxy setting if available 
+#    @proxy : proxy setting if available
 ######################################################################
 
 module OpenStudioAwsMethods
   # This list of processors can be pulled out of the ../../doc/amazon_prices.xlsx file
   def find_processors(instance)
     lookup = {
-        "m3.medium" => 1,
-        "m3.large" => 2,
-        "m3.xlarge" => 4,
-        "m3.2xlarge" => 8,
-        "c3.large" => 2,
-        "c3.xlarge" => 4,
-        "c3.2xlarge" => 8,
-        "c3.4xlarge" => 8,
-        "c3.8xlarge" => 16,
-        "r3.large" => 2,
-        "r3.xlarge" => 4,
-        "r3.2xlarge" => 8,
-        "r3.4xlarge" => 16,
-        "r3.8xlarge" => 32,
-        "t1.micro" => 1,
-        "m1.small" => 1,
+      'm3.medium' => 1,
+      'm3.large' => 2,
+      'm3.xlarge' => 4,
+      'm3.2xlarge' => 8,
+      'c3.large' => 2,
+      'c3.xlarge' => 4,
+      'c3.2xlarge' => 8,
+      'c3.4xlarge' => 8,
+      'c3.8xlarge' => 16,
+      'r3.large' => 2,
+      'r3.xlarge' => 4,
+      'r3.2xlarge' => 8,
+      'r3.4xlarge' => 16,
+      'r3.8xlarge' => 32,
+      't1.micro' => 1,
+      'm1.small' => 1,
     }
 
     processors = 1
-    if lookup.has_key?(instance)
+    if lookup.key?(instance)
       processors = lookup[instance]
     else
-      #logger.warn "Could not find the number of processors for instance type of #{instance}" if logger
+      # logger.warn "Could not find the number of processors for instance type of #{instance}" if logger
     end
 
     processors
   end
 
-  def get_proxy()
+  def get_proxy
     proxy = nil
     if @proxy
       if @proxy[:username]
-        proxy = Net::SSH::Proxy::HTTP.new(@proxy[:host], @proxy[:port], :user => @proxy[:username], :password => proxy[:password])
+        proxy = Net::SSH::Proxy::HTTP.new(@proxy[:host], @proxy[:port], user: @proxy[:username], password: proxy[:password])
       else
         proxy = Net::SSH::Proxy::HTTP.new(@proxy[:host], @proxy[:port])
       end
     end
-    
+
     proxy
   end
-  
-  
+
   def upload_file(host, local_path, remote_path)
     retries = 0
     begin
-      Net::SCP.start(host, 'ubuntu', :proxy => get_proxy, :key_data => [@private_key]) do |scp|
+      Net::SCP.start(host, 'ubuntu', proxy: get_proxy, key_data: [@private_key]) do |scp|
         scp.upload! local_path, remote_path
       end
     rescue SystemCallError, Timeout::Error => e
@@ -100,29 +99,28 @@ module OpenStudioAwsMethods
     end
   end
 
-
   def send_command(host, command)
-    #retries = 0
+    # retries = 0
     begin
       output = ''
-      Net::SSH.start(host, 'ubuntu', :proxy => get_proxy, :key_data => [@private_key]) do |ssh|
+      Net::SSH.start(host, 'ubuntu', proxy: get_proxy, key_data: [@private_key]) do |ssh|
         response = ssh.exec!(command)
-        output += response if !response.nil?
+        output += response unless response.nil?
       end
       return output
     rescue Net::SSH::HostKeyMismatch => e
       e.remember_host!
       # key mismatch, retry
-      #return if retries == 5
-      #retries += 1
+      # return if retries == 5
+      # retries += 1
       sleep 1
       retry
     rescue Net::SSH::AuthenticationFailed
-      error(-1, "Incorrect private key")
+      error(-1, 'Incorrect private key')
     rescue SystemCallError, Timeout::Error => e
       # port 22 might not be available immediately after the instance finishes launching
-      #return if retries == 5
-      #retries += 1
+      # return if retries == 5
+      # retries += 1
       sleep 1
       retry
     rescue Exception => e
@@ -131,26 +129,26 @@ module OpenStudioAwsMethods
     end
   end
 
-  #======================= send command ======================#
+  # ======================= send command ======================#
   # Send a command through SSH Shell to an instance.
   # Need to pass instance object and the command as a string.
   def shell_command(host, command)
     begin
       @logger.info("ssh_command #{command}")
-      Net::SSH.start(host, 'ubuntu', :proxy => get_proxy, :key_data => [@private_key]) do |ssh|
+      Net::SSH.start(host, 'ubuntu', proxy: get_proxy, key_data: [@private_key]) do |ssh|
         channel = ssh.open_channel do |ch|
           ch.exec "#{command}" do |ch, success|
-            raise "could not execute #{command}" unless success
+            fail "could not execute #{command}" unless success
 
             # "on_data" is called when the process writes something to stdout
             ch.on_data do |c, data|
-              #$stdout.print data
+              # $stdout.print data
               @logger.info("#{data.inspect}")
             end
 
             # "on_extended_data" is called when the process writes something to stderr
             ch.on_extended_data do |c, type, data|
-              #$stderr.print data
+              # $stderr.print data
               @logger.info("#{data.inspect}")
             end
           end
@@ -158,13 +156,13 @@ module OpenStudioAwsMethods
       end
     rescue Net::SSH::HostKeyMismatch => e
       e.remember_host!
-      @logger.info("key mismatch, retry")
+      @logger.info('key mismatch, retry')
       sleep 1
       retry
     rescue SystemCallError, Timeout::Error => e
       # port 22 might not be available immediately after the instance finishes launching
       sleep 1
-      @logger.info("Not Yet")
+      @logger.info('Not Yet')
       retry
     end
   end
@@ -172,17 +170,17 @@ module OpenStudioAwsMethods
   def wait_command(host, command)
     begin
       flag = 0
-      while flag == 0 do
+      while flag == 0
         @logger.info("wait_command #{command}")
-        Net::SSH.start(host, 'ubuntu', :proxy => get_proxy, :key_data => [@private_key]) do |ssh|
+        Net::SSH.start(host, 'ubuntu', proxy: get_proxy, key_data: [@private_key]) do |ssh|
           channel = ssh.open_channel do |ch|
             ch.exec "#{command}" do |ch, success|
-              raise "could not execute #{command}" unless success
+              fail "could not execute #{command}" unless success
 
               # "on_data" is called when the process writes something to stdout
               ch.on_data do |c, data|
                 @logger.info("#{data.inspect}")
-                if data.chomp == "true"
+                if data.chomp == 'true'
                   @logger.info("wait_command #{command} is true")
                   flag = 1
                 else
@@ -193,7 +191,7 @@ module OpenStudioAwsMethods
               # "on_extended_data" is called when the process writes something to stderr
               ch.on_extended_data do |c, type, data|
                 @logger.info("#{data.inspect}")
-                if data == "true"
+                if data == 'true'
                   @logger.info("wait_command #{command} is true")
                   flag = 1
                 else
@@ -206,13 +204,13 @@ module OpenStudioAwsMethods
       end
     rescue Net::SSH::HostKeyMismatch => e
       e.remember_host!
-      @logger.info("key mismatch, retry")
+      @logger.info('key mismatch, retry')
       sleep 5
       retry
     rescue SystemCallError, Timeout::Error => e
       # port 22 might not be available immediately after the instance finishes launching
       sleep 5
-      @logger.info("Timeout.  Perhaps there is a communication error to EC2?  Will try again")
+      @logger.info('Timeout.  Perhaps there is a communication error to EC2?  Will try again')
       retry
     end
   end
@@ -220,7 +218,7 @@ module OpenStudioAwsMethods
   def download_file(host, remote_path, local_path)
     retries = 0
     begin
-      Net::SCP.start(host, 'ubuntu', :proxy => get_proxy, :key_data => [@private_key]) do |scp|
+      Net::SCP.start(host, 'ubuntu', proxy: get_proxy, key_data: [@private_key]) do |scp|
         scp.download! remote_path, local_path
       end
     rescue SystemCallError, Timeout::Error => e

data/lib/openstudio/lib/openstudio_aws_wrapper.rb

@@ -1,18 +1,18 @@
 # NOTE: Do not modify this file as it is copied over. Modify the source file and rerun rake import_files
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.  
+#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
 #  All rights reserved.
-#  
+#
 #  This library is free software; you can redistribute it and/or
 #  modify it under the terms of the GNU Lesser General Public
 #  License as published by the Free Software Foundation; either
 #  version 2.1 of the License, or (at your option) any later version.
-#  
+#
 #  This library is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #  Lesser General Public License for more details.
-#  
+#
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library; if not, write to the Free Software
 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
@@ -50,7 +50,7 @@ class OpenStudioAwsWrapper
 
   # todo: put this into a module
   VALID_OPTIONS = [
-      :proxy, :credentials
+    :proxy, :credentials
   ]
 
   def initialize(options = {}, group_uuid = nil)
@@ -71,31 +71,31 @@ class OpenStudioAwsWrapper
 
   def create_or_retrieve_security_group(sg_name = nil)
     tmp_name = sg_name || 'openstudio-server-sg-v1'
-    group = @aws.describe_security_groups({:filters => [{:name => 'group-name', :values => [tmp_name]}]})
+    group = @aws.describe_security_groups(filters: [{ name: 'group-name', values: [tmp_name] }])
     logger.info "Length of the security group is: #{group.data.security_groups.length}"
     if group.data.security_groups.length == 0
-      logger.info "server group not found --- will create a new one"
-      @aws.create_security_group({:group_name => tmp_name, :description => "group dynamically created by #{__FILE__}"})
+      logger.info 'server group not found --- will create a new one'
+      @aws.create_security_group(group_name: tmp_name, description: "group dynamically created by #{__FILE__}")
       @aws.authorize_security_group_ingress(
-          {
-              :group_name => tmp_name,
-              :ip_permissions => [
-                  {:ip_protocol => 'tcp', :from_port => 1, :to_port => 65535, :ip_ranges => [:cidr_ip => "0.0.0.0/0"]}
+
+              group_name: tmp_name,
+              ip_permissions: [
+                { ip_protocol: 'tcp', from_port: 1, to_port: 65_535, ip_ranges: [cidr_ip: '0.0.0.0/0'] }
               ]
-          }
+
       )
       @aws.authorize_security_group_ingress(
-          {
-              :group_name => tmp_name,
-              :ip_permissions => [
-                  {:ip_protocol => 'icmp', :from_port => -1, :to_port => -1, :ip_ranges => [:cidr_ip => "0.0.0.0/0"]
-                  }
+
+              group_name: tmp_name,
+              ip_permissions: [
+                { ip_protocol: 'icmp', from_port: -1, to_port: -1, ip_ranges: [cidr_ip: '0.0.0.0/0']
+                }
               ]
-          }
+
       )
 
       # reload group information
-      group = @aws.describe_security_groups({:filters => [{:name => 'group-name', :values => [tmp_name]}]})
+      group = @aws.describe_security_groups(filters: [{ name: 'group-name', values: [tmp_name] }])
     end
     @security_group_name = group.data.security_groups.first.group_name
     logger.info("server_group #{group.data.security_groups.first.group_name}")
@@ -108,7 +108,7 @@ class OpenStudioAwsWrapper
       map << zn.to_hash
     end
 
-    {:availability_zone_info => map}
+    { availability_zone_info: map }
   end
 
   def describe_availability_zones_json
@@ -118,8 +118,8 @@ class OpenStudioAwsWrapper
   def describe_total_instances
     resp = @aws.describe_instance_status
 
-    region = resp.instance_statuses.length > 0 ? resp.instance_statuses.first.availability_zone : "no_instances"
-    {:total_instances => resp.instance_statuses.length, :region => region}
+    region = resp.instance_statuses.length > 0 ? resp.instance_statuses.first.availability_zone : 'no_instances'
+    { total_instances: resp.instance_statuses.length, region: region }
   end
 
   def describe_total_instances_json
@@ -128,23 +128,22 @@ class OpenStudioAwsWrapper
 
   # return all of the running instances, or filter by the group_uuid & instance type
   def describe_running_instances(group_uuid = nil, openstudio_instance_type = nil)
-
     resp = nil
     if group_uuid
       resp = @aws.describe_instances(
-          {
-              :filters => [
-                  {:name => "instance-state-code", :values => [0.to_s, 16.to_s]}, #running or pending
-                  {:name => "tag-key", :values => ["GroupUUID"]},
-                  {:name => "tag-value", :values => [group_uuid.to_s]} # todo: how to check for the server versions
-              #{:name => "tag-value", :values => [group_uuid.to_s, "OpenStudio#{@openstudio_instance_type.capitalize}"]} 
-              #{:name => "tag:key=value", :values => ["GroupUUID=#{group_uuid.to_s}"]}
+
+              filters: [
+                { name: 'instance-state-code', values: [0.to_s, 16.to_s] }, # running or pending
+                { name: 'tag-key', values: ['GroupUUID'] },
+                { name: 'tag-value', values: [group_uuid.to_s] } # todo: how to check for the server versions
+              # {:name => "tag-value", :values => [group_uuid.to_s, "OpenStudio#{@openstudio_instance_type.capitalize}"]}
+              # {:name => "tag:key=value", :values => ["GroupUUID=#{group_uuid.to_s}"]}
               ]
-          }
+
       )
     else
       # todo: need to restrict this to only the current user
-      resp = @aws.describe_instances()
+      resp = @aws.describe_instances
     end
 
     instance_data = nil
@@ -157,10 +156,9 @@ class OpenStudioAwsWrapper
             instance_data << i.to_hash
           end
 
-
         end
       else
-        logger.info "no running instances found"
+        logger.info 'no running instances found'
       end
     end
 
@@ -173,15 +171,15 @@ class OpenStudioAwsWrapper
     # todo: test the filter.  i don't think that it is exposed in the AWS gem?
     if owned_by_me
       if filter
-        resp = @aws.describe_images({:owners => [:self], :filter => filter}).data
+        resp = @aws.describe_images(owners: [:self], filter: filter).data
       else
-        resp = @aws.describe_images({:owners => [:self]}).data
+        resp = @aws.describe_images(owners: [:self]).data
       end
     else
       if filter
-        resp = @aws.describe_images({:filter => filter}).data
+        resp = @aws.describe_images(filter: filter).data
       else
-        resp = @aws.describe_images({:image_ids => image_ids}).data
+        resp = @aws.describe_images(image_ids: image_ids).data
       end
     end
 
@@ -209,8 +207,8 @@ class OpenStudioAwsWrapper
     # the describe_key_pairs method will raise an expection if it can't find the keypair, so catch it
     resp = nil
     begin
-      resp = @aws.describe_key_pairs({:key_names => [tmp_name]}).data
-      raise "looks like there are 2 key pairs with the same name" if resp.key_pairs.size >= 2
+      resp = @aws.describe_key_pairs(key_names: [tmp_name]).data
+      fail 'looks like there are 2 key pairs with the same name' if resp.key_pairs.size >= 2
     rescue
       logger.info "could not find key pair '#{tmp_name}'"
     end
@@ -219,7 +217,7 @@ class OpenStudioAwsWrapper
       # create the new key_pair
       # check if the key pair name exists
       # create a new key pair everytime
-      keypair = @aws.create_key_pair({:key_name => tmp_name})
+      keypair = @aws.create_key_pair(key_name: tmp_name)
 
       # save the private key to memory (which can later be persisted via the save_private_key method)
       @private_key = keypair.data.key_material
@@ -244,27 +242,27 @@ class OpenStudioAwsWrapper
       File.open(filename, 'w') { |f| f << @private_key }
       File.chmod(0600, filename)
     else
-      logger.error "no private key found in which to persist"
+      logger.error 'no private key found in which to persist'
     end
   end
 
   def launch_server(image_id, instance_type, options = {})
-    defaults = {:user_id => "unknown_user"}
+    defaults = { user_id: 'unknown_user' }
     options = defaults.merge(options)
 
-    user_data = File.read(File.expand_path(File.dirname(__FILE__))+'/server_script.sh')
+    user_data = File.read(File.expand_path(File.dirname(__FILE__)) + '/server_script.sh')
     @server = OpenStudioAwsInstance.new(@aws, :server, @key_pair_name, @security_group_name, @group_uuid, @private_key, @proxy)
 
-    raise "image_id is nil" if not image_id
-    raise "instance type is nil" if not instance_type
+    fail 'image_id is nil' unless image_id
+    fail 'instance type is nil' unless instance_type
     @server.launch_instance(image_id, instance_type, user_data, options[:user_id])
   end
 
   def launch_workers(image_id, instance_type, num, options = {})
-    defaults = {:user_id => "unknown_user"}
+    defaults = { user_id: 'unknown_user' }
     options = defaults.merge(options)
 
-    user_data = File.read(File.expand_path(File.dirname(__FILE__))+'/worker_script.sh.template')
+    user_data = File.read(File.expand_path(File.dirname(__FILE__)) + '/worker_script.sh.template')
     user_data.gsub!(/SERVER_IP/, @server.data.ip)
     user_data.gsub!(/SERVER_HOSTNAME/, 'master')
     user_data.gsub!(/SERVER_ALIAS/, '')
@@ -291,10 +289,10 @@ class OpenStudioAwsWrapper
   # blocking method that waits for servers and workers to be fully configured (i.e. execution of user_data has
   # occured on all nodes)
   def configure_server_and_workers
-    #todo: add a timeout here!
-    logger.info("waiting for server user_data to complete")
+    # todo: add a timeout here!
+    logger.info('waiting for server user_data to complete')
     @server.wait_command(@server.data.ip, '[ -e /home/ubuntu/user_data_done ] && echo "true"')
-    @logger.info("waiting for worker user_data to complete")
+    @logger.info('waiting for worker user_data to complete')
     @workers.each { |worker| worker.wait_command(worker.data.ip, '[ -e /home/ubuntu/user_data_done ] && echo "true"') }
 
     ips = "master|#{@server.data.ip}|#{@server.data.dns}|#{@server.data.procs}|ubuntu|ubuntu|true\n"
@@ -309,7 +307,7 @@ class OpenStudioAwsWrapper
     @server.shell_command(@server.data.ip, '~/setup-ssh-keys.sh')
     @server.shell_command(@server.data.ip, '~/setup-ssh-worker-nodes.sh ip_addresses')
 
-    mongoid = File.read(File.expand_path(File.dirname(__FILE__))+'/mongoid.yml.template')
+    mongoid = File.read(File.expand_path(File.dirname(__FILE__)) + '/mongoid.yml.template')
     mongoid.gsub!(/SERVER_IP/, @server.data.ip)
     file = Tempfile.new('mongoid.yml')
     file.write(mongoid)
@@ -325,7 +323,6 @@ class OpenStudioAwsWrapper
     true
   end
 
-
   # method to query the amazon api to find the server (if it exists), based on the group id
   # if it is found, then it will set the @server member variable.
   # Note that the information around keys and security groups is pulled from the instance information.
@@ -333,11 +330,11 @@ class OpenStudioAwsWrapper
     group_uuid = group_uuid || @group_uuid
 
     logger.info "finding the server for groupid of #{group_uuid}"
-    raise "no group uuid defined either in member variable or method argument" if group_uuid.nil?
+    fail 'no group uuid defined either in member variable or method argument' if group_uuid.nil?
 
     resp = describe_running_instances(group_uuid, :server)
     if resp
-      raise "more than one server running with group uuid of #{group_uuid} found, expecting only one" if resp.size > 1
+      fail "more than one server running with group uuid of #{group_uuid} found, expecting only one" if resp.size > 1
       resp = resp.first
       if !@server
         logger.info "Server found and loading data into object [instance id is #{resp[:instance_id]}]"
@@ -347,23 +344,23 @@ class OpenStudioAwsWrapper
         logger.info "Server instance is already defined with instance #{resp[:instance_id]}"
       end
     else
-      raise "could not find a running server instance"
+      fail 'could not find a running server instance'
     end
   end
 
-  # method to hit the existing list of available amis and compare to the list of AMIs on Amazon and then generate the 
+  # method to hit the existing list of available amis and compare to the list of AMIs on Amazon and then generate the
   # new ami list
   def create_new_ami_json(version = 1)
     # get the list of existing amis from developer.nrel.gov
     existing_amis = OpenStudioAmis.new(1).list
 
     # list of available AMIs from AWS
-    available_amis = describe_amis()
+    available_amis = describe_amis
 
     amis = transform_ami_lists(existing_amis, available_amis)
 
     if version == 1
-      puts "Creating version 1 of the AMI file"
+      puts 'Creating version 1 of the AMI file'
       version1 = {}
 
       # now grab the good keys - they should be sorted newest to older... so go backwards
@@ -376,8 +373,8 @@ class OpenStudioAwsWrapper
       end
 
       # create the default version. First sort, then grab the first hash's values
-      
-      version1.sort_by()
+
+      version1.sort_by
       default_v = nil
       version1 = Hash[version1.sort_by { |k, _| k.to_s.to_version }.reverse]
       default_v = version1.keys[0]
@@ -397,15 +394,15 @@ class OpenStudioAwsWrapper
   def to_os_worker_hash
     worker_hash = []
     @workers.each { |worker|
-      worker_hash.push({
-                           :id => worker.data.id,
-                           :ip => 'http://' + worker.data.ip,
-                           :dns => worker.data.dns,
-                           :procs => worker.data.procs
-                       })
+      worker_hash.push(
+                           id: worker.data.id,
+                           ip: 'http://' + worker.data.ip,
+                           dns: worker.data.dns,
+                           procs: worker.data.procs
+                       )
     }
 
-    out = {:workers => worker_hash}
+    out = { workers: worker_hash }
     logger.info out
 
     out
@@ -434,27 +431,26 @@ class OpenStudioAwsWrapper
   # transform the available amis into an easier to read format
   def transform_ami_lists(existing, available)
     # initialize ami hash
-    amis = {:openstudio_server => {}, :openstudio => {}}
+    amis = { openstudio_server: {}, openstudio: {} }
     list_of_svs = []
 
     available[:images].each do |ami|
       sv = ami[:tags_hash][:openstudio_server_version]
 
-
-      if sv.nil? || sv == ""
-        puts "found nil version, incrementing from 0.0.1"
-        sv = get_next_version("0.0.1", list_of_svs)
+      if sv.nil? || sv == ''
+        puts 'found nil version, incrementing from 0.0.1'
+        sv = get_next_version('0.0.1', list_of_svs)
       end
       list_of_svs << sv
 
-      amis[:openstudio_server][sv.to_sym] = {} if !amis[:openstudio_server][sv.to_sym]
+      amis[:openstudio_server][sv.to_sym] = {} unless amis[:openstudio_server][sv.to_sym]
       a = amis[:openstudio_server][sv.to_sym]
 
       # initialize ami hash
-      a[:amis] = {} if !a[:amis]
+      a[:amis] = {} unless a[:amis]
 
       # fill in data (this will override data currently)
-      a[:deprecate] = true if sv.to_version.satisfies("0.0.*")
+      a[:deprecate] = true if sv.to_version.satisfies('0.0.*')
       a[:openstudio_version] = ami[:tags_hash][:openstudio_version] if ami[:tags_hash][:openstudio_version]
       a[:openstudio_version_sha] = ami[:tags_hash][:openstudio_version_sha] if ami[:tags_hash][:openstudio_version_sha]
       a[:user_uuid] = ami[:tags_hash][:user_uuid] if ami[:tags_hash][:user_uuid]
@@ -462,37 +458,37 @@ class OpenStudioAwsWrapper
       a[:created_on] = ami[:tags_hash][:created_on] if ami[:tags_hash][:created_on]
       a[:openstudio_server_version] = sv.to_s
       if ami[:tags_hash][:tested]
-        a[:tested] = ami[:tags_hash][:tested].downcase == "true"
+        a[:tested] = ami[:tags_hash][:tested].downcase == 'true'
       else
         a[:tested] = false
       end
 
       if ami[:name] =~ /Worker|Cluster/
-        if ami[:virtualization_type] == "paravirtual"
+        if ami[:virtualization_type] == 'paravirtual'
           a[:amis][:worker] = ami[:image_id]
-        elsif ami[:virtualization_type] == "hvm"
+        elsif ami[:virtualization_type] == 'hvm'
           a[:amis][:cc2worker] = ami[:image_id]
         else
-          raise "unknown virtualization_type in #{ami[:name]}"
+          fail "unknown virtualization_type in #{ami[:name]}"
         end
       elsif ami[:name] =~ /Server/
         a[:amis][:server] = ami[:image_id]
       end
     end
-    #puts "Current AMIs: #{JSON.pretty_generate(amis)}"
+    # puts "Current AMIs: #{JSON.pretty_generate(amis)}"
 
     # merge in the existing AMIs the existing amis into the 'unknown category, but don't flag them as 'deprecate'
-    #puts "Existing AMIs: #{JSON.pretty_generate(existing)}"
+    # puts "Existing AMIs: #{JSON.pretty_generate(existing)}"
     existing.keys.each do |ami_key|
-      next if ami_key == "default".to_sym # ignore default
+      next if ami_key == 'default'.to_sym # ignore default
 
       # get next version
-      next_version = get_next_version("0.0.1", list_of_svs)
+      next_version = get_next_version('0.0.1', list_of_svs)
       list_of_svs << next_version
 
-      amis[:openstudio_server][next_version.to_sym] = {} if !amis[:openstudio_server][next_version.to_sym]
+      amis[:openstudio_server][next_version.to_sym] = {} unless amis[:openstudio_server][next_version.to_sym]
       a = amis[:openstudio_server][next_version.to_sym]
-      a[:amis] = {} if !a[:amis]
+      a[:amis] = {} unless a[:amis]
 
       a[:openstudio_version] = ami_key
       a[:amis][:server] = existing[ami_key][:server]
@@ -501,18 +497,18 @@ class OpenStudioAwsWrapper
       a[:openstudio_server_version] = next_version.to_s
     end
 
-    #puts "After merge: #{JSON.pretty_generate(amis)}"
+    # puts "After merge: #{JSON.pretty_generate(amis)}"
     # flip these around for openstudio server section
     amis[:openstudio_server].keys.each do |key|
-      next if key.to_s.to_version.satisfies("0.0.*")
+      next if key.to_s.to_version.satisfies('0.0.*')
 
       a = amis[:openstudio_server][key]
       ov = a[:openstudio_version]
 
-      amis[:openstudio][ov] = {} if !amis[:openstudio][ov]
+      amis[:openstudio][ov] = {} unless amis[:openstudio][ov]
       osv = key
-      amis[:openstudio][ov][osv] = {} if !amis[:openstudio][ov][osv]
-      amis[:openstudio][ov][osv][:amis] = {} if !amis[:openstudio][ov][osv][:amis]
+      amis[:openstudio][ov][osv] = {} unless amis[:openstudio][ov][osv]
+      amis[:openstudio][ov][osv][:amis] = {} unless amis[:openstudio][ov][osv][:amis]
       amis[:openstudio][ov][osv][:amis][:server] = a[:amis][:server]
       amis[:openstudio][ov][osv][:amis][:worker] = a[:amis][:worker]
       amis[:openstudio][ov][osv][:amis][:cc2worker] = a[:amis][:cc2worker]
@@ -528,9 +524,8 @@ class OpenStudioAwsWrapper
     end
     amis[:openstudio] = Hash[amis[:openstudio].sort_by { |k, _| k.to_s.to_version }.reverse]
 
-    #puts "After sort: #{JSON.pretty_generate(amis)}"
+    # puts "After sort: #{JSON.pretty_generate(amis)}"
 
     amis
   end
-
 end