mortar 0.15.46 → 0.15.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d8e876d0197d938d81930eb95a59e98a82ce23b
-  data.tar.gz: 50f063a2016a1ad6ab4eaf9fed9df8a4bcd76a01
+  metadata.gz: c7a981fb03efa2e8eca07f34e215b5a46a9bf297
+  data.tar.gz: 515d42fa8b43d9033e05bbddaea2d1090a27b583
 SHA512:
-  metadata.gz: 0a5b4a64bfe460cb7568021eccb5238bccd2db1abb16ca0fee9bebb4cf14a9ff4f693b0bb83fd947c7ffcc3eb6aaa721f61badaf2b01610203da39cd0bfd47cd
-  data.tar.gz: f3263b4f877a7b4b2665195d4c2fd8cdf6034dfcad7647f5b54b8954d78e8a6d222fa4c757e178b0f78701453342b2896b15619176fda3c35140d97767ec2c5a
+  metadata.gz: 4940e4462c82f588dfcf1f90d4b12c7db48bdd87d1e69cda97c1ea8f28eab8b82995aef9f45a3c8f1a8b9004c176fe9717cb7e50df3f0cf10dc18043710b331e
+  data.tar.gz: 77ef37837fc0e9596fb4e73ba18b1aea3141868119a19c31dc898ec88efc2a10b8808e3b708032f43beacfefda7929e4ca5d24f5735866dedf7df0ee15c53806

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-Hadoop-2")
+      line.gsub!("<PIG_VERSION_OPTIONS>", "0.12-Hadoop-2.7.3")
     end
   end
 
@@ -608,7 +608,7 @@ protected
   end
 
   def pig_version
-    pig_version_str = options[:pigversion] || '0.12-Hadoop-2'
+    pig_version_str = options[:pigversion] || '0.12-Hadoop-2.7.3'
     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::Pig012Hadoop2.new
+      pig_version = Mortar::PigVersion::Pig012Hadoop273.new
     end
 
     java = Mortar::Local::Java.new()

data/lib/mortar/local/pig.rb

@@ -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::Pig012Hadoop2.new
+      pig_version = Mortar::PigVersion::Pig012Hadoop273.new
     end
     [ "#{pig_directory(pig_version)}/*",
       "#{pig_directory(pig_version)}/lib-local/*",

data/lib/mortar/pigversion.rb

@@ -16,20 +16,22 @@
 
 module Mortar
     module PigVersion
-        PIG_0_12_HADOOP_2_TGZ_NAME = "pig-0.12-hadoop-2.tar.gz"
+        PIG_0_12_HADOOP_2_TGZ_NAME = "pig-0.12-Hadoop-2.7.3.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'
-                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."
+                raise ArgumentError, "Our Hadoop 1 clusters are no longer supported by EMR.  Please use the default version of Pig: 0.12-Hadoop-2.7.3.  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 
+                raise ArgumentError, "EMR 3 is no longer supported. Please use the default version of Pig: 0.12-Hadoop-2.7.3.  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.7.3'
+                return Pig012Hadoop273.new
             else
-                raise ArgumentError, "Unsupported pig version: #{pig_version_str}.  Options are: ['0.12-Hadoop-2]."
+                raise ArgumentError, "Unsupported pig version: #{pig_version_str}.  Options are: ['0.12-Hadoop-2.7.3']."
             end
         end
 
-        class Pig012Hadoop2
+        class Pig012Hadoop273
             def tgz_name
                 PIG_0_12_HADOOP_2_TGZ_NAME
             end
@@ -43,7 +45,7 @@ module Mortar
             end
 
             def version
-                "0.12-Hadoop-2"
+                "0.12-Hadoop-2.7.3"
             end
 
             def pig_version
@@ -51,7 +53,7 @@ module Mortar
             end
 
             def cluster_backend
-                Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2
+                Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2_7_3
             end
         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-Hadoop-2
-pigversion=0.12-Hadoop-2
+# Default new projects to using Pig 0.12-Hadoop-2.7.3
+pigversion=0.12-Hadoop-2.7.3

data/lib/mortar/version.rb

@@ -16,5 +16,5 @@
 
 module Mortar
   # see http://semver.org/
-  VERSION = "0.15.46"
+  VERSION = "0.15.47"
 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-Hadoop-2'
+        lines.join("").should == 'linestart 0.12-Hadoop-2.7.3'
       end
     end
 
@@ -147,7 +147,7 @@ other\tgit@github.com:other.git (push)
         with_git_initialized_project do |p|
           text = """
 [DEFAULTS]
-pigversion=0.12-Hadoop-2
+pigversion=0.12-Hadoop-2.7.3
 
 [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-Hadoop-2"}
+          b.options.should == {:pigversion => "0.12-Hadoop-2.7.3"}
         end
       end
 
@@ -166,7 +166,7 @@ no_browser=true
         with_git_initialized_project do |p|
           text = """
 [DEFAULTS]
-pigversion=0.12-Hadoop-2
+pigversion=0.12-Hadoop-2.7.3
 
 [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-Hadoop-2", :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.7.3", :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-Hadoop-2", :polling_interval => "0.05"}
+          d.options.should == {:pigversion => "0.12-Hadoop-2.7.3", :polling_interval => "0.05"}
         end
       end
 
@@ -194,7 +194,7 @@ no_browser=true
         with_git_initialized_project do |p|
           text = """
 [DEFAULTS]
-pigversion=0.12-Hadoop-2
+pigversion=0.12-Hadoop-2.7.3
 
 [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-Hadoop-2", :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.7.3", :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-Hadoop-2", :polling_interval => "0.05", :no_browser => true}
+          d.options.should == {:pigversion => "0.12-Hadoop-2.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2
+pigversion=0.12-Hadoop-2.7.3
 """
           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-Hadoop-2", :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.7.3", :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-Hadoop-2"}
+          d.options.should == {:polling_interval => "0.05", :no_browser => true, :clustersize => "5", :pigversion => "0.12-Hadoop-2.7.3"}
         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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2",
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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-Hadoop-2", 
+                                                      :pig_version => "0.12-Hadoop-2.7.3",
                                                       :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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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-Hadoop-2", 
+              :pig_version => "0.12-Hadoop-2.7.3",
               :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-Hadoop-2", 
+              :pig_version => "0.12-Hadoop-2.7.3",
               :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_2) {Excon::Response.new(:body => {'clusters' => []})}
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2_7_3) {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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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_2) {Excon::Response.new(:body => {'clusters' => []})}
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2_7_3) {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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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-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})}
+          mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :pig_version => "0.12-Hadoop-2.7.3", :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_2) {
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2_7_3) {
             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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :notify_on_job_finish => true,
@@ -458,7 +458,7 @@ STDOUT
           huge_busy_cluster_status = Mortar::API::Clusters::STATUS_RUNNING
 
 
-          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2) {
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2_7_3) {
             Excon::Response.new(:body => {
               'clusters' => [
                 { 'cluster_id' => small_cluster_id, 'size' => small_cluster_size, 'running_jobs' => [], 'status_code' => small_cluster_status, 'tags' => ['small'] },
@@ -470,7 +470,7 @@ STDOUT
               ]})
           }
           mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), large_cluster_id,
-            :pig_version => "0.12-Hadoop-2",
+            :pig_version => "0.12-Hadoop-2.7.3",
             :project_script_path => be_a_kind_of(String),
             :parameters => [],
             :notify_on_job_finish => true,
@@ -510,7 +510,7 @@ Or by running:
           large_h2_cluster_size = 5
           large_h2_cluster_status = Mortar::API::Clusters::STATUS_RUNNING
 
-          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2) {
+          mock(Mortar::Auth.api).get_clusters(Mortar::API::Jobs::CLUSTER_BACKEND__EMR_HADOOP_2_7_3) {
             Excon::Response.new(:body => {
               'clusters' => [
                   { 'cluster_id' => small_h2_cluster_id, 'size' => small_h2_cluster_size, 'running_jobs' => [], 'status_code' => small_h2_cluster_status },
@@ -518,14 +518,14 @@ Or by running:
               ]})
           }
           mock(Mortar::Auth.api).post_pig_job_existing_cluster("myproject", "my_script", is_a(String), large_h2_cluster_id,
-            :pig_version => "0.12-Hadoop-2",
+            :pig_version => "0.12-Hadoop-2.7.3",
             :project_script_path => be_a_kind_of(String),
             :parameters => [],
             :notify_on_job_finish => true,
             :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 -g 0.12-Hadoop-2", p, @git)
+          stderr, stdout = execute("jobs:run pigscripts/my_script.pig -g 0.12-Hadoop-2.7.3", p, @git)
           stdout.should == <<-STDOUT
 Defaulting to running job on largest existing free cluster, id = 510bf0db3004860820ab6590, size = 5
 Taking code snapshot... done
@@ -552,7 +552,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-Hadoop-2",
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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,
@@ -580,7 +580,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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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,
@@ -636,7 +636,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-Hadoop-2", 
+            :pig_version => "0.12-Hadoop-2.7.3",
             :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::Pig012Hadoop2), [], false, false).returns(nil)
+            mock(u).illustrate(pigscript, "some_alias", is_a(Mortar::PigVersion::Pig012Hadoop273), [], 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::Pig012Hadoop2), [], false, false).returns(nil)
+            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012Hadoop273), [], false, false).returns(nil)
           end
-          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12-Hadoop-2", p)
+          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12-Hadoop-2.7.3", 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::Pig012Hadoop2), [{"name"=>"first", "value"=>1},{"name"=>"second", "value"=>2}], false, false).returns(nil)
+            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012Hadoop273), [{"name"=>"first", "value"=>1},{"name"=>"second", "value"=>2}], false, false).returns(nil)
           end
-          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12-Hadoop-2", p)
+          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12-Hadoop-2.7.3", p)
           stderr.should == ""
         end
       end
@@ -125,9 +125,9 @@ STDERR
             mock(u).config_parameters.returns([])
           end
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).run(pigscript, is_a(Mortar::PigVersion::Pig012Hadoop2), []).returns(nil)
+            mock(u).run(pigscript, is_a(Mortar::PigVersion::Pig012Hadoop273), []).returns(nil)
           end
-          stderr, stdout = execute("local:run pigscripts/#{script_name}.pig -g 0.12-Hadoop-2", p)
+          stderr, stdout = execute("local:run pigscripts/#{script_name}.pig -g 0.12-Hadoop-2.7.3", 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::Pig012Hadoop2), 'validate')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop273), 'validate')
           end
           any_instance_of(Mortar::Local::Pig) do |u|
-            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012Hadoop2), [{"key"=>"k", "value"=>"v"}])
+            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012Hadoop273), [{"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::Pig012Hadoop2), 'validate')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop273), 'validate')
           end
           any_instance_of(Mortar::Local::Pig) do |u|
-            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012Hadoop2), [])
+            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig012Hadoop273), [])
           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::Pig012Hadoop2),'luigi')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop273),'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::Pig012Hadoop2),'luigi')
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig012Hadoop273),'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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", :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.7.3", :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-Hadoop-2", p, @git)
+        stderr, stdout = execute("validate my_script --polling_interval 0.05 -p key=value -g 0.12-Hadoop-2.7.3", 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::Pig012Hadoop2), nil)
+          mock(p).install_or_update(is_a(Mortar::PigVersion::Pig012Hadoop273), 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-Hadoop-2", "run")
+        mock(c).install_and_configure("0.12-Hadoop-2.7.3", "run")
         test_script = "foobar-script"
         the_parameters = []
         any_instance_of(Mortar::Local::Pig) do |p|
-          mock(p).run_script(test_script, "0.12-Hadoop-2", the_parameters)
+          mock(p).run_script(test_script, "0.12-Hadoop-2.7.3", the_parameters)
         end
-        c.run(test_script, "0.12-Hadoop-2", the_parameters)
+        c.run(test_script, "0.12-Hadoop-2.7.3", 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-Hadoop-2", "illustrate")
+        mock(c).install_and_configure("0.12-Hadoop-2.7.3", "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-Hadoop-2", the_parameters)
+          mock(p).illustrate_alias(test_script, script_alias, prune, no_browser, "0.12-Hadoop-2.7.3", the_parameters)
         end
-        c.illustrate(test_script, script_alias, "0.12-Hadoop-2", the_parameters, prune, no_browser)
+        c.illustrate(test_script, script_alias, "0.12-Hadoop-2.7.3", the_parameters, prune, no_browser)
       end
     end
 

data/spec/mortar/local/pig_spec.rb

@@ -35,7 +35,7 @@ module Mortar::Local
         # chmods bin/pig, removes tgz, and notes the installation
         FakeFS do
           pig = Mortar::Local::Pig.new
-          pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
+          pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop273.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
@@ -61,7 +61,7 @@ module Mortar::Local
 
       it "does nothing if existing install and no update available" do
         pig = Mortar::Local::Pig.new
-        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
+        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop273.new
 
         mock(pig).should_do_pig_install?(pig012Hadoop2).returns(false)
         mock(pig).should_do_pig_update?(pig012Hadoop2, nil).returns(false)
@@ -79,7 +79,7 @@ module Mortar::Local
 
       it "does install if none has been done before" do
         pig = Mortar::Local::Pig.new
-        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
+        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop273.new
 
         mock(pig).should_do_pig_install?(pig012Hadoop2).returns(true)
         mock(pig).should_do_lib_install?.returns(true)
@@ -93,7 +93,7 @@ module Mortar::Local
 
       it "does install if one was done before but there is an update" do
         pig = Mortar::Local::Pig.new
-        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop2.new
+        pig012Hadoop2 = Mortar::PigVersion::Pig012Hadoop273.new
 
         mock(pig).should_do_pig_install?(pig012Hadoop2).returns(false)
         mock(pig).should_do_pig_update?(pig012Hadoop2, nil).returns(true)
@@ -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-Hadoop-2", [])
+        pig.illustrate_alias(script, 'my_alias', false, false, "0.12-Hadoop-2.7.3", [])
       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-Hadoop-2", [])
+        pig.illustrate_alias(script, 'my_alias', false, true, "0.12-Hadoop-2.7.3", [])
       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-Hadoop-2", [])
+        pig.illustrate_alias(script, 'my_alias', false, false, "0.12-Hadoop-2.7.3", [])
       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-Hadoop-2", [])
+        pig.illustrate_alias(script, 'my_alias', false, false, "0.12-Hadoop-2.7.3", [])
       end
 
     end
@@ -266,9 +266,9 @@ module Mortar::Local
         expect(tpc.include?("pig-0.12")).to be_true
       end
 
-      it "Works with 0.12-Hadoop-2 pig" do
+      it "Works with 0.12-Hadoop-2.7.3 pig" do
         pig = Mortar::Local::Pig.new
-        tpc = pig.template_params_classpath(Mortar::PigVersion::Pig012Hadoop2.new)
+        tpc = pig.template_params_classpath(Mortar::PigVersion::Pig012Hadoop273.new)
         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.46
+  version: 0.15.47
 platform: ruby
 authors:
 - Mortar Data
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-08 00:00:00.000000000 Z
+date: 2017-10-11 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.15
+        version: 0.8.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.15
+        version: 0.8.16
 - !ruby/object:Gem::Dependency
   name: netrc
   requirement: !ruby/object:Gem::Requirement