mortar 0.15.37 → 0.15.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15cff7085bdc1d7475ce5de63a224f1e5f9af981
-  data.tar.gz: e273bd6668c0752d89cef8546c1c43cdc69f1d92
+  metadata.gz: ffc0b8718edcb166d6efb97aa313f93f62cbe05a
+  data.tar.gz: e50a708d63e897a055528aeb61b0a2a023c6cb78
 SHA512:
-  metadata.gz: 3c52e4a5fb9d3921626417c54aa3622d8494b81bb481155862918c05a9d1a69c3f1ceab0ac4485409533f383d2c1d1043b9c7d89293c35c27f12ade5e2d49ae7
-  data.tar.gz: c31c3f2135b0e592630cbf622d9815d7ccb28eb741826e203df3b11be0d427b5c936ec67e23543a5494ff1444ec1bee0eb91c990234ffe9a8d9c32d49845be84
+  metadata.gz: 0c57ea3f3a078fd0896b92973d5bd731bdedd2024c2ddfae3f74121dce10fddef75b374c4b6f6618345f724ce79963cf501065553b7494c919627aa64815b715
+  data.tar.gz: b62dc6bb899b601ea4c6162a2bcdf068d47e23d13d1acf75cfefb40bcefdd757d0475d0dd91d6325b7031352ea4a3097e96a733ec65123eff2d08f4ca0d96cc0

data/lib/mortar/command/base.rb

@@ -296,7 +296,7 @@ protected
 
   def self.replace_templates(help)
     help.each do |line|
-      line.gsub!("<PIG_VERSION_OPTIONS>", "0.12 and 0.12-Hadoop-2")
+      line.gsub!("<PIG_VERSION_OPTIONS>", "0.12-Hadoop-2")
     end
   end
 
@@ -608,7 +608,7 @@ protected
   end
 
   def pig_version
-    pig_version_str = options[:pigversion] || '0.12'
+    pig_version_str = options[:pigversion] || '0.12-Hadoop-2'
     pig_version = Mortar::PigVersion.from_string(pig_version_str)
   end
 

data/lib/mortar/local/controller.rb

@@ -124,7 +124,7 @@ EOF
     require_aws_keys()
 
     if pig_version.nil?
-      pig_version = Mortar::PigVersion::Pig012.new
+      pig_version = Mortar::PigVersion::Pig012Hadoop2.new
     end
 
     java = Mortar::Local::Java.new()

data/lib/mortar/local/pig.rb

@@ -84,7 +84,7 @@ class Mortar::Local::Pig
   end
 
   def pig_directory(pig_version)
-    return File.join(local_install_directory, pig_version.name)
+    return File.join(local_install_directory, pig_version.pig_version)
   end
 
   def lib_directory
@@ -113,7 +113,7 @@ class Mortar::Local::Pig
   # Determines if a pig install needs to occur, true if server side
   # pig tgz is newer than date of the existing install
   def should_do_pig_update?(pig_version, command=nil)
-    return is_newer_version(pig_version.name, pig_archive_url(pig_version), command)
+    return is_newer_version(pig_version.pig_version, pig_archive_url(pig_version), command)
   end
 
   def should_do_lib_update?
@@ -122,11 +122,11 @@ class Mortar::Local::Pig
 
   def install_or_update(pig_version, command=nil)
     if should_do_pig_install?(pig_version)
-      action "Installing #{pig_version.name} to #{local_install_directory_name}" do
+      action "Installing #{pig_version.pig_version} to #{local_install_directory_name}" do
         install_pig(pig_version, command)
       end
     elsif should_do_pig_update?(pig_version, command)
-      action "Updating to latest #{pig_version.name} in #{local_install_directory_name}" do
+      action "Updating to latest #{pig_version.pig_version} in #{local_install_directory_name}" do
         install_pig(pig_version)
       end
     end
@@ -159,7 +159,7 @@ class Mortar::Local::Pig
     FileUtils.chmod(0755, command(pig_version))
 
     File.delete(local_tgz)
-    note_install(pig_version.name)
+    note_install(pig_version.pig_version)
   end
 
   def install_lib
@@ -323,7 +323,7 @@ class Mortar::Local::Pig
   def template_params_classpath(pig_version=nil)
     # Need to support old watchtower plugins that don't set pig_version
     if pig_version.nil?
-      pig_version = Mortar::PigVersion::Pig012.new
+      pig_version = Mortar::PigVersion::Pig012Hadoop2.new
     end
     [ "#{pig_directory(pig_version)}/*",
       "#{pig_directory(pig_version)}/lib-local/*",
@@ -362,7 +362,7 @@ class Mortar::Local::Pig
   def pig_command_script_template_parameters(cmd, pig_version, pig_parameters)
     template_params = {}
     template_params['pig_params_file'] = make_pig_param_file(pig_parameters)
-    template_params['pig_dir'] = pig_version.name
+    template_params['pig_dir'] = pig_version.pig_version
     template_params['pig_home'] = pig_directory(pig_version)
     template_params['pig_classpath'] = pig_classpath(pig_version)
     template_params['classpath'] = template_params_classpath

data/lib/mortar/pigversion.rb

@@ -16,41 +16,16 @@
 
 module Mortar
     module PigVersion
-        PIG_0_12_TGZ_NAME = "pig-0.12.tar.gz"
-        PIG_0_12_TGZ_DEFAULT_URL_PATH = "resource/pig_0_12"
-
         PIG_0_12_HADOOP_2_TGZ_NAME = "pig-0.12-hadoop-2.tar.gz"
         PIG_0_12_HADOOP_2_TGZ_DEFAULT_URL_PATH = "resource/pig_0_12_hadoop_2"
 
         def PigVersion.from_string(pig_version_str)
             if pig_version_str == '0.12'
-                return Pig012.new
+                raise ArgumentError, "Our Hadoop 1 clusters are no longer supported by EMR.  Please use the default version of Pig: 0.12-Hadoop-2.  If you're unsure of why you're seeing this error please ensure that the project.properties file is not setting pigversion to an unsupported value."
             elsif pig_version_str == '0.12-Hadoop-2'
                 return Pig012Hadoop2.new 
             else
-                raise ArgumentError, "Unsupported pig version: #{pig_version_str}.  Options are: ['0.12', '0.12-Hadoop-2]."
-            end
-        end
-
-        class Pig012
-            def tgz_name
-                PIG_0_12_TGZ_NAME
-            end
-
-            def tgz_default_url_path
-                PIG_0_12_TGZ_DEFAULT_URL_PATH
-            end
-
-            def name
-                "pig-#{version}"
-            end
-
-            def version
-                "0.12"
-            end
-
-            def cluster_backend
-                Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_1
+                raise ArgumentError, "Unsupported pig version: #{pig_version_str}.  Options are: ['0.12-Hadoop-2]."
             end
         end
 
@@ -71,6 +46,10 @@ module Mortar
                 "0.12-Hadoop-2"
             end
 
+            def pig_version
+                "pig-0.12"
+            end
+
             def cluster_backend
                 Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2
             end

data/lib/mortar/templates/project/project.properties

@@ -7,5 +7,5 @@
 #   http://help.mortardata.com/data_apps/build_your_own/running_a_mortar_project#toc_7SettingProjectDefaults
 
 [DEFAULTS]
-# Default new projects to using Pig 0.12
-pigversion=0.12
+# Default new projects to using Pig 0.12-Hadoop-2
+pigversion=0.12-Hadoop-2

data/lib/mortar/version.rb

@@ -16,5 +16,5 @@
 
 module Mortar
   # see http://semver.org/
-  VERSION = "0.15.37"
+  VERSION = "0.15.38"
 end

data/spec/mortar/command/base_spec.rb

@@ -106,7 +106,7 @@ other\tgit@github.com:other.git (push)
     context "method_added" do
       it "replaces help templates" do
         lines = Base.replace_templates(["line", "start <PIG_VERSION_OPTIONS>"])
-        lines.join("").should == 'linestart 0.12 and 0.12-Hadoop-2'
+        lines.join("").should == 'linestart 0.12-Hadoop-2'
       end
     end
 
@@ -147,7 +147,7 @@ other\tgit@github.com:other.git (push)
         with_git_initialized_project do |p|
           text = """
 [DEFAULTS]
-pigversion=0.12
+pigversion=0.12-Hadoop-2
 
 [other]
 no_browser=true
@@ -155,7 +155,7 @@ no_browser=true
           write_file(File.join(p.root_path, ".mortar-defaults"), text)
 
           b = Base.new
-          b.options.should == {:pigversion => "0.12"}
+          b.options.should == {:pigversion => "0.12-Hadoop-2"}
         end
       end
 
@@ -166,7 +166,7 @@ no_browser=true
         with_git_initialized_project do |p|
           text = """
 [DEFAULTS]
-pigversion=0.12
+pigversion=0.12-Hadoop-2
 
 [other]
 no_browser=true
@@ -176,14 +176,14 @@ no_browser=true
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           mock(Launchy).open(describe_url) {Thread.new {}}
 
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
 
           stderr, stdout, d = execute_and_return_command("describe pigscripts/my_script.pig my_alias --polling_interval 0.05", p, git)
-          d.options.should == {:pigversion => "0.12", :polling_interval => "0.05"}
+          d.options.should == {:pigversion => "0.12-Hadoop-2", :polling_interval => "0.05"}
         end
       end
 
@@ -194,7 +194,7 @@ no_browser=true
         with_git_initialized_project do |p|
           text = """
 [DEFAULTS]
-pigversion=0.12
+pigversion=0.12-Hadoop-2
 
 [my_script]
 no_browser=true
@@ -204,12 +204,12 @@ no_browser=true
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
 
           stderr, stdout, d = execute_and_return_command("describe pigscripts/my_script.pig my_alias --polling_interval 0.05", p, git)
-          d.options.should == {:pigversion => "0.12", :polling_interval => "0.05", :no_browser => true}
+          d.options.should == {:pigversion => "0.12-Hadoop-2", :polling_interval => "0.05", :no_browser => true}
         end
       end
 
@@ -232,7 +232,7 @@ polling_interval=10
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
 
@@ -250,19 +250,19 @@ polling_interval=10
 [DEFAULTS]
 clustersize=5
 no_browser=true
-pigversion=0.12
+pigversion=0.12-Hadoop-2
 """
           write_file(File.join(p.root_path, "project.properties"), text)
 
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
 
           stderr, stdout, d = execute_and_return_command("describe pigscripts/my_script.pig my_alias --polling_interval 0.05", p, git)
-          d.options.should == {:polling_interval => "0.05", :no_browser => true, :clustersize => "5", :pigversion => "0.12"}
+          d.options.should == {:polling_interval => "0.05", :no_browser => true, :clustersize => "5", :pigversion => "0.12-Hadoop-2"}
         end
       end
 

data/spec/mortar/command/describe_spec.rb

@@ -98,7 +98,7 @@ STDERR
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered
@@ -129,7 +129,7 @@ STDOUT
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered
@@ -163,7 +163,7 @@ STDOUT
           column_number = 32
           error_type = 'PigError'
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_FAILURE, "status_description" => "Failed",
             "error_message" => error_message,
@@ -198,7 +198,7 @@ STDERR
           describe_url = "https://mdog.datadoghq.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered

data/spec/mortar/command/illustrate_spec.rb

@@ -74,7 +74,7 @@ STDERR
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -108,7 +108,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -142,7 +142,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_SUCCESS,          "status_description" => "Succeeded", "web_result_url" => illustrate_url})).ordered
                     
@@ -169,7 +169,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", true, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", true, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_SUCCESS,          "status_description" => "Succeeded", "web_result_url" => illustrate_url})).ordered
                     
@@ -195,7 +195,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -232,7 +232,7 @@ STDOUT
           error_type = 'PigError'
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,  "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_FAILURE, 
             "error_message" => error_message,
@@ -268,7 +268,7 @@ STDERR
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered

data/spec/mortar/command/jobs_spec.rb

@@ -47,7 +47,7 @@ module Mortar::Command
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.12",
+            :pig_version => "0.12-Hadoop-2",
             :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__SINGLE_JOB,
@@ -83,7 +83,7 @@ STDOUT
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String),cluster_size,
-                                                      :pig_version => "0.12", 
+                                                      :pig_version => "0.12-Hadoop-2", 
                                                       :project_script_path => be_a_kind_of(String),
                                                       :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]),
                                                       :cluster_type => Jobs::CLUSTER_TYPE__PERMANENT,
@@ -143,7 +143,7 @@ STDERR
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String),cluster_size, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
@@ -179,7 +179,7 @@ STDOUT
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String),cluster_size, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
@@ -215,7 +215,7 @@ STDOUT
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
           mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id,
-              :pig_version => "0.12", 
+              :pig_version => "0.12-Hadoop-2", 
               :project_script_path => be_a_kind_of(String),
               :parameters => [],
               :notify_on_job_finish => false,
@@ -249,7 +249,7 @@ STDOUT
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
           mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id,
-              :pig_version => "0.12", 
+              :pig_version => "0.12-Hadoop-2", 
               :project_script_path => be_a_kind_of(String),
               :parameters => [],
               :notify_on_job_finish => false,
@@ -281,9 +281,9 @@ STDOUT
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_size = 2
 
-          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_1) {Excon::Response.new(:body => {'clusters' => []})}
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2) {Excon::Response.new(:body => {'clusters' => []})}
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
@@ -319,9 +319,9 @@ STDOUT
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_size = 2
 
-          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_1) {Excon::Response.new(:body => {'clusters' => []})}
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2) {Excon::Response.new(:body => {'clusters' => []})}
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
@@ -358,7 +358,7 @@ STDOUT
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
-          mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => [], :notify_on_job_finish => false, :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
+          mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => [], :notify_on_job_finish => false, :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
 
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
           stderr, stdout = execute("jobs:run pigscripts/my_script.pig --clusterid e2790e7e8c7d48e39157238d58191346 -d", p, @git)
@@ -399,7 +399,7 @@ STDOUT
           huge_busy_cluster_status = Mortar::API::Clusters::STATUS_RUNNING
           
 
-          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_1) {
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2) {
             Excon::Response.new(:body => { 
               'clusters' => [
                   { 'cluster_id' => small_cluster_id, 'size' => small_cluster_size, 'running_jobs' => [], 'status_code' => small_cluster_status }, 
@@ -411,7 +411,7 @@ STDOUT
               ]})
           }
           mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), large_cluster_id, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :notify_on_job_finish => true,
@@ -493,7 +493,7 @@ STDOUT
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.12",
+            :pig_version => "0.12-Hadoop-2",
             :project_script_path => be_a_kind_of(String), 
             :parameters => match_array([{"name" => "FIRST", "value" => "FOO"}, {"name" => "SECOND", "value" => "BAR"}, {"name" => "THIRD", "value" => "BEAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
@@ -521,7 +521,7 @@ PARAMS
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST", "value" => "FOO"}, {"name" => "SECOND", "value" => "BAR"}, {"name" => "THIRD", "value" => "BEAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
@@ -577,7 +577,7 @@ STDERR
           mock(@git).sync_embedded_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
 
           mock(Mortar::Auth.api).post_pig_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.12", 
+            :pig_version => "0.12-Hadoop-2", 
             :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,

data/spec/mortar/command/local_spec.rb

@@ -48,7 +48,7 @@ STDERR
             mock(u).config_parameters.returns([])
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).illustrate(pigscript, "some_alias", is_a(Mortar::PigVersion::Pig012), [], false, false).returns(nil)
+            mock(u).illustrate(pigscript, "some_alias", is_a(Mortar::PigVersion::Pig012Hadoop2), [], false, false).returns(nil)
           end
           stderr, stdout = execute("local:illustrate #{script_name} some_alias", p)
           stderr.should == ""
@@ -66,9 +66,9 @@ STDERR
             mock(u).config_parameters.returns([])
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012), [], false, false).returns(nil)
+            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012Hadoop2), [], false, false).returns(nil)
           end
-          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12", p)
+          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12-Hadoop-2", p)
           stderr.should == ""
         end
       end
@@ -85,9 +85,9 @@ STDERR
           end
           mock(Mortar::Project::PigScript).new(script_name, script_path).returns(pigscript)
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012), [{"name"=>"first", "value"=>1},{"name"=>"second", "value"=>2}], false, false).returns(nil)
+            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012Hadoop2), [{"name"=>"first", "value"=>1},{"name"=>"second", "value"=>2}], false, false).returns(nil)
           end
-          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12", p)
+          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12-Hadoop-2", p)
           stderr.should == ""
         end
       end
@@ -244,10 +244,10 @@ PARAMS
             mock(u).config_parameters.returns([{"key"=>"k", "value"=>"v"}])
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012), 'validate')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop2), 'validate')
           end
           any_instance_of(Mortar::Local::Pig) do |u|
-            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012), [{"key"=>"k", "value"=>"v"}])
+            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012Hadoop2), [{"key"=>"k", "value"=>"v"}])
           end
           stderr, stdout = execute("local:validate #{script_name}", p)
           stderr.should == ""
@@ -265,10 +265,10 @@ PARAMS
             mock(u).config_parameters.returns([])
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012), 'validate')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop2), 'validate')
           end
           any_instance_of(Mortar::Local::Pig) do |u|
-            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012), [])
+            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012Hadoop2), [])
           end
           stderr, stdout = execute("local:validate pigscripts/#{script_name}.pig", p)
           stderr.should == ""
@@ -316,7 +316,7 @@ STDERR
             mock(u).run_stillson_luigi_client_cfg_expansion(luigi_script, config_parameters).returns(true)
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012),'luigi')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop2),'luigi')
           end
           any_instance_of(Mortar::Command::Local) do |u|
             mock(u).sync_code_with_cloud().returns("some-git-ref")
@@ -347,7 +347,7 @@ STDERR
             mock(u).run_luigi_script(luigi_script, %W{--myoption 2 --myotheroption 3})
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012),'luigi')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop2),'luigi')
           end
           any_instance_of(Mortar::Command::Local) do |u|
             mock(u).sync_code_with_cloud().returns("some-git-ref")

data/spec/mortar/command/validate_spec.rb

@@ -73,7 +73,7 @@ STDERR
           validate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           parameters = ["name"=>"key", "value"=>"value" ]
 
-          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
+          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_PROGRESS, "status_description" => "Starting"})).ordered
@@ -103,7 +103,7 @@ STDOUT
           column_number = 32
           error_type = 'PigError'
           
-          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"validate_id" => validate_id})}
+          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"validate_id" => validate_id})}
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_FAILURE, "status_description" => "Failed",
             "error_message" => error_message,
@@ -137,7 +137,7 @@ STDERR
         validate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
         parameters = ["name"=>"key", "value"=>"value" ]
         
-        mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
+        mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12-Hadoop-2", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
         mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_QUEUED, "status_description" => "Pending"})).ordered
         mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
         mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_PROGRESS, "status_description" => "Starting"})).ordered
@@ -146,7 +146,7 @@ STDERR
         mock(@git).sync_embedded_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
 
         write_file(File.join(p.pigscripts_path, "my_script.pig"))
-        stderr, stdout = execute("validate my_script --polling_interval 0.05 -p key=value -g 0.12", p, @git)
+        stderr, stdout = execute("validate my_script --polling_interval 0.05 -p key=value -g 0.12-Hadoop-2", p, @git)
       end
     end
   end

data/spec/mortar/local/controller_spec.rb

@@ -135,7 +135,7 @@ module Mortar::Local
           mock(j).check_install.returns(true)
         end
         any_instance_of(Mortar::Local::Pig) do |p|
-          mock(p).install_or_update(is_a(Mortar::PigVersion::Pig012), nil)
+          mock(p).install_or_update(is_a(Mortar::PigVersion::Pig012Hadoop2), nil)
         end
         any_instance_of(Mortar::Local::Python) do |p|
           mock(p).check_or_install.returns(true)
@@ -158,13 +158,13 @@ module Mortar::Local
 
       it "checks for aws keys, checks depenendency installation, runs script" do
         c = Mortar::Local::Controller.new
-        mock(c).install_and_configure("0.12", "run")
+        mock(c).install_and_configure("0.12-Hadoop-2", "run")
         test_script = "foobar-script"
         the_parameters = []
         any_instance_of(Mortar::Local::Pig) do |p|
-          mock(p).run_script(test_script, "0.12", the_parameters)
+          mock(p).run_script(test_script, "0.12-Hadoop-2", the_parameters)
         end
-        c.run(test_script, "0.12", the_parameters)
+        c.run(test_script, "0.12-Hadoop-2", the_parameters)
       end
 
     end
@@ -172,16 +172,16 @@ module Mortar::Local
     context("illustrate") do
       it "checks for aws keys, checks depenendency installation, runs the illustrate process" do
         c = Mortar::Local::Controller.new
-        mock(c).install_and_configure("0.12", "illustrate")
+        mock(c).install_and_configure("0.12-Hadoop-2", "illustrate")
         test_script = "foobar-script"
         script_alias = "some_alias"
         prune = false
         no_browser = false
         the_parameters = []
         any_instance_of(Mortar::Local::Pig) do |p|
-          mock(p).illustrate_alias(test_script, script_alias, prune, no_browser, "0.12", the_parameters)
+          mock(p).illustrate_alias(test_script, script_alias, prune, no_browser, "0.12-Hadoop-2", the_parameters)
         end
-        c.illustrate(test_script, script_alias, "0.12", the_parameters, prune, no_browser)
+        c.illustrate(test_script, script_alias, "0.12-Hadoop-2", the_parameters, prune, no_browser)
       end
     end
 

data/spec/mortar/local/pig_spec.rb

@@ -35,19 +35,19 @@ module Mortar::Local
         # chmods bin/pig, removes tgz, and notes the installation
         FakeFS do
           pig = Mortar::Local::Pig.new
-          pig012 = Mortar::PigVersion::Pig012.new
-          local_pig_archive = File.join(pig.local_install_directory, pig012.tgz_name)
-          mock(pig).download_file(pig.pig_archive_url(pig012), local_pig_archive, nil) do
+          pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
+          local_pig_archive = File.join(pig.local_install_directory, pig012Hadoop2.tgz_name)
+          mock(pig).download_file(pig.pig_archive_url(pig012Hadoop2), local_pig_archive, nil) do
             # Simulate the tgz file being downloaded, this should be deleted
             # before the method finishes executing
             FileUtils.touch(local_pig_archive)
           end
           mock(pig).extract_tgz(local_pig_archive, pig.local_install_directory)
-          mock(pig).note_install(pig012.name)
-          mock(pig).command(pig012)
+          mock(pig).note_install(pig012Hadoop2.pig_version)
+          mock(pig).command(pig012Hadoop2)
           begin
             previous_stdout, $stdout = $stdout, StringIO.new
-            pig.install_pig(pig012)
+            pig.install_pig(pig012Hadoop2)
           ensure
             $stdout = previous_stdout
           end
@@ -61,17 +61,17 @@ module Mortar::Local
 
       it "does nothing if existing install and no update available" do
         pig = Mortar::Local::Pig.new
-        pig012 = Mortar::PigVersion::Pig012.new
+        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
 
-        mock(pig).should_do_pig_install?(pig012).returns(false)
-        mock(pig).should_do_pig_update?(pig012, nil).returns(false)
+        mock(pig).should_do_pig_install?(pig012Hadoop2).returns(false)
+        mock(pig).should_do_pig_update?(pig012Hadoop2, nil).returns(false)
         mock(pig).should_do_lib_install?.returns(false)
         mock(pig).should_do_lib_update?.returns(false)
         FakeFS do
           FileUtils.mkdir_p(File.dirname(pig.local_install_directory))
           FileUtils.rm_rf(pig.local_install_directory, :force => true)
-          pig.install_or_update(pig012)
-          expect(File.exists?(pig.pig_directory(pig012))).to be_false
+          pig.install_or_update(pig012Hadoop2)
+          expect(File.exists?(pig.pig_directory(pig012Hadoop2))).to be_false
           expect(File.exists?(pig.lib_directory)).to be_false
 
         end
@@ -79,30 +79,30 @@ module Mortar::Local
 
       it "does install if none has been done before" do
         pig = Mortar::Local::Pig.new
-        pig012 = Mortar::PigVersion::Pig012.new
+        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
 
-        mock(pig).should_do_pig_install?(pig012).returns(true)
+        mock(pig).should_do_pig_install?(pig012Hadoop2).returns(true)
         mock(pig).should_do_lib_install?.returns(true)
 
-        mock(pig).install_pig(pig012, nil)
+        mock(pig).install_pig(pig012Hadoop2, nil)
         mock(pig).install_lib
         capture_stdout do
-          pig.install_or_update(pig012)
+          pig.install_or_update(pig012Hadoop2)
         end
       end
 
       it "does install if one was done before but there is an update" do
         pig = Mortar::Local::Pig.new
-        pig012 = Mortar::PigVersion::Pig012.new
+        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
 
-        mock(pig).should_do_pig_install?(pig012).returns(false)
-        mock(pig).should_do_pig_update?(pig012, nil).returns(true)
+        mock(pig).should_do_pig_install?(pig012Hadoop2).returns(false)
+        mock(pig).should_do_pig_update?(pig012Hadoop2, nil).returns(true)
         mock(pig).should_do_lib_install?.returns(false)
         mock(pig).should_do_lib_update?.returns(true)
-        mock(pig).install_pig(pig012)
+        mock(pig).install_pig(pig012Hadoop2)
         mock(pig).install_lib
         capture_stdout do
-          pig.install_or_update(pig012)
+          pig.install_or_update(pig012Hadoop2)
         end
       end
 
@@ -208,7 +208,7 @@ module Mortar::Local
         mock(pig).run_pig_command.with_any_args.returns(true)
         mock(pig).show_illustrate_output_browser.with_any_args
         stub(pig).make_pig_param_file.returns('param.file')
-        pig.illustrate_alias(script, 'my_alias', false, false, "0.12", [])
+        pig.illustrate_alias(script, 'my_alias', false, false, "0.12-Hadoop-2", [])
       end
 
       it "displays text results if illustrate was successful with no_browser" do
@@ -218,7 +218,7 @@ module Mortar::Local
         stub(pig).run_pig_command.with_any_args.returns(true)
         mock(pig).display.with_any_args
         stub(pig).make_pig_param_file.returns('param.file')
-        pig.illustrate_alias(script, 'my_alias', false, true, "0.12", [])
+        pig.illustrate_alias(script, 'my_alias', false, true, "0.12-Hadoop-2", [])
       end
 
       it "skips results if illustrate was unsuccessful" do
@@ -228,7 +228,7 @@ module Mortar::Local
         mock(pig).run_pig_command.with_any_args.returns(false)
         mock(pig).show_illustrate_output_browser.with_any_args.never
         stub(pig).make_pig_param_file.returns('param.file')
-        pig.illustrate_alias(script, 'my_alias', false, false, "0.12", [])
+        pig.illustrate_alias(script, 'my_alias', false, false, "0.12-Hadoop-2", [])
       end
 
       it "does not require login credentials for illustration" do
@@ -238,7 +238,7 @@ module Mortar::Local
         mock(Mortar::Auth).user_s3_safe(true).returns('notloggedin-user-org')
         mock(pig).run_pig_command.with_any_args.returns(true)
         mock(pig).show_illustrate_output_browser.with_any_args
-        pig.illustrate_alias(script, 'my_alias', false, false, "0.12", [])
+        pig.illustrate_alias(script, 'my_alias', false, false, "0.12-Hadoop-2", [])
       end
 
     end
@@ -264,13 +264,12 @@ module Mortar::Local
         pig = Mortar::Local::Pig.new
         tpc = pig.template_params_classpath
         expect(tpc.include?("pig-0.12")).to be_true
-        expect(tpc.include?("pig-0.12-Hadoop-2")).to be_false
       end
 
       it "Works with 0.12-Hadoop-2 pig" do
         pig = Mortar::Local::Pig.new
         tpc = pig.template_params_classpath(Mortar::PigVersion::Pig012Hadoop2.new)
-        expect(tpc.include?("pig-0.12-Hadoop-2")).to be_true
+        expect(tpc.include?("pig-0.12")).to be_true
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mortar
 version: !ruby/object:Gem::Version
-  version: 0.15.37
+  version: 0.15.38
 platform: ruby
 authors:
 - Mortar Data
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-11 00:00:00.000000000 Z
+date: 2016-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.14
+        version: 0.8.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.14
+        version: 0.8.15
 - !ruby/object:Gem::Dependency
   name: netrc
   requirement: !ruby/object:Gem::Requirement
@@ -322,7 +322,6 @@ files:
 - spec/mortar/command/pigscripts_spec.rb
 - spec/mortar/command/projects_spec.rb
 - spec/mortar/command/s3_spec.rb
-- spec/mortar/command/spark_spec.rb
 - spec/mortar/command/validate_spec.rb
 - spec/mortar/command/version_spec.rb
 - spec/mortar/command_spec.rb

data/spec/mortar/command/spark_spec.rb

@@ -1,154 +0,0 @@
-#
-# Copyright 2014 Mortar Data Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'spec_helper'
-require 'fakefs/spec_helpers'
-require 'mortar/command/spark'
-require 'mortar/api/jobs'
-
-module Mortar::Command
-  describe Spark do
-    
-    before(:each) do
-      stub_core      
-      @git = Mortar::Git::Git.new
-    end
-    
-    context("index") do
-      it "shows help when user adds help argument" do
-        with_git_initialized_project do |p|
-          stderr_dash_h, stdout_dash_h = execute("spark -h", p, @git) 
-          stderr_help, stdout_help = execute("spark help", p, @git)
-          stdout_dash_h.should == stdout_help
-          stderr_dash_h.should == stderr_help
-        end
-      end
-
-      it "runs a spark job with no arguments new cluster" do
-        with_git_initialized_project do |p|
-          # stub api requests
-          job_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
-          job_url = "http://127.0.0.1:5000/jobs/spark_job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
-          mock(Mortar::Auth.api).post_spark_job_new_cluster("myproject", "my_script.py", is_a(String), 4,
-            :project_script_path => be_a_kind_of(String),
-            :script_arguments => "",
-            :cluster_type=>"persistent",
-            :use_spot_instances=>false
-          ) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
-
-          write_file(File.join(p.sparkscripts_path, "my_script.py"))
-          stderr, stdout = execute("spark sparkscripts/my_script.py --clustersize 4", p, @git)
-          puts stderr
-          stdout.should == <<-STDOUT
-Taking code snapshot... done
-Sending code snapshot to Mortar... done
-Requesting job execution... done
-job_id: c571a8c7f76a4fd4a67c103d753e2dd5
-
-Job status can be viewed on the web at:
-
- http://127.0.0.1:5000/jobs/spark_job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5
-
-STDOUT
-        end
-      end
-
-      it "runs a spark job with script_arguments existing cluster" do
-        with_git_initialized_project do |p|
-          # stub api requests
-          job_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
-          cluster_id = "c571a8c7f76a4fd4a67c103d753e2dd7"
-          job_url = "http://127.0.0.1:5000/jobs/spark_job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
-          script_arguments = "arg1 arg2 arg3"
-          mock(Mortar::Auth.api).post_spark_job_existing_cluster("myproject", "my_script.py", is_a(String), cluster_id,
-            :project_script_path => be_a_kind_of(String),
-            :script_arguments => script_arguments
-          ) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
-
-          write_file(File.join(p.sparkscripts_path, "my_script.py"))
-          stderr, stdout = execute("spark sparkscripts/my_script.py --clusterid #{cluster_id} #{script_arguments}", p, @git)
-          stdout.should == <<-STDOUT
-Taking code snapshot... done
-Sending code snapshot to Mortar... done
-Requesting job execution... done
-job_id: c571a8c7f76a4fd4a67c103d753e2dd5
-
-Job status can be viewed on the web at:
-
- http://127.0.0.1:5000/jobs/spark_job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5
-
-STDOUT
-        end
-      end
-
-      it "runs a spark job with on free cluster" do
-        with_git_initialized_project do |p|
-          # stub api requests
-          job_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
-          job_url = "http://127.0.0.1:5000/jobs/spark_job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
-          script_arguments = "arg1 arg2 arg3"
-
-          small_cluster_id = '510beb6b3004860820ab6538'
-          small_cluster_size = 2
-          small_cluster_status = Mortar::API::Clusters::STATUS_RUNNING
-          large_cluster_id = '510bf0db3004860820ab6590'
-          large_cluster_size = 5
-          large_cluster_status = Mortar::API::Clusters::STATUS_RUNNING
-          starting_cluster_id = '510bf0db3004860820abaaaa'
-          starting_cluster_size = 10
-          starting_cluster_status = Mortar::API::Clusters::STATUS_STARTING
-          huge_busy_cluster_id = '510bf0db3004860820ab6621'
-          huge_busy_cluster_size = 20
-          huge_busy_cluster_status = Mortar::API::Clusters::STATUS_RUNNING
-          
-
-          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2) {
-            Excon::Response.new(:body => { 
-              'clusters' => [
-                  { 'cluster_id' => small_cluster_id, 'size' => small_cluster_size, 'running_jobs' => [], 'status_code' => small_cluster_status }, 
-                  { 'cluster_id' => large_cluster_id, 'size' => large_cluster_size, 'running_jobs' => [], 'status_code' => large_cluster_status },
-                  { 'cluster_id' => starting_cluster_id, 'size' => starting_cluster_size, 'running_jobs' => [], 'status_code' => starting_cluster_status },
-                  { 'cluster_id' => huge_busy_cluster_id, 'size' => huge_busy_cluster_size, 
-                    'running_jobs' => [ { 'job_id' => 'c571a8c7f76a4fd4a67c103d753e2dd5',
-                       'job_name' => "", 'start_timestamp' => ""} ], 'status_code' => huge_busy_cluster_status  }
-              ]})
-          }
-
-          mock(Mortar::Auth.api).post_spark_job_existing_cluster("myproject", "my_script.py", is_a(String), large_cluster_id,
-            :project_script_path => be_a_kind_of(String),
-            :script_arguments => script_arguments
-          ) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
-
-          write_file(File.join(p.sparkscripts_path, "my_script.py"))
-          stderr, stdout = execute("spark sparkscripts/my_script.py #{script_arguments}", p, @git)
-          stdout.should == <<-STDOUT
-Taking code snapshot... done
-Sending code snapshot to Mortar... done
-Defaulting to running job on largest existing free cluster, id = 510bf0db3004860820ab6590, size = 5
-Requesting job execution... done
-job_id: c571a8c7f76a4fd4a67c103d753e2dd5
-
-Job status can be viewed on the web at:
-
- http://127.0.0.1:5000/jobs/spark_job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5
-
-STDOUT
-        end
-      end
-
-    end
-  end
-end