appscale-tools 1.6.0

data/test/tc_appscale_terminate_instances.rb

@@ -0,0 +1,104 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'appscale_tools'
+
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+
+class TestAppScaleTerminateInstances < Test::Unit::TestCase
+  def setup
+    kernel = flexmock(Kernel)
+    kernel.should_receive(:print).and_return()
+    kernel.should_receive(:puts).and_return()
+    kernel.should_receive(:sleep).and_return()
+
+    stdout = flexmock(STDOUT)
+    stdout.should_receive(:flush).and_return()
+
+    fileutils = flexmock(FileUtils)
+    fileutils.should_receive(:rm_f).and_return()
+ 
+    # taken from the standard two node deployment
+    node1 = {
+      'public_ip' => 'public_ip1',
+      'private_ip' => 'private_ip1',
+      'jobs' => ['load_balancer', 'shadow', 'db_master', 'zookeeper', 'login', 'memcache', 'rabbitmq_master'],
+      'instance_id' => 'instance_id1',
+      'cloud' => 'cloud1',
+      'creation_time' => nil,
+      'destruction_time' => nil
+    }
+
+    node2 = {
+      'public_ip' => 'public_ip2',
+      'private_ip' => 'private_ip2',
+      'jobs' => ['load_balancer', 'db_slave', 'memcache', 'rabbitmq_slave', 'appengine'],
+      'instance_id' => 'instance_id2',
+      'cloud' => 'cloud2',
+      'creation_time' => nil,
+      'destruction_time' => nil
+    }
+
+    @role_info = [node1, node2]
+    @key = "appscale"
+
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:read_file).
+      with(File.expand_path("~/.appscale/locations-#{@key}.json")).
+      and_return(JSON.dump(@role_info))
+  end
+
+  def test_no_locations_yaml
+    file = flexmock(File)
+    file.should_receive(:exists?).and_return(false)
+
+    options = {"keyname" => @key}
+    assert_raises(AppScaleException) {
+      AppScaleTools.terminate_instances(options)
+    }
+  end
+
+  def test_terminate_xen_boxes
+    file = flexmock(File)
+    file.should_receive(:exists?).and_return(true)
+
+    @secret = "booooo"
+    @fake_yaml = {
+      :shadow => "public_ip",
+      :secret => @secret,
+      #:table => "cassandra",
+      :infrastructure => "xen",
+      :ips => "public_ip"
+    }
+    yaml = flexmock(YAML)
+    yaml.should_receive(:load_file).and_return(@fake_yaml)
+
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:run_remote_command).and_return()
+    commonfunctions.should_receive(:shell).and_return("service appscale-controller stop", "")
+
+    # mocks for get_role_info, which will return the node's state
+    appcontroller = flexmock('appcontroller')
+    appcontroller.should_receive(:get_role_info).and_return(@role_info)
+    flexmock(AppControllerClient).should_receive(:new).
+      and_return(appcontroller)
+
+    commonfunctions.should_receive(:write_file).with(
+      File.expand_path("~/.appscale/locations-appscale.json"),
+      JSON.dump(@role_info)).and_return()
+
+    options = {"keyname" => "appscale"}
+    assert_nothing_raised(Exception) {
+      AppScaleTools.terminate_instances(options)
+    }
+  end
+
+  def test_usage_is_up_to_date
+    AppScaleTools::TERMINATE_INSTANCES_FLAGS.each { |flag|
+      assert_equal(true, 
+        AppScaleTools::TERMINATE_INSTANCES_USAGE.include?("-#{flag}"), 
+        "No usage text for #{flag}.")
+    } 
+  end
+end

data/test/tc_appscale_upload_app.rb

@@ -0,0 +1,166 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'appscale_tools'
+
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+
+class TestAppScaleUploadApp < Test::Unit::TestCase
+  def setup
+    @app_name = "boo"
+    @file_location = "/tmp/boo.tar.gz"
+    @language = "python"
+    @user = "a@a.a"
+
+    @key = "booscale"
+    @options = { "file_location" => @file_location, "keyname" => @key,
+      "test" => true}
+
+    # common mocks, mostly involving reading files
+    file = flexmock(File)
+    file.should_receive(:exists?).and_return(true)
+
+    @secret = "booooo"
+    @fake_yaml = {:load_balancer => "public_ip1",
+      :shadow => "public_ip1",
+      :secret => @secret,
+      :db_master => "public_ip1",
+      :table => "cassandra",
+      :instance_id => "i-FOOBARZ"}
+    yaml = flexmock(YAML)
+    yaml.should_receive(:load_file).and_return(@fake_yaml)
+
+    # taken from the standard two node deployment
+    node1 = {
+      'public_ip' => 'public_ip1',
+      'private_ip' => 'private_ip1',
+      'jobs' => ['load_balancer', 'shadow', 'db_master', 'zookeeper', 'login', 'memcache', 'rabbitmq_master'],
+      'instance_id' => 'instance_id1',
+      'cloud' => 'cloud1',
+      'creation_time' => nil,
+      'destruction_time' => nil
+    }
+
+    node2 = {
+      'public_ip' => 'public_ip2',
+      'private_ip' => 'private_ip2',
+      'jobs' => ['load_balancer', 'db_slave', 'memcache', 'rabbitmq_slave', 'appengine'],
+      'instance_id' => 'instance_id2',
+      'cloud' => 'cloud2',
+      'creation_time' => nil,
+      'destruction_time' => nil
+    }
+
+    @role_info = [node1, node2]
+
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:read_file).
+      with(File.expand_path("~/.appscale/locations-#{@key}.json")).
+      and_return(JSON.dump(@role_info))
+
+    # mocks for get_role_info, which will return the node's state
+    appcontroller = flexmock('appcontroller')
+    appcontroller.should_receive(:get_role_info).and_return(@role_info)
+    appcontroller.should_receive(:get_userappserver_ip).and_return("127.0.0.1")
+    flexmock(AppControllerClient).should_receive(:new).and_return(appcontroller)
+    
+    commonfunctions.should_receive(:write_file).with(
+      File.expand_path("~/.appscale/locations-#{@key}.json"),
+      JSON.dump(@role_info)).and_return()
+
+    fileutils = flexmock(FileUtils)
+    fileutils.should_receive(:rm_rf).and_return()
+
+    kernel = flexmock(Kernel)
+    kernel.should_receive(:print).and_return()
+    kernel.should_receive(:puts).and_return()
+
+    @app_info = {
+      :app_name => @app_name,
+      :file => @file_location,
+      :language => @language
+    }
+
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:get_app_name_from_tar).and_return(@app_info)
+  end
+
+  def test_no_app_provided
+    options = {"keyname" => @key}
+    assert_raises(AppScaleException) {
+      AppScaleTools.upload_app(options)
+    }
+  end
+
+  def test_app_already_exists_and_user_does_not
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:create_user).and_return()
+
+    appcontrollerclient = flexmock(AppControllerClient)
+    appcontrollerclient.new_instances { |instance|
+      instance.should_receive(:get_userappserver_ip).and_return("127.0.0.1")
+    }
+
+    userappclient = flexmock(UserAppClient)
+    userappclient.new_instances { |instance|
+      instance.should_receive(:does_user_exist?).and_return(false)
+      instance.should_receive(:does_app_exist?).and_return(true)
+    }
+
+    assert_raises(AppScaleException) {
+      AppScaleTools.upload_app(@options)
+    }
+  end
+
+  def test_upload_user_not_app_administrator
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:create_user).and_return()
+
+    appcontrollerclient = flexmock(AppControllerClient)
+    appcontrollerclient.new_instances { |instance|
+      instance.should_receive(:get_userappserver_ip).and_return("127.0.0.1")
+    }
+
+    userappclient = flexmock(UserAppClient)
+    userappclient.new_instances { |instance|
+      instance.should_receive(:does_user_exist?).and_return(true)
+      instance.should_receive(:does_app_exist?).and_return(false)
+      instance.should_receive(:get_app_admin).and_return(@user + "boo")
+    }
+
+    assert_raises(AppScaleException) {
+      AppScaleTools.upload_app(@options)
+    }
+  end
+
+  def test_app_uploads_successfully
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:scp_app_to_ip).and_return(@file_location)
+    commonfunctions.should_receive(:update_appcontroller).and_return()
+    commonfunctions.should_receive(:wait_for_app_to_start).and_return()
+
+    appcontrollerclient = flexmock(AppControllerClient)
+    appcontrollerclient.new_instances { |instance|
+      instance.should_receive(:get_userappserver_ip).and_return("127.0.0.1")
+    }
+
+    userappclient = flexmock(UserAppClient)
+    userappclient.new_instances { |instance|
+      instance.should_receive(:does_user_exist?).and_return(true)
+      instance.should_receive(:does_app_exist?).and_return(false)
+      instance.should_receive(:get_app_admin).and_return(@user)
+    }
+
+    assert_nothing_raised(Exception) {
+      AppScaleTools.upload_app(@options)
+    }
+  end
+
+  def test_usage_is_up_to_date
+    AppScaleTools::UPLOAD_APP_FLAGS.each { |flag|
+      assert_equal(true, AppScaleTools::UPLOAD_APP_USAGE.include?("-#{flag}"), 
+        "No usage text for #{flag}.")
+    }
+  end
+end

data/test/tc_common_functions.rb

@@ -0,0 +1,56 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'common_functions'
+
+
+require 'flexmock/test_unit'
+
+
+class TestCommonFunctions < Test::Unit::TestCase
+  def setup
+    @secret = "baz"
+    @fake_yaml = {
+      :load_balancer => "public_ip1",
+      :shadow => "public_ip1",
+      :secret => @secret,
+      :table => "cassandra",
+      :infrastructure => "xen",
+      :ips => ["public_ip1", "public_ip2"]
+    }
+    yaml = flexmock(YAML)
+    yaml.should_receive(:load_file).and_return(@fake_yaml)
+
+    # taken from the standard two node deployment
+    node1 = {
+      'public_ip' => 'public_ip1',
+      'private_ip' => 'private_ip1',
+      'jobs' => ['load_balancer', 'shadow', 'db_master', 'zookeeper', 'login', 'memcache', 'rabbitmq_master'],
+      'instance_id' => 'instance_id1',
+      'cloud' => 'cloud1',
+      'creation_time' => nil,
+      'destruction_time' => nil
+    }
+
+    node2 = {
+      'public_ip' => 'public_ip2',
+      'private_ip' => 'private_ip2',
+      'jobs' => ['load_balancer', 'db_slave', 'memcache', 'rabbitmq_slave', 'appengine'],
+      'instance_id' => 'instance_id2',
+      'cloud' => 'cloud2',
+      'creation_time' => nil,
+      'destruction_time' => nil
+    }
+
+    @role_info = [node1, node2]
+    @key = "appscale"
+  end
+
+
+  def test_get_ips_for_roles
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:read_file).
+      with(File.expand_path("~/.appscale/locations-#{@key}.json")).
+      and_return(JSON.dump(@role_info))
+
+    assert_equal("public_ip1", CommonFunctions.get_load_balancer_ip(@key))
+  end
+end

data/test/tc_encryption_helper.rb

@@ -0,0 +1,10 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'encryption_helper'
+
+require 'test/unit'
+
+
+class TestEncryptionHelper < Test::Unit::TestCase
+  def test_nothing
+  end
+end

data/test/tc_god_interface.rb

@@ -0,0 +1,10 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'godinterface'
+
+require 'test/unit'
+
+
+class TestGodInterface < Test::Unit::TestCase
+  def test_nothing
+  end
+end

data/test/tc_node_layout.rb

@@ -0,0 +1,93 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'node_layout'
+
+require 'test/unit'
+
+
+class TestNodeLayout < Test::Unit::TestCase
+  def setup
+    @blank_input_yaml = nil
+    @blank_options = {}
+
+    @ip_1 = '192.168.1.1'
+    @ip_2 = '192.168.1.2'
+    @ip_3 = '192.168.1.3'
+  end
+
+  def test_simple_layout_yaml_only
+    # Specifying one controller and one server should be ok
+    input_yaml_1 = {:controller => @ip_1, :servers => [@ip_2]}
+    layout_1 = NodeLayout.new(input_yaml_1, @blank_options)
+    assert_equal(true, layout_1.valid?)
+
+    # Specifying one controller should be ok
+    input_yaml_2 = {:controller => @ip_1}
+    layout_2 = NodeLayout.new(input_yaml_2, @blank_options)
+    assert_equal(true, layout_2.valid?)
+
+    # Specifying the same IP more than once is not ok
+    input_yaml_3 = {:controller => @ip_1, :servers => [@ip_1]}
+    layout_3 = NodeLayout.new(input_yaml_3, @blank_options)
+    assert_equal(false, layout_3.valid?)
+    assert_equal(DUPLICATE_IPS, layout_3.errors)
+
+    # Failing to specify a controller is not ok
+    input_yaml_4 = {:servers => [@ip_1, @ip_2]}
+    layout_4 = NodeLayout.new(input_yaml_4, @blank_options)
+    assert_equal(false, layout_4.valid?)
+    assert_equal(NO_CONTROLLER, layout_4.errors)
+
+    # Specifying more than one controller is not ok
+    input_yaml_5 = {:controller => [@ip_1, @ip_2], :servers => [@ip_3]}
+    layout_5 = NodeLayout.new(input_yaml_5, @blank_options)
+    assert_equal(false, layout_5.valid?)
+    assert_equal(ONLY_ONE_CONTROLLER, layout_5.errors)
+
+    # Specifying something other than controller and servers in simple
+    # deployments is not ok
+    input_yaml_6 = {:controller => @ip_1, :servers => [@ip_2], :boo => @ip_3}
+    layout_6 = NodeLayout.new(input_yaml_6, @blank_options)
+    assert_equal(false, layout_6.valid?)
+    assert_equal(["The flag boo is not a supported flag"], layout_6.errors)
+  end
+
+  def test_simple_layout_options
+    # Using Euca with no input yaml, and no max or min images is not ok
+    options_1 = {:infrastructure => "euca"}
+    layout_1 = NodeLayout.new(@blank_input_yaml, options_1)
+    assert_equal(false, layout_1.valid?)
+    assert_equal(NO_INPUT_YAML_REQUIRES_MIN_IMAGES, layout_1.errors)
+
+    options_2 = {:infrastructure => "euca", :max_images => 2}
+    layout_2 = NodeLayout.new(@blank_input_yaml, options_2)
+    assert_equal(false, layout_2.valid?)
+    assert_equal(NO_INPUT_YAML_REQUIRES_MIN_IMAGES, layout_2.errors)
+
+    options_3 = {:infrastructure => "euca", :min_images => 2}
+    layout_3 = NodeLayout.new(@blank_input_yaml, options_3)
+    assert_equal(false, layout_3.valid?)
+    assert_equal(NO_INPUT_YAML_REQUIRES_MAX_IMAGES, layout_3.errors)
+
+    # Using Euca with no input yaml, with max and min images set is ok
+    options_4 = {:infrastructure => "euca", :min_images => 2, :max_images => 2}
+    layout_4 = NodeLayout.new(@blank_input_yaml, options_4)
+    assert_equal(true, layout_4.valid?)
+
+    # Using Xen or hybrid cloud deployments with no input yaml is not ok
+    options_5 = {:infrastructure => "xen"}
+    layout_5 = NodeLayout.new(@blank_input_yaml, options_5)
+    assert_equal(false, layout_5.valid?)
+    assert_equal([INPUT_YAML_REQUIRED], layout_5.errors)
+
+    options_6 = {:infrastructure => "hybrid"}
+    layout_6 = NodeLayout.new(@blank_input_yaml, options_6)
+    assert_equal(false, layout_6.valid?)
+    assert_equal([INPUT_YAML_REQUIRED], layout_6.errors)
+  end
+
+  def test_advanced_format_yaml_only
+    input_yaml_1 = {:master => @ip_1, :database => @ip_1, :appengine => @ip_1, :open => @ip_2}
+    layout_1 = NodeLayout.new(input_yaml_1, @blank_options)
+    assert_equal(true, layout_1.valid?)
+  end
+end

data/test/tc_parse_args.rb

@@ -0,0 +1,160 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'parse_args'
+
+require 'test/unit'
+
+
+class TestParseArgs < Test::Unit::TestCase
+  def setup
+    @args = {}
+    @usage = "boo"
+  end
+
+  def get_exception_msg
+    if !block_given?
+      abort('need to give me a block!')
+    end
+
+    begin
+      yield
+    rescue SystemExit => e
+      return e.message
+    end
+  end
+
+  def test_flags_that_cause_program_abort
+    # Using a flag that isn't acceptable should cause ParseArgs to abort
+    args_1 = ['--boo!']
+    all_flags_1 = []
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_1, all_flags_1, @usage)
+    }
+
+    # The --usage flag should cause ParseArgs to abort and print the usage
+    args_2 = ['--usage']
+    all_flags_2 = ['usage']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_2, all_flags_2, @usage)
+    }
+
+    # The --version flag should cause ParseArgs to abort and print the version
+    args_3 = ['--version']
+    all_flags_3 = ['version']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_3, all_flags_3, @usage)
+    }
+  end
+
+  def test_get_min_and_max
+    # Setting min or max below 1 is not acceptable
+    args_1 = ['--min', '0']
+    all_flags_1 = ['min']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_1, all_flags_1, @usage)
+    }
+
+    args_2 = ['--max', '0']
+    all_flags_2 = ['max']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_2, all_flags_2, @usage)
+    }
+
+    # If max is specified but not min, min should be equal to max
+    args_3 = ['--max', '1']
+    all_flags_3 = ['max']
+    actual_3 = ParseArgs.get_vals_from_args(args_3, all_flags_3, @usage)
+    assert_equal(actual_3['min_images'], actual_3['max_images'])
+
+    # If max is less than min, it should abort
+    args_4 = ['--min', '10', '--max', '1']
+    all_flags_4 = ['min', 'max']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_4, all_flags_4, @usage)
+    }
+  end
+
+  def test_table_flags
+    # Specifying a table that isn't accepted should abort
+    args_1 = ['--table', 'non-existant-table']
+    all_flags_1 = ['table']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_1, all_flags_1, @usage)
+    }
+
+    # Specifying a table that is accepted should return that in the result
+    args_2 = ['--table', 'voldemort']
+    all_flags_2 = ['table']
+    expected_2 = Hash[*args_2]
+    actual_2 = ParseArgs.get_vals_from_args(args_2, all_flags_2, @usage)
+    assert_equal('voldemort', actual_2['table'])
+
+    # Failing to specify a table should default to a predefined table
+    args_3 = []
+    all_flags_3 = ['table']
+    expected_3 = {}
+    actual_3 = ParseArgs.get_vals_from_args(args_3, all_flags_3, @usage)
+    assert_equal(DEFAULT_DATASTORE, actual_3['table'])
+
+    # Specifying r or w when Voldemort isn't used should abort
+    args_4 = ['--table', 'cassandra', '-r', '1']
+    all_flags_4 = ['table', 'r', 'w']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_4, all_flags_4, @usage)
+    }
+
+    args_5 = ['--table', 'cassandra', '-w', '1']
+    all_flags_5 = ['table', 'r', 'w']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_5, all_flags_5, @usage)
+    }
+
+    # Specifying a non-positive integer for r or w with Voldemort should abort
+    args_6 = ['--table', 'voldemort', '-r', 'boo']
+    all_flags_6 = ['table', 'r', 'w']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_6, all_flags_6, @usage)
+    }
+
+    args_7 = ['--table', 'voldemort', '-w', '0']
+    all_flags_7 = ['table', 'r', 'w']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_7, all_flags_7, @usage)
+    }
+
+    # Specifying a non-positive integer for n should abort
+    args_8 = ['--table', 'cassandra', '-n', '0']
+    all_flags_8 = ['table', 'n']
+    assert_raises(BadCommandLineArgException) {
+      ParseArgs.get_vals_from_args(args_8, all_flags_8, @usage)
+    }
+
+    # Specifying a positive integer for n should be ok
+    args_9 = ['--table', 'cassandra', '-n', '2']
+    all_flags_9 = ['table', 'n']
+    expected_9 = Hash[*args_9]
+    actual_9 = ParseArgs.get_vals_from_args(args_9, all_flags_9, @usage)
+    assert_equal(2, actual_9['replication'])
+
+    # Specifying a positive integer for r or w with Voldemort should be ok
+    args_10 = ['--table', 'voldemort', '-r', '3']
+    all_flags_10 = ['table', 'r', 'w']
+    actual_10 = ParseArgs.get_vals_from_args(args_10, all_flags_10, @usage)
+    assert_equal(3, actual_10['voldemort_r'])
+
+    args_11 = ['--table', 'voldemort', '-w', '3']
+    all_flags_11 = ['table', 'r', 'w']
+    actual_11 = ParseArgs.get_vals_from_args(args_11, all_flags_11, @usage)
+    assert_equal(3, actual_11['voldemort_w'])
+  end
+
+  def test_developer_flags
+    # Specifying auto, force, or test should have that carried over
+    # to in the resulting hash
+    ['auto', 'force', 'test'].each { |param|
+      args = ["--#{param}"]
+      all_flags = [param]
+      actual = ParseArgs.get_vals_from_args(args, all_flags, @usage)
+      assert_equal(true, actual[param])
+    }
+  end
+end