openstudio-aws 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05896fabcda97abcb347532edcfc7a177c498815
-  data.tar.gz: 920f0bd7ebe65eaede3f224555a04b8a177ef8dc
+  metadata.gz: 60c7a1fc72d71ce4c4dbc7d0ebfebdc54facedfc
+  data.tar.gz: 05a41b5ad8f6d1227f8ee7451ec933f1802a9941
 SHA512:
-  metadata.gz: 6cec51f927a1027f54fac563961a3df91286aa5c6490147187b091887594c9b27f144aa735b95ab72ad684a7d388a58e5c2715270da71ff7806b007c8e53e44b
-  data.tar.gz: ed92542a65387c426876960918dc7497600675aa5c9729ce1927e3262a6d5c52fa3f5861b4f2ae285744f861beeb3264883911eb96dccc1529f11c110b4896dd
+  metadata.gz: 51d1d6994dc81b161de452642efadbf30ca114af68d6073b9ee2baf1ca324d64e064de1944f4c9ccb87109f4824f718bd23fb8718b360933566646218061c364
+  data.tar.gz: aac1a5ddb1db0242725637c44889e48cb69e6e620a7287e0f95e461a06a7213a4edd3d03a19e79cae0c4b3c3dbc5f064fadf03ae8917480fec1d3a327e95a646

data/Rakefile

@@ -73,3 +73,13 @@ end
 
 desc 'reinstall the gem (uninstall, build, and reinstall'
 task reinstall: [:uninstall, :install]
+
+require 'rubocop/rake_task'
+desc 'Run RuboCop on the lib directory'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['--no-color', '--out=rubocop-results.xml']
+  task.formatters = ['RuboCop::Formatter::CheckstyleFormatter']
+  task.requires = ['rubocop/formatter/checkstyle_formatter']
+  # don't abort rake on failure
+  task.fail_on_error = false
+end

data/lib/openstudio-aws.rb

@@ -6,6 +6,7 @@ require 'logger'
 require 'securerandom'
 require 'semantic'
 require 'semantic/core_ext'
+require 'fileutils'
 
 # AWS SDK CORE
 begin

data/lib/openstudio/aws/aws.rb

@@ -27,7 +27,7 @@ module OpenStudio
           region: 'us-east-1',
           ssl_verify_peer: false,
           host: 'developer.nrel.gov',
-          url: '/downloads/buildings/openstudio/api',
+          url: '/downloads/buildings/openstudio/api'
         }
         options = defaults.merge(options)
 
@@ -98,6 +98,7 @@ module OpenStudio
           ebs_volume_id: nil,
           aws_key_pair_name: nil,
           private_key_file_name: nil, # required if using an existing "aws_key_pair_name"
+          tags: []
         }
         options = defaults.merge(options)
 
@@ -118,7 +119,7 @@ module OpenStudio
           @os_aws.save_private_key('ec2_server_key.pem')
         end
 
-        server_options = { user_id: options[:user_id] }
+        server_options = { user_id: options[:user_id], tags: options[:tags] }
         # if instance_data[:ebs_volume_id]
         #   server_options[:ebs_volume_id] = instance_data[:ebs_volume_id]
         # end
@@ -135,17 +136,18 @@ module OpenStudio
         puts "ssh -i #{@os_aws.private_key_file_name} ubuntu@#{@os_aws.server.data[:dns]}"
       end
 
-      def create_workers(number_of_instances, options = {}, _user_id = 'unknown_user')
+      def create_workers(number_of_instances, options = {}, user_id = 'unknown_user')
         defaults = {
           instance_type: 'm2.4xlarge',
           security_group: 'openstudio-server-sg-v1',
           image_id: @default_amis[:server],
-          user_id: 'unknown_user',
+          user_id: user_id,
 
           # optional -- will default later
           ebs_volume_id: nil,
           aws_key_pair_name: nil,
-          private_key_file_name: nil, # required if using an existing "aws_key_pair_name"
+          private_key_file_name: nil, # required if using an existing "aws_key_pair_name",
+          tags: []
         }
         options = defaults.merge(options)
 
@@ -160,34 +162,39 @@ module OpenStudio
 
         fail "Can't create workers without a server instance running" if @os_aws.server.nil?
 
-        worker_options = { user_id: options[:user_id] }
-        # if options[:ebs_volume_size]
-        #   worker_options[:ebs_volume_size] = options[:ebs_volume_size]
-        # end
-
-        @os_aws.launch_workers(options[:image_id], options[:instance_type], number_of_instances, worker_options)
-
-        ## append the information to the server_data hash that already exists
-        # @server_data[:instance_type] = instance_data[:instance_type]
-        # @server_data[:num] = number_of_instances
-        # server_string = @server_data.to_json.gsub("\"", "\\\\\"")
-        #
-        # start_string = "ruby #{os_aws_file_location} #{@config.access_key} #{@config.secret_key} us-east-1 EC2 launch_workers \"#{server_string}\""
-        # puts "Worker Command: #{start_string}"
-        # worker_data_string = `#{start_string}`
-        # @worker_data = JSON.parse(worker_data_string, :symbolize_names => true)
-        # File.open("worker_data.json", "w") { |f| f << JSON.pretty_generate(worker_data) }
-        #
-        ## Print out some debugging commands (probably work on mac/linux only)
-        # Add the worker data to the JSON
-        h = JSON.parse(File.read(@instances_json))
-        h[:workers] = @os_aws.to_os_worker_hash[:workers]
-        File.open(@instances_json, 'w') { |f| f << JSON.pretty_generate(h) }
-
-        puts ''
-        puts 'Worker SSH Command:'
-        @os_aws.workers.each do |worker|
-          puts "ssh -i #{@os_aws.private_key_file_name} ubuntu@#{worker.data[:dns]}"
+        if number_of_instances == 0
+          puts ''
+          puts 'No workers requested'
+        else
+          worker_options = { user_id: options[:user_id], tags: options[:tags] }
+          # if options[:ebs_volume_size]
+          #   worker_options[:ebs_volume_size] = options[:ebs_volume_size]
+          # end
+
+          @os_aws.launch_workers(options[:image_id], options[:instance_type], number_of_instances, worker_options)
+
+          ## append the information to the server_data hash that already exists
+          # @server_data[:instance_type] = instance_data[:instance_type]
+          # @server_data[:num] = number_of_instances
+          # server_string = @server_data.to_json.gsub("\"", "\\\\\"")
+          #
+          # start_string = "ruby #{os_aws_file_location} #{@config.access_key} #{@config.secret_key} us-east-1 EC2 launch_workers \"#{server_string}\""
+          # puts "Worker Command: #{start_string}"
+          # worker_data_string = `#{start_string}`
+          # @worker_data = JSON.parse(worker_data_string, :symbolize_names => true)
+          # File.open("worker_data.json", "w") { |f| f << JSON.pretty_generate(worker_data) }
+          #
+          ## Print out some debugging commands (probably work on mac/linux only)
+          # Add the worker data to the JSON
+          h = JSON.parse(File.read(@instances_json))
+          h[:workers] = @os_aws.to_os_worker_hash[:workers]
+          File.open(@instances_json, 'w') { |f| f << JSON.pretty_generate(h) }
+
+          puts ''
+          puts 'Worker SSH Command:'
+          @os_aws.workers.each do |worker|
+            puts "ssh -i #{@os_aws.private_key_file_name} ubuntu@#{worker.data[:dns]}"
+          end
         end
 
         puts ''
@@ -206,7 +213,7 @@ module OpenStudio
         resp
       end
 
-      # @params(ids): array of instances
+      # @params(ids): array of instance ids
       def terminate_instances(ids)
         puts "Terminating the following instances #{ids}"
         resp = []

data/lib/openstudio/aws/version.rb

@@ -1,5 +1,5 @@
 module OpenStudio
   module Aws
-    VERSION = '0.2.3'
+    VERSION = '0.2.4'
   end
 end

data/lib/openstudio/lib/openstudio_aws_instance.rb

@@ -26,7 +26,8 @@ class OpenStudioAwsInstance
   attr_reader :private_key_file_name
   attr_reader :group_uuid
 
-  def initialize(aws_session, openstudio_instance_type, key_pair_name, security_group_name, group_uuid, private_key, private_key_file_name, proxy = nil, _options = {})
+  def initialize(aws_session, openstudio_instance_type, key_pair_name, security_group_name, group_uuid, private_key,
+                 private_key_file_name, proxy = nil)
     @data = nil # stored information about the instance
     @aws = aws_session
     @openstudio_instance_type = openstudio_instance_type # :server, :worker
@@ -56,9 +57,8 @@ class OpenStudioAwsInstance
 
     # get the instance information
     test_result = @aws.describe_volumes(volume_ids: [resp[:volume_id]])
-    puts test_result
     begin
-      Timeout.timeout(600) { # 10 minutes
+      Timeout.timeout(600) do # 10 minutes
         while test_result.nil? || test_result.instance_state.name != 'available'
           # refresh the server instance information
 
@@ -66,7 +66,7 @@ class OpenStudioAwsInstance
           test_result = @aws.describe_volumes(volume_ids: [resp[:volume_id]])
           logger.info '... waiting for EBS volume to be available ...'
         end
-      }
+      end
     rescue TimeoutError
       raise "EBS volume was unable to be created due to timeout #{instance_id}"
     end
@@ -87,7 +87,7 @@ class OpenStudioAwsInstance
     # true?
   end
 
-  def launch_instance(image_id, instance_type, user_data, user_id, ebs_volume_size = nil)
+  def launch_instance(image_id, instance_type, user_data, user_id, options = {})
     # logger.info("user_data #{user_data.inspect}")
     instance = {
       image_id: image_id,
@@ -106,23 +106,43 @@ class OpenStudioAwsInstance
     # determine how many processors are suppose to be in this image (lookup for now?)
     processors = find_processors(instance_type)
 
+    # create the tag structure
+    aws_tags = [
+      { key: 'Name', value: "OpenStudio-#{@openstudio_instance_type.capitalize}" },
+      { key: 'GroupUUID', value: @group_uuid },
+      { key: 'NumberOfProcessors', value: processors.to_s },
+      { key: 'Purpose', value: "OpenStudio#{@openstudio_instance_type.capitalize}" },
+      { key: 'UserID', value: user_id }
+    ]
+
+    # add in any manual tags
+    options[:tags].each do |tag|
+      t = tag.split('=')
+      if t.size != 2
+        logger.error "Tag '#{t}' not defined or does not have an equal sign"
+        puts "Tag '#{t}' not defined or does not have an equal sign"
+        next
+      end
+      if %w(Name GroupUUID NumberOfProcessors Purpose UserID).include? t[0]
+        logger.error "Tag name '#{t[0]}' is a reserved tag"
+        puts "Tag name '#{t[0]}' is a reserved tag"
+        next
+      end
+
+      aws_tags << { key: t[0].strip, value: t[1].strip }
+    end
+
     # only asked for 1 instance, so therefore it should be the first
     aws_instance = result.data.instances.first
     @aws.create_tags(
         resources: [aws_instance.instance_id],
-        tags: [
-          { key: 'Name', value: "OpenStudio-#{@openstudio_instance_type.capitalize}" }, # todo: abstract out the server and version
-          { key: 'GroupUUID', value: @group_uuid },
-          { key: 'NumberOfProcessors', value: processors.to_s },
-          { key: 'Purpose', value: "OpenStudio#{@openstudio_instance_type.capitalize}" },
-          { key: 'UserID', value: user_id }
-        ]
+        tags: aws_tags
     )
 
     # get the instance information
     test_result = @aws.describe_instance_status(instance_ids: [aws_instance.instance_id]).data.instance_statuses.first
     begin
-      Timeout.timeout(600) { # 10 minutes
+      Timeout.timeout(600) do # 10 minutes
         while test_result.nil? || test_result.instance_state.name != 'running'
           # refresh the server instance information
 
@@ -130,13 +150,13 @@ class OpenStudioAwsInstance
           test_result = @aws.describe_instance_status(instance_ids: [aws_instance.instance_id]).data.instance_statuses.first
           logger.info '... waiting for instance to be running ...'
         end
-      }
+      end
     rescue TimeoutError
       raise "Instance was unable to launch due to timeout #{aws_instance.instance_id}"
     end
 
-    if ebs_volume_size
-      create_and_attach_volume(ebs_volume_size, aws_instance.instance_id, aws_instance.placement.availability_zone)
+    if options[:ebs_volume_size]
+      create_and_attach_volume(options[:ebs_volume_size], aws_instance.instance_id, aws_instance.placement.availability_zone)
     end
 
     # now grab information about the instance
@@ -201,7 +221,7 @@ class OpenStudioAwsInstance
       't1.micro' => 1,
       'm1.small' => 1,
       'm2.2xlarge' => 4,
-      'm2.4xlarge' => 8,
+      'm2.4xlarge' => 8
     }
 
     processors = 1

data/lib/openstudio/lib/openstudio_aws_wrapper.rb

@@ -149,11 +149,11 @@ class OpenStudioAwsWrapper
           if group_uuid && openstudio_instance_type
             # {:key=>"Purpose", :value=>"OpenStudioWorker"}
             if i_h[:tags].any? { |h| (h[:key] == 'Purpose') && (h[:value] == "OpenStudio#{openstudio_instance_type.capitalize}") } &&
-                      i_h[:tags].any? { |h|(h[:key] == 'GroupUUID') && (h[:value] == group_uuid.to_s) }
+                i_h[:tags].any? { |h| (h[:key] == 'GroupUUID') && (h[:value] == group_uuid.to_s) }
               instance_data << i_h
             end
           elsif group_uuid
-            if i_h[:tags].any? { |h|(h[:key] == 'GroupUUID') && (h[:value] == group_uuid.to_s) }
+            if i_h[:tags].any? { |h| (h[:key] == 'GroupUUID') && (h[:value] == group_uuid.to_s) }
               instance_data << i_h
             end
           elsif openstudio_instance_type
@@ -218,13 +218,13 @@ class OpenStudioAwsWrapper
   def terminate_instances(ids)
     begin
       resp = @aws.terminate_instances(
-          instance_ids: ids,
+          instance_ids: ids
       )
     rescue Aws::EC2::Errors::InvalidInstanceIDNotFound
       # Log that the instances couldn't be found?
-      return resp = {error: 'instances could not be found'}
+      return resp = { error: 'instances could not be found' }
     end
-      
+
     resp
   end
 
@@ -275,23 +275,24 @@ class OpenStudioAwsWrapper
     end
   end
 
-  def launch_server(image_id, instance_type, options = {})
-    defaults = { user_id: 'unknown_user' }
-    options = defaults.merge(options)
+  def launch_server(image_id, instance_type, launch_options = {})
+    defaults = { user_id: 'unknown_user', tags: [], ebs_volume_size: nil }
+    launch_options = defaults.merge(launch_options)
 
     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, @private_key_file_name, @proxy)
+    @server = OpenStudioAwsInstance.new(@aws, :server, @key_pair_name, @security_group_name, @group_uuid, @private_key,
+                                        @private_key_file_name, @proxy)
 
     # create the EBS volumes instead of the ephemeral storage - needed especially for the m3 instances (SSD)
 
     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], options[:ebs_volume_size])
+    @server.launch_instance(image_id, instance_type, user_data, launch_options[:user_id], launch_options)
   end
 
-  def launch_workers(image_id, instance_type, num, options = {})
-    defaults = { user_id: 'unknown_user' }
-    options = defaults.merge(options)
+  def launch_workers(image_id, instance_type, num, launch_options = {})
+    defaults = { user_id: 'unknown_user', tags: [], ebs_volume_size: nil }
+    launch_options = defaults.merge(launch_options)
 
     user_data = File.read(File.expand_path(File.dirname(__FILE__)) + '/worker_script.sh.template')
     user_data.gsub!(/SERVER_IP/, @server.data.ip)
@@ -302,17 +303,18 @@ class OpenStudioAwsWrapper
     # thread the launching of the workers
 
     num.times do
-      @workers << OpenStudioAwsInstance.new(@aws, :worker, @key_pair_name, @security_group_name, @group_uuid, @private_key, @private_key_file_name, @proxy)
+      @workers << OpenStudioAwsInstance.new(@aws, :worker, @key_pair_name, @security_group_name, @group_uuid,
+                                            @private_key, @private_key_file_name, @proxy)
     end
 
     threads = []
     @workers.each do |worker|
       threads << Thread.new do
         # create the EBS volumes instead of the ephemeral storage - needed especially for the m3 instances (SSD)
-        worker.launch_instance(image_id, instance_type, user_data, options[:user_id], options[:ebs_volume_size])
+        worker.launch_instance(image_id, instance_type, user_data, launch_options[:user_id], launch_options)
       end
     end
-    threads.each { |t| t.join }
+    threads.each(&:join)
 
     # todo: do we need to have a flag if the worker node is successful?
     # todo: do we need to check the current list of running workers?
@@ -350,7 +352,8 @@ class OpenStudioAwsWrapper
     @server.shell_command('chmod 664 /mnt/openstudio/rails-models/mongoid.yml')
     @workers.each { |worker| worker.shell_command('chmod 664 /mnt/openstudio/rails-models/mongoid.yml') }
 
-    sleep 60 # wait 60 more seconds for everything -- this is cheesy
+    # I'm removing this as of 10/6/14. This should have been resolved by now.
+    # sleep 60 # wait 60 more seconds for everything -- this is cheesy
     true
   end
 
@@ -499,16 +502,26 @@ class OpenStudioAwsWrapper
         a[:tested] = false
       end
 
-      if ami[:name] =~ /Worker|Cluster/
-        if ami[:virtualization_type] == 'paravirtual'
+      # TODO: in 1.6.0 just stop putting in the cc2workers.
+      if ami[:tags_hash][:openstudio_version].to_version >= '1.5.0'
+        if ami[:name] =~ /Server/
+          a[:amis][:server] = ami[:image_id]
+        elsif ami[:name] =~ /Worker/
           a[:amis][:worker] = ami[:image_id]
-        elsif ami[:virtualization_type] == 'hvm'
           a[:amis][:cc2worker] = ami[:image_id]
-        else
-          fail "unknown virtualization_type in #{ami[:name]}"
         end
-      elsif ami[:name] =~ /Server/
-        a[:amis][:server] = ami[:image_id]
+      else
+        if ami[:name] =~ /Worker|Cluster/
+          if ami[:virtualization_type] == 'paravirtual'
+            a[:amis][:worker] = ami[:image_id]
+          elsif ami[:virtualization_type] == 'hvm'
+            a[:amis][:cc2worker] = ami[:image_id]
+          else
+            fail "unknown virtualization_type in #{ami[:name]}"
+          end
+        elsif ami[:name] =~ /Server/
+          a[:amis][:server] = ami[:image_id]
+        end
       end
     end
     # puts "Current AMIs: #{JSON.pretty_generate(amis)}"
@@ -522,7 +535,7 @@ class OpenStudioAwsWrapper
       next_version = get_next_version('0.0.1', list_of_svs)
       list_of_svs << next_version
 
-      amis[:openstudio_server][next_version.to_sym] = {} unless amis[:openstudio_server][next_version.to_sym]
+      amis[:openstudio_server][next_version.to_sym] ||= {}
       a = amis[:openstudio_server][next_version.to_sym]
       a[:amis] = {} unless a[:amis]
 
@@ -541,10 +554,10 @@ class OpenStudioAwsWrapper
       a = amis[:openstudio_server][key]
       ov = a[:openstudio_version]
 
-      amis[:openstudio][ov] = {} unless amis[:openstudio][ov]
+      amis[:openstudio][ov] ||= {}
       osv = key
-      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[: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]

data/spec/aws_instances/aws_spec_api.rb

@@ -10,11 +10,11 @@ describe OpenStudio::Aws::Aws do
     end
 
     it 'should create a new instance' do
-      @aws.should_not be_nil
+      expect(@aws).to be_nil
     end
 
     it 'should create a server' do
-      options = { instance_type: 'm1.small', image_id: 'ami-29faca40' }
+      options = { instance_type: 'm3.medium', image_id: 'ami-3c0fbf54' }
 
       test_pem_file = 'ec2_server_key.pem'
       FileUtils.rm_f test_pem_file if File.exist? test_pem_file
@@ -26,32 +26,31 @@ describe OpenStudio::Aws::Aws do
       expect(File.exist?('server_data.json')).to be true
       expect(@aws.os_aws.server).not_to be_nil
 
-      h = @os_aws.server.to_os_hash
+      h = @aws.os_aws.server.to_os_hash
       expect(h[:group_id]).to be_a String
-      expect(h[:group_id]).to match /^\d{10}$/
-      expect(h[:location]).to be 'AWS'
+      expect(h[:group_id]).to match /^[\d\S]{32}$/
+      expect(h[:location]).to eq 'AWS'
 
       @group_id = h[:group_id]
-
     end
 
     it 'should create a 1 worker' do
-      options = { instance_type: 'm1.small', image_id: 'ami-95f9c9fc' }
+      options = { instance_type: 'm3.medium', image_id: 'ami-040ebe6c' }
 
       @aws.create_workers(1, options)
 
-      expect(@aws.os_aws.workers).to have(1).thing
+      expect(@aws.os_aws.workers.size).to eq 1
       expect(@aws.os_aws.workers[0].data[:dns]).not_to be_nil
     end
 
     it 'should be able to connect a worker to an existing server' do
-      options = { instance_type: 'm1.small', image_id: 'ami-29faca40' }
+      options = { instance_type: 'm3.medium', image_id: 'ami-3c0fbf54' }
 
       # will require a new @aws class--but attached to same group_uuid
       @config = OpenStudio::Aws::Config.new
       @aws_2 = OpenStudio::Aws::Aws.new
 
-      @aws_2.os_aws.find_server(@aws.os_aws.group_uuid)
+      @aws_2.os_aws.find_server(@aws.os_aws.server.to_os_hash)
 
       expect(@aws.os_aws.server).not_to be_nil
     end
@@ -70,7 +69,7 @@ describe OpenStudio::Aws::Aws do
       config = OpenStudio::Aws::Config.new
       aws = OpenStudio::Aws::Aws.new
 
-      options = { instance_type: 'm1.small', image_id: 'ami-29faca40' }
+      options = { instance_type: 'm3.medium', image_id: 'ami-3c0fbf54' }
 
       aws.create_server(options)
     end
@@ -81,26 +80,26 @@ describe OpenStudio::Aws::Aws do
       j = JSON.parse(File.read('server_data.json'), symbolize_names: true)
 
       config = OpenStudio::Aws::Config.new
-      aws = OpenStudio::Aws::Aws.new
+      aws2 = OpenStudio::Aws::Aws.new
 
-      aws.load_instance_info_from_file('server_data.json')
+      aws2.load_instance_info_from_file('server_data.json')
 
-      expect(aws.os_aws.server.group_uuid).to eq j[:group_id]
-      puts aws.os_aws.server.inspect
+      expect(aws2.os_aws.server.group_uuid).to eq j[:group_id]
+      puts aws2.os_aws.server.inspect
 
       local_file = File.expand_path('spec/resources/upload_me.sh')
       remote_file = '/home/ubuntu/i_uploaded_this_file.sh'
 
-      aws.upload_file(:server, local_file, remote_file)
+      aws2.upload_file(:server, local_file, remote_file)
 
-      aws.shell_command(:server, "source #{remote_file}")
+      aws2.shell_command(:server, "source #{remote_file}")
 
       FileUtils.rm_f 'success.receipt' if File.exist? 'success.receipt'
-      aws.download_remote_file(:server, '/home/ubuntu/success.receipt', 'success.receipt')
+      aws2.download_remote_file(:server, '/home/ubuntu/success.receipt', 'success.receipt')
       expect(File.exist?('success.receipt')).to be true
 
       FileUtils.rm_f 'gemlist.receipt' if File.exist? 'gemlist.receipt'
-      aws.download_remote_file(:server, '/home/ubuntu/gemlist.receipt', 'gemlist.receipt')
+      aws2.download_remote_file(:server, '/home/ubuntu/gemlist.receipt', 'gemlist.receipt')
       expect(File.exist?('gemlist.receipt')).to be true
       gemlist = File.read('gemlist.receipt')
       expect(gemlist).to match /^s3 \(.*\)$/
@@ -121,6 +120,94 @@ describe OpenStudio::Aws::Aws do
     end
   end
 
+  context 'create aws tags' do
+    before(:all) do
+      @config = OpenStudio::Aws::Config.new
+      @aws = OpenStudio::Aws::Aws.new
+
+      @group_id = nil
+    end
+
+    it 'should create a server with tags' do
+      begin
+        options = {
+          instance_type: 'm3.medium',
+          image_id: 'ami-3c0fbf54',
+          tags: [
+            'ci_tests=true',
+            'nothing=else',
+            'this=is the end    ',
+            'this=   is the beginning   '
+          ]
+        }
+
+        test_pem_file = 'ec2_server_key.pem'
+        FileUtils.rm_f test_pem_file if File.exist? test_pem_file
+        FileUtils.rm_f 'server_data.json' if File.exist? 'server_data.json'
+
+        @aws.create_server(options)
+
+        expect(File.exist?('ec2_server_key.pem')).to be true
+        expect(File.exist?('server_data.json')).to be true
+        expect(@aws.os_aws.server).not_to be_nil
+
+        h = @aws.os_aws.server.to_os_hash
+        expect(h[:group_id]).to be_a String
+        expect(h[:group_id]).to match /^[\d\S]{32}$/
+        expect(h[:location]).to eq 'AWS'
+
+        puts h.inspect
+
+        @group_id = h[:group_id]
+      ensure
+        @aws.terminate_instances_by_group_id(h[:group_id], :server)
+      end
+
+    end
+  end
+
+  context 'server only' do
+    before(:all) do
+      @config = OpenStudio::Aws::Config.new
+      @aws = OpenStudio::Aws::Aws.new
+
+      @group_id = nil
+    end
+
+    it 'should create allow a zero length worker' do
+      begin
+        begin
+          options = {
+            instance_type: 'm3.medium',
+            image_id: 'ami-3c0fbf54', # server AMI
+            tags: [
+              'ci_tests=true',
+              'ServerOnly=true'
+            ]
+          }
+
+          expect { @aws.create_workers(0) }.to raise_error "Can't create workers without a server instance running"
+
+          test_pem_file = 'ec2_server_key.pem'
+          FileUtils.rm_f test_pem_file if File.exist? test_pem_file
+          FileUtils.rm_f 'server_data.json' if File.exist? 'server_data.json'
+
+          @aws.create_server(options)
+
+          # Still have to call "create workers" or the configuration won't happen.
+          @aws.create_workers(0, options)
+
+          h = @aws.os_aws.server.to_os_hash
+          expect(h[:group_id]).to be_a String
+          expect(h[:group_id]).to match /^[\d\S]{32}$/
+          expect(h[:location]).to eq 'AWS'
+        ensure
+          @aws.terminate_instances_by_group_id(h[:group_id], :server)
+        end
+      end
+    end
+  end
+
   # context 'create ebs storage' do
   #   before(:all) do
   #     @aws = OpenStudio::Aws::Aws.new