openstudio-aws 0.1.13 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09422f52cf5335909cdd51b4c434a08427483560
-  data.tar.gz: d2e3c74b74a510bb1b4c9fa4f971c835316a48a7
+  metadata.gz: c999ae868853c9646c3e8ca5d7cd30a757256e95
+  data.tar.gz: 031ffc958eee37bc0ed1b09574e6af924d76ef52
 SHA512:
-  metadata.gz: 16eea5517088408b78c3f24c287b8658f7f00ecc5c3a40e511070e43ea23da04ac46a63f4764f0d8283cb2de29f546c7062f60d16f5a9b66e366be0fe7a7c72d
-  data.tar.gz: 23b80ec6b869b088fdf7f864a237461537b98e0ecd325e952b33ab3e40e37952719eee1d57233a368b1f84817d6e13f742f6b726073b397f8e76d3f0bba1bf7e
+  metadata.gz: 1b9349832295aa0587313d84520d4c81f9bb08f60f4e12863347dd14576f9682a348ba1493c2188552a15e57111b0415cb4cc67ad35a5231e24edb3c313a40b1
+  data.tar.gz: 9554df0d318b4edf1658a18b13d8575ae76aedc79fac926ed3e0a47427b5eecb33db85d153d4ca37d1e725c0f0938bec37c74bda52110b77cd1727a45db0b385

data/lib/openstudio/aws/aws.rb

@@ -1,15 +1,56 @@
 # This class is a wrapper around the command line version that is in the OpenStudio repository.
 module OpenStudio
   module Aws
+    VALID_OPTIONS = [
+        :proxy, :credentials
+    ]
+
     class Aws
       attr_reader :os_aws
 
-      def initialize()
+      # default constructor to create the AWS class that can spin up server and worker instances.
+      # options are optional with the following support:
+      #   credentials => {:access_key_id, :secret_access_key, :region, :ssl_verify_peer}
+      #   proxy => {:host => "192.168.0.1", :port => "8808", :username => "user", :password => "password"}}
+      def initialize(options = {})
+        invalid_options = options.keys - VALID_OPTIONS
+        if invalid_options.any?
+          raise ArgumentError, "invalid option(s): #{invalid_options.join(', ')}"
+        end
+
         # read in the config.yml file to get the secret/private key
-        @config = OpenStudio::Aws::Config.new()
+        if !options[:credentials] 
+          config_file = OpenStudio::Aws::Config.new()
+
+          # populate the credentials
+          options = {
+              :credentials =>
+                  {
+                      :access_key_id => config_file.access_key,
+                      :secret_access_key => config_file.secret_key,
+                      :region => "us-east-1",  #todo: move this to a default
+                      :ssl_verify_peer => false
+                  }
+          }
+        end
+
+        if options[:proxy]
+          proxy_uri = nil
+          if options[:proxy][:username]
+            proxy_uri = "https://#{options[:proxy][:username]}:#{options[:proxy][:password]}@#{options[:proxy][:host]}:#{options[:proxy][:port]}"
+          else
+            proxy_uri = "https://#{options[:proxy][:host]}:#{options[:proxy][:port]}"
+          end
+          # todo: remove this proxy_uri and make a method to format correctly
+          options[:proxy_uri] = proxy_uri
 
-        config = {:access_key_id => @config.access_key, :secret_access_key => @config.secret_key, :region => "us-east-1", :ssl_verify_peer => false}
-        @os_aws = OpenStudioAwsWrapper.new(config)
+          #todo: do we need to escape a couple of the argument of username and password
+          
+          #todo: set some environment variables for system based proxy
+          
+        end
+
+        @os_aws = OpenStudioAwsWrapper.new(options)
         @local_key_file_name = nil
 
         # this will grab the default version of openstudio ami versions
@@ -30,26 +71,6 @@ module OpenStudio
 
         puts @os_aws.server.to_os_hash.to_json
 
-        # Call the openstudio script to start the ec2 instance 
-        #start_string = "ruby #{os_aws_file_location} #{@config.access_key} #{@config.secret_key} us-east-1 EC2 launch_server \"#{instance_string}\""
-        #puts "Server Command: #{start_string}"
-        #server_data_str = `#{start_string}`
-        #@server_data = JSON.parse(server_data_str, :symbolize_names => true)
-
-        # Save pieces of the data for passing to the worker node
-
-        #File.open(server_key_file, "w") { |f| f << @server_data[:private_key] }
-        #File.chmod(0600, server_key_file)
-
-        # Save off the server data to be loaded into the worker nodes.  The Private key needs to e read from a
-        # file in the worker node, so save that name instead in the HASH along with a couple other changes
-        #@server_data[:private_key] = server_key_file
-        #if @server_data[:server]
-        #  @server_data[:server_id] = @server_data[:server][:id]
-        #  @server_data[:server_ip] = @server_data[:server][:ip]
-        #  @server_data[:server_dns] = @server_data[:server][:dns]
-        #end
-
         File.open(server_json_filename, "w") { |f| f << JSON.pretty_generate(@os_aws.server.to_os_hash) }
 
         # Print out some debugging commands (probably work on mac/linux only)

data/lib/openstudio/aws/version.rb

@@ -1,6 +1,6 @@
 module OpenStudio
   module Aws
-    VERSION = "0.1.13"
+    VERSION = "0.1.14"
     OPENSTUDIO_VERSION = "1.2.1"
   end
 end

data/lib/openstudio/lib/ami_list.rb

@@ -24,8 +24,8 @@ class OpenStudioAmis
 
   def initialize(version = 1, openstudio_version = 'default', openstudio_server_version = 'default')
     @version = 1
-    @openstudio_version = openstudio_version
-    @openstudio_server_version = openstudio_server_version
+    @openstudio_version = openstudio_version.to_sym
+    @openstudio_server_version = openstudio_server_version.to_sym
   end
 
   def list
@@ -85,12 +85,14 @@ class OpenStudioAmis
   end
 
   private
+  
+  
 
   def retrieve_json(endpoint)
     result = nil
     resp = Net::HTTP.get_response('developer.nrel.gov', endpoint)
     if resp.code == '200'
-      result = JSON.parse(resp.body)
+      result = JSON.parse(resp.body, :symbolize_names => true)
     else
       raise "#{resp.code} Unable to download AMI IDs"
     end

data/lib/openstudio/lib/openstudio_aws_instance.rb

@@ -22,6 +22,7 @@ require 'securerandom'
 require_relative 'openstudio_aws_logger'
 require_relative 'openstudio_aws_methods'
 
+
 class OpenStudioAwsInstance
   include Logging
   include OpenStudioAwsMethods
@@ -29,7 +30,7 @@ class OpenStudioAwsInstance
   attr_reader :openstudio_instance_type
   attr_reader :data
 
-  def initialize(aws_session, openstudio_instance_type, key_pair_name, security_group_name, group_uuid, private_key)
+  def initialize(aws_session, openstudio_instance_type, key_pair_name, security_group_name, group_uuid, private_key, proxy = nil, options = {})
     @data = nil # stored information about the instance
     @aws = aws_session
     @openstudio_instance_type = openstudio_instance_type # :server, :worker
@@ -37,9 +38,9 @@ class OpenStudioAwsInstance
     @security_group_name = security_group_name
     @group_uuid = group_uuid.to_s
     @private_key = private_key
+    @proxy = proxy 
   end
 
-
   def launch_instance(image_id, instance_type, user_data)
     #logger.info("user_data #{user_data.inspect}")
     instance = {

data/lib/openstudio/lib/openstudio_aws_methods.rb

@@ -30,10 +30,11 @@
 #  Member Variables:
 #    private_key : the in memory private key
 #    logger : logger class in which to write log messages
-# 
+#    @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.xlarge" => 4,
@@ -71,11 +72,24 @@ module OpenStudioAwsMethods
     processors
   end
 
-
+  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])
+      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', :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
@@ -98,7 +112,7 @@ module OpenStudioAwsMethods
     #retries = 0
     begin
       output = ''
-      Net::SSH.start(host, 'ubuntu', :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?
       end
@@ -124,13 +138,13 @@ module OpenStudioAwsMethods
     end
   end
 
-#======================= send command ======================#
-# Send a command through SSH Shell to an instance.
-# Need to pass instance object and the command as a string.
+  #======================= 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', :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
@@ -167,7 +181,7 @@ module OpenStudioAwsMethods
       flag = 0
       while flag == 0 do
         @logger.info("wait_command #{command}")
-        Net::SSH.start(host, 'ubuntu', :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
@@ -205,7 +219,7 @@ module OpenStudioAwsMethods
     rescue SystemCallError, Timeout::Error => e
       # port 22 might not be available immediately after the instance finishes launching
       sleep 5
-      @logger.info("Not Yet")
+      @logger.info("Timeout.  Perhaps there is a communication error to EC2?  Will try again")
       retry
     end
   end
@@ -213,7 +227,7 @@ module OpenStudioAwsMethods
   def download_file(host, remote_path, local_path)
     retries = 0
     begin
-      Net::SCP.start(host, 'ubuntu', :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

@@ -41,13 +41,19 @@ require_relative 'openstudio_aws_logger'
 class OpenStudioAwsWrapper
   include Logging
 
-  attr_reader :group_uuid               
+  attr_reader :group_uuid
   attr_reader :security_group_name
   attr_reader :key_pair_name
   attr_reader :server
   attr_reader :workers
+  attr_reader :proxy
 
-  def initialize(credentials = nil, group_uuid = nil)
+  # todo: put this into a module
+  VALID_OPTIONS = [
+      :proxy, :credentials
+  ]
+
+  def initialize(options = {}, group_uuid = nil)
     @group_uuid = group_uuid || Time.now.to_i.to_s
 
     @security_group_name = nil
@@ -56,10 +62,11 @@ class OpenStudioAwsWrapper
     @server = nil
     @workers = []
 
-    # If you already set the credentials in another script in memory, then you won't have to do it here, but
-    # it won't hurt if you do
-    Aws.config = credentials if credentials
-    @aws = Aws::EC2.new
+    # store an instance variable with the proxy for passing to instances for use in scp/ssh
+    @proxy = options[:proxy] ? options[:proxy] : nil
+
+    # need to remove the prxoy information here
+    @aws = Aws::EC2.new(options[:credentials])
   end
 
   def create_or_retrieve_security_group(sg_name = nil)
@@ -160,6 +167,42 @@ class OpenStudioAwsWrapper
     instance_data
   end
 
+  def describe_amis(filter = nil, image_ids = [], owned_by_me = true)
+    resp = nil
+
+    # 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
+      else
+        resp = @aws.describe_images({:owners => [:self]}).data
+      end
+    else
+      if filter
+        resp = @aws.describe_images({:filter => filter}).data
+      else
+        resp = @aws.describe_images({:image_ids => image_ids}).data
+      end
+    end
+
+    resp = resp.to_hash
+
+    # map the tags to hashes
+    resp[:images].each do |image|
+      image[:tags_hash] = {}
+      image[:tags_hash][:tags] = []
+      image[:tags].each do |tag|
+        if tag[:value]
+          image[:tags_hash][tag[:key].to_sym] = tag[:value]
+        else
+          image[:tags_hash][:tags] << tag[:key]
+        end
+      end
+    end
+
+    resp
+  end
+
   def create_or_retrieve_key_pair(key_pair_name = nil, private_key_file = nil)
     tmp_name = key_pair_name || "os-key-pair-#{@group_uuid}"
 
@@ -170,21 +213,21 @@ class OpenStudioAwsWrapper
       raise "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  
-    
+    end
+
     if resp.nil? || resp.key_pairs.size == 0
       # 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})
-      
+
       # save the private key to memory (which can later be persisted via the save_private_key method)
       @private_key = keypair.data.key_material
       @key_pair_name = keypair.data.key_name
     else
       logger.info "found existing keypair #{resp.key_pairs.first}"
       @key_pair_name = resp.key_pairs.first[:key_name]
-      
+
       if File.exists(private_key_file)
         @private_key = File.read(private_key_file, 'r')
       else
@@ -192,7 +235,7 @@ class OpenStudioAwsWrapper
         logger.error "Could not find the private key file to load from #{private_key_file}"
       end
     end
-    
+
     logger.info("create key pair: #{@key_pair_name}")
   end
 
@@ -202,13 +245,13 @@ class OpenStudioAwsWrapper
       File.chmod(0600, filename)
     else
       logger.error "no private key found in which to persist"
-    end  
+    end
   end
 
   def launch_server(image_id, instance_type)
     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)
-    
+    @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
     @server.launch_instance(image_id, instance_type, user_data)
@@ -220,11 +263,11 @@ class OpenStudioAwsWrapper
     user_data.gsub!(/SERVER_HOSTNAME/, 'master')
     user_data.gsub!(/SERVER_ALIAS/, '')
     logger.info("worker user_data #{user_data.inspect}")
-    
+
     # thread the launching of the workers
-    
+
     num.times do
-      @workers << OpenStudioAwsInstance.new(@aws, :worker, @key_pair_name, @security_group_name, @group_uuid, @private_key)
+      @workers << OpenStudioAwsInstance.new(@aws, :worker, @key_pair_name, @security_group_name, @group_uuid, @private_key, @proxy)
     end
 
     threads = []
@@ -238,7 +281,7 @@ class OpenStudioAwsWrapper
     # 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?
   end
-  
+
   # 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
@@ -251,7 +294,7 @@ class OpenStudioAwsWrapper
     ips = "master|#{@server.data.ip}|#{@server.data.dns}|#{@server.data.procs}|ubuntu|ubuntu\n"
     @workers.each { |worker| ips << "worker|#{worker.data.ip}|#{worker.data.dns}|#{worker.data.procs}|ubuntu|ubuntu|true\n" }
     file = Tempfile.new('ip_addresses')
-    file.write(ips)                               
+    file.write(ips)
     file.close
     @server.upload_file(@server.data.ip, file.path, 'ip_addresses')
     file.unlink
@@ -272,31 +315,11 @@ class OpenStudioAwsWrapper
     # Does this command crash it?
     @server.shell_command(@server.data.ip, 'chmod 664 /mnt/openstudio/rails-models/mongoid.yml')
     @workers.each { |worker| worker.shell_command(worker.data.ip, 'chmod 664 /mnt/openstudio/rails-models/mongoid.yml') }
-    
+
     true
   end
 
-  def describe_amis(filter = nil, image_ids = [], owned_by_me = true)
-    resp = nil
 
-    if owned_by_me
-      if filter  
-        resp = @aws.describe_images({:owners => [:self], :filter => filter}).data
-      else
-        resp = @aws.describe_images({:owners => [:self]}).data
-      end
-    else
-      if filter  
-        resp = @aws.describe_images({:filter => filter}).data
-      else
-        resp = @aws.describe_images({:image_ids => image_ids}).data
-      end
-    end
-
-
-    resp
-  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.
@@ -305,7 +328,7 @@ class OpenStudioAwsWrapper
 
     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?
-    
+
     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
@@ -321,27 +344,45 @@ class OpenStudioAwsWrapper
       raise "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 
   # new ami list
   def create_new_ami_json(version = 1)
+    # get the list of existing amis from developer.nrel.gov
     existing_amis = OpenStudioAmis.new(version).list
-    logger.info existing_amis
-    
+
+    # list of available AMIs from AWS
+    available_amis = describe_amis()
+
+    amis = transform_ami_lists(existing_amis, available_amis)
+
     if version == 1
-      # check if the AMIs still exist (anywhere)
-      #test_ami = @os_aws.describe_amis(nil, )
+      version1 = {}
+
+      # grab the old AMIs that are in the 0.0.1 section
+      amis[:openstudio_server]["0.0.1".to_sym].each do |a|
+        next if a[:deprecate]
+
+        version1[a[:openstudio_version]] = a[:amis]
+      end
+
+      # now grab the good keys - they should be sorted newest to older... so go backwards
+      amis[:openstudio_server].keys.reverse.each do |key|
+        next if key == "0.0.1".to_sym
+
+        a = amis[:openstudio_server][key]
+        # this will override any of the old ami/os version
+        version1[a[:openstudio_version].to_sym] = a[:amis]
+      end
+
+      amis = version1
     elsif version == 2
+      # don't need to transform anything right now
     end
-    
 
-    # check if the existing AMIs still exist
-    #existing_amis
-    available_amis = describe_amis()
-    logger.info available_amis
+    amis
   end
-  
+
   def to_os_worker_hash
     worker_hash = []
     @workers.each { |worker|
@@ -352,12 +393,98 @@ class OpenStudioAwsWrapper
                            :procs => worker.data.procs
                        })
     }
-    
+
     out = {:workers => worker_hash}
     logger.info out
-    
+
     out
   end
 
+  private
+
+  # transform the available amis into an easier to read format
+  def transform_ami_lists(existing, available)
+    # initialize ami hash
+    amis = {:openstudio_server => {}, :openstudio => {}}
+    
+    available[:images].each do |ami|
+      sv = ami[:tags_hash][:openstudio_server_version]
+      sv = "0.0.1" if sv.nil?
+
+      a = nil
+      #initialize hashes
+      if sv == "0.0.1" # unknown is an array
+        amis[:openstudio_server][sv.to_sym] = [] if !amis[:openstudio_server][sv.to_sym]
+        amis[:openstudio_server][sv.to_sym] << {}
+        a = amis[:openstudio_server][sv.to_sym].last
+      else
+        amis[:openstudio_server][sv.to_sym] = {} if !amis[:openstudio_server][sv.to_sym]
+        a = amis[:openstudio_server][sv.to_sym]
+      end
+
+      # initialize ami hash
+      a[:amis] = {} if !a[:amis]
+
+      # fill in data (this will override data currently)
+      a[:deprecate] = true if sv == "0.0.1"
+      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]
+      a[:deprecate] = ami[:tags_hash][:deprecate] if ami[:tags_hash][:deprecate]
+      a[:created_on] = ami[:tags_hash][:created_on] if ami[:tags_hash][:created_on]
+
+      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
+          raise "unknown virtualization_type in #{ami[:name]}"
+        end
+      elsif ami[:name] =~ /Server/
+        a[:amis][:server] = ami[:image_id]
+      end
+    end
+
+    # dump the existing amis into the 'unknown category, but don't flag them as 'deprecate'
+    existing.keys.each do |ami_key|
+      next if ami_key == "default".to_sym # ignore default
+
+      amis[:openstudio_server]["0.0.1".to_sym] = [] if !amis[:openstudio_server]["0.0.1".to_sym]
+      amis[:openstudio_server]["0.0.1".to_sym] << {}
+      a = amis[:openstudio_server]["0.0.1".to_sym].last
+      a[:amis] = {} if !a[:amis]
+
+      a[:openstudio_version] = ami_key
+      a[:amis][:server] = existing[ami_key][:server]
+      a[:amis][:worker] = existing[ami_key][:worker]
+      a[:amis][:cc2worker] = existing[ami_key][:cc2worker]
+    end
+
+    # flip these around for openstudio section
+    amis[:openstudio_server].keys.each do |key|
+      next if key == "0.0.1".to_sym
+      a = amis[:openstudio_server][key]
+      ov = a[:openstudio_version]
+
+      amis[:openstudio][ov] = {} if !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][:amis][:server] = a[:amis][:server]
+      amis[:openstudio][ov][osv][:amis][:worker] = a[:amis][:worker]
+      amis[:openstudio][ov][osv][:amis][:cc2worker] = a[:amis][:cc2worker]
+    end
+
+    # sort on the semantic version so that grabbing the key will be the most recent
+    amis[:openstudio_server].sort_by { |k, _| Semantic::Version.new(k.to_s) }
+
+    # determine the defaults - for now just grab the most recent in each openstudio version
+    amis[:openstudio].keys.each do |key|
+      amis[:openstudio][key][:default] = amis[:openstudio][key].keys[0]
+    end
+
+    amis
+  end
 
 end

data/lib/openstudio-aws.rb

@@ -3,6 +3,7 @@ require 'net/scp'
 require 'net/http'
 require 'yaml'
 require 'logger'
+require 'semantic'
 
 # AWS SDK CORE
 begin

data/spec/aws_instances/aws_spec_api.rb

@@ -11,24 +11,20 @@ describe OpenStudio::Aws::Aws do
       @aws.should_not be_nil
     end
 
+    
     it "should ask the user to create a new config file" do
     end
 
     it "should create a server" do
       # use the default instance type
-      options = {instance_type: "t1.micro", image_id: "ami-fb301292"}
+      options = {instance_type: "m1.small", image_id: "ami-29faca40"}
 
-      #options = {instance_type: "m1.small" }
       @aws.create_server(options)
       expect(@aws.os_aws.server).not_to be_nil
     end
 
     it "should create a 1 worker" do
-      options = {instance_type: "t1.micro", image_id: "ami-21301248"}
-      #options = {instance_type: "m1.small" }
-      #server_json[:instance_type] = "m2.4xlarge"
-      #server_json[:instance_type] = "m2.2xlarge"
-      #server_json[:instance_type] = "t1.micro"
+      options = {instance_type: "m1.small", image_id: "ami-95f9c9fc"}
 
       @aws.create_workers(1, options)
 
@@ -37,7 +33,7 @@ describe OpenStudio::Aws::Aws do
     end
     
     it "should be able to connect a worker to an existing server" do
-      options = {instance_type: "t1.micro", image_id: "ami-a9e4ccc0"}
+      options = {instance_type: "m1.small", image_id: "ami-29faca40"}
 
       # will require a new @aws class--but attached to same group_uuid
       @config = OpenStudio::Aws::Config.new