mortar 0.15.29 → 0.15.30

data/lib/mortar/conf/luigi/logging.ini

@@ -9,7 +9,7 @@ keys=console
 keys=standard,plain        
 
 [logger_root]
-level=WARNING
+level=INFO
 handlers=console
 
 [logger_luigi-interface]

data/lib/mortar/local/controller.rb

@@ -90,7 +90,7 @@ EOF
       if !auth.has_credentials                      
         error(NO_AWS_KEYS_ERROR_MESSAGE)
       else
-        vars = fetch_aws_keys(auth, Mortar::Command::Base.new)
+        vars = fetch_aws_keys(auth)
         if vars['aws_access_key_id'] && vars['aws_secret_access_key']
           set_aws_keys(vars['aws_access_key_id'], vars['aws_secret_access_key'])
         else
@@ -101,9 +101,8 @@ EOF
   end
 
   # Fetches AWS Keys based on auth
-  def fetch_aws_keys(auth, base)    
-    project = base.project    
-    project_name = base.options[:project] || project.name    
+  def fetch_aws_keys(auth)
+    project_name = ENV['MORTAR_PROJECT_NAME']
     return auth.api.get_config_vars(project_name).body['config']
   end
 
@@ -111,11 +110,20 @@ EOF
     ENV['AWS_ACCESS_KEY'] = aws_access_key
     ENV['AWS_SECRET_KEY'] = aws_secret_key    
   end
-  
+
+  def set_project_name(base)
+    project = base.project    
+    project_name = base.options[:project] || project.name
+    ENV['MORTAR_PROJECT_NAME'] = project_name
+  end
   # Main entry point to perform installation and configuration necessary
   # to run pig on the users local machine
   def install_and_configure(pig_version=nil, command=nil, install_sqoop=false)
     #To support old watchtower plugins we'll accept nil pig_version
+    base = Mortar::Command::Base.new
+    set_project_name(base)
+    require_aws_keys()
+
     if pig_version.nil?
       pig_version = Mortar::PigVersion::Pig09.new
     end
@@ -204,7 +212,6 @@ README
 
   # Main entry point for user running a pig script
   def run(pig_script, pig_version, pig_parameters)
-    require_aws_keys
     install_and_configure(pig_version, 'run')
     pig = Mortar::Local::Pig.new()
     pig.run_script(pig_script, pig_version, pig_parameters)
@@ -212,7 +219,6 @@ README
 
   # Main entry point for illustrating a pig alias
   def illustrate(pig_script, pig_alias, pig_version, pig_parameters, skip_pruning, no_browser)
-    require_aws_keys
     install_and_configure(pig_version, 'illustrate')
     pig = Mortar::Local::Pig.new()
     pig.illustrate_alias(pig_script, pig_alias, skip_pruning, no_browser, pig_version, pig_parameters)
@@ -231,7 +237,6 @@ README
   end
 
   def run_luigi(pig_version, luigi_script, luigi_script_parameters, project_config_parameters)
-    require_aws_keys
     install_and_configure(pig_version, 'luigi')
     py = Mortar::Local::Python.new()
     unless py.run_stillson_luigi_client_cfg_expansion(luigi_script, project_config_parameters)
@@ -241,7 +246,6 @@ README
   end
 
   def sqoop_export_table(pig_version, connstr, dbtable, s3dest, options)
-    require_aws_keys
     install_and_configure(pig_version, 'sqoop', true)
     sqoop = Mortar::Local::Sqoop.new()
     options[:dbtable] = dbtable
@@ -249,7 +253,6 @@ README
   end
 
   def sqoop_export_query(pig_version, connstr, query, s3dest, options)
-    require_aws_keys
     install_and_configure(pig_version, 'sqoop', true)
     sqoop = Mortar::Local::Sqoop.new()
     options[:sqlquery] = sqoop.prep_query(query)
@@ -257,7 +260,6 @@ README
   end
 
   def sqoop_export_incremental(pig_version, connstr, dbtable, column, max_value, s3dest, options)
-    require_aws_keys
     install_and_configure(pig_version, 'sqoop', true)
     sqoop = Mortar::Local::Sqoop.new()
     options[:dbtable] = dbtable

data/lib/mortar/local/params.rb

@@ -49,6 +49,8 @@ module Mortar
         params['AWS_SECRET_KEY'] = ENV['AWS_SECRET_KEY']
         params['AWS_SECRET_ACCESS_KEY'] = ENV['AWS_SECRET_KEY']
         params['aws_secret_access_key'] = ENV['AWS_SECRET_KEY']
+
+        params['MORTAR_PROJECT_NAME'] = ENV['MORTAR_PROJECT_NAME']
         
         param_list = params.map do |k,v|
           {"name" => k, "value" => v}

data/lib/mortar/templates/project/luigiscripts/client.cfg.template

@@ -23,6 +23,7 @@
 email: ${MORTAR_EMAIL}
 api_key: ${MORTAR_API_KEY}
 host: api.mortardata.com
+project_name: ${MORTAR_PROJECT_NAME}
 
 # 
 # AWS credentials to check for completed output

data/lib/mortar/templates/project/luigiscripts/luigiscript.py

@@ -4,131 +4,144 @@ from luigi.s3 import S3Target, S3PathTask
 
 from mortar.luigi import mortartask
 
+import logging
+
 """
-  Luigi is a powerful, easy-to-use framework for building data pipelines.
+Luigi is a powerful, easy-to-use framework for building data pipelines.
 
-  This is an example Luigi script to get you started. This script has a 
-  'fill in the blank' interaction. Feel free to alter it to build your pipeline.
+This is an example Luigi script to get you started. This script has a 
+'fill in the blank' interaction. Feel free to alter it to build your pipeline.
 
-  In this example we will run a Pig script, and then shutdown any clusters associated
-  with that script.  We will do that by running the ShutdownClusters Task,
-  which is dependent on RunMyExamplePigScript Task. This means the cluster will only 
-  shutdown after RunMyExamplePigScript (where the data transformation happens) 
-  Task is completed.
+In this example we will run a Pig script, and then shutdown any clusters associated
+with that script.  We will do that by running the ShutdownClusters Task,
+which is dependent on RunMyExamplePigScript Task. This means the cluster will only 
+shutdown after RunMyExamplePigScript (where the data transformation happens) 
+Task is completed.
 
-  For full tutorials and in-depth Luigi documentation, visit:
-  https://help.mortardata.com/technologies/luigi
+For full tutorials and in-depth Luigi documentation, visit:
+https://help.mortardata.com/technologies/luigi
 
-  To Run:
-    mortar luigi luigiscripts/<%= project_name %>_luigi.py \
+To Run:
+mortar luigi luigiscripts/<%= project_name %>_luigi.py \
     --output-base-path "s3://mortar-example-output-data/<your_username_here>/<%= project_name %>"
 """
 
 MORTAR_PROJECT = '<%= project_name %>'
 
+"""
+This logger outputs logs to Mortar Logs. An example of it's usage can be seen
+in the ShutdownClusters function.
+"""
+logger = logging.getLogger('luigi-interface')
+
 # helper function
 def create_full_path(base_path, sub_path):
-  return '%s/%s' % (base_path, sub_path)
+    return '%s/%s' % (base_path, sub_path)
 
 class RunMyExamplePigScript(mortartask.MortarProjectPigscriptTask):
-  """
-  This is a Luigi Task that extends MortarProjectPigscriptTask to run a Pig
-  script on Mortar.
-  """
-
-  """
-  The location in S3 where the output of the Mortar job will be written.
-  """
-  output_base_path = luigi.Parameter() 
-
-  """
-  Default cluster size to use for running Mortar jobs.  A cluster size of 0
-  will run in Mortar's local mode.  This is a fast (and free!) way to run jobs
-  on small data samples.  Cluster sizes >= 2 will run on a Hadoop cluster.
-  """
-  cluster_size = luigi.IntParameter(default=0)
-
-  """
-  Path to input data being analyzed using the Pig script.
-  """
-  input_path = luigi.Parameter(default ='s3://mortar-example-data/tutorial/excite.log.bz2')
-
-
-  def requires(self):
     """
-    The requires method specifies a list of other Tasks that must be complete
-    for this Task to run. In this case, we want to require that our input
-    exists on S3 before we run the script. S3PathTask validates that the
-    specified file or directory exists on S3.
+    This is a Luigi Task that extends MortarProjectPigscriptTask to run a Pig
+    script on Mortar.
     """
-    return [S3PathTask(self.input_path)]
 
-  def project(self):
     """
-    Name of Mortar Project to run.
+    The location in S3 where the output of the Mortar job will be written.
     """
-    return MORTAR_PROJECT
+    output_base_path = luigi.Parameter() 
 
-  def script_output(self):
-    """
-    The script_output method is how you define where the output from this task
-    will be stored. Luigi will check this output location before starting any
-    tasks that depend on this task.
-    """
-    return[S3Target(self.output_base_path + '/pigoutput')]
-  
-  def token_path(self):
     """
-    Luigi manages dependencies between tasks by checking for the existence of
-    files.  When one task finishes it writes out a 'token' file that will
-    trigger the next task in the dependency graph.  This is the base path for
-    where those tokens will be written.
+    Default cluster size to use for running Mortar jobs.  A cluster size of 0
+    will run in Mortar's local mode.  This is a fast (and free!) way to run jobs
+    on small data samples.  Cluster sizes >= 2 will run on a Hadoop cluster.
     """
-    return self.output_base_path
-  
-  def parameters(self):
+    cluster_size = luigi.IntParameter(default=0)
+
     """
-    Parameters for this pig job.
+    Path to input data being analyzed using the Pig script.
     """
-    return {'INPUT_PATH': self.input_path,
+    input_path = luigi.Parameter(default ='s3://mortar-example-data/tutorial/excite.log.bz2')
+
+
+    def requires(self):
+        """
+        The requires method specifies a list of other Tasks that must be complete
+        for this Task to run. In this case, we want to require that our input
+        exists on S3 before we run the script. S3PathTask validates that the
+        specified file or directory exists on S3.
+        """
+        return [S3PathTask(self.input_path)]
+
+    def project(self):
+        """
+        Name of Mortar Project to run.
+        """
+        return MORTAR_PROJECT
+
+    def script_output(self):
+        """
+        The script_output method is how you define where the output from this task
+        will be stored. Luigi will check this output location before starting any
+        tasks that depend on this task.
+        """
+        return[S3Target(self.output_base_path + '/pigoutput')]
+
+    def token_path(self):
+        """
+        Luigi manages dependencies between tasks by checking for the existence of
+        files.  When one task finishes it writes out a 'token' file that will
+        trigger the next task in the dependency graph.  This is the base path for
+        where those tokens will be written.
+        """
+        return self.output_base_path
+
+    def parameters(self):
+        """
+        Parameters for this pig job.
+        """
+        return {'INPUT_PATH': self.input_path,
             'OUTPUT_PATH': self.output_base_path + '/pigoutput'}
-  
-  def script(self):
-    """
-    Name of Pig script to run.
-    """
-    return '<%= project_name %>'
+
+    def script(self):
+        """
+        Name of Pig script to run.
+        """
+        return '<%= project_name %>'
 
 
 class ShutdownClusters(mortartask.MortarClusterShutdownTask):
-  """
-  When the pipeline is completed, this task shuts down all active clusters not
-  currently running jobs. As this task is only shutting down clusters and not
-  generating any output data, this S3 location is used to store a 'token' file
-  indicating when the task has been completed.
-  """
-  output_base_path = luigi.Parameter() 
-
-  def requires(self):
     """
-    The ShutdownClusters task is dependent on RunMyExamplePigScript because a
-    cluster should not shut down until all the tasks are completed. You can
-    think of this as saying 'shut down my cluster after running my task'.
+    When the pipeline is completed, this task shuts down all active clusters not
+    currently running jobs. As this task is only shutting down clusters and not
+    generating any output data, this S3 location is used to store a 'token' file
+    indicating when the task has been completed.
     """
-    return RunMyExamplePigScript(output_base_path = self.output_base_path)
+    output_base_path = luigi.Parameter() 
 
-  def output(self):
-    """
-    This output statement is needed because ShutdownClusters has no actual
-    output. We write a token with the class name to S3 to know that this task
-    has completed and it does not need to be run again.
-    """
-    return [S3Target((create_full_path(self.output_base_path, 'ShutdownClusters')))]
+    def requires(self):
+        """
+        The ShutdownClusters task is dependent on RunMyExamplePigScript because a
+        cluster should not shut down until all the tasks are completed. You can
+        think of this as saying 'shut down my cluster after running my task'.
+        """
+
+
+        # This is an example of emitting log messages.
+        logger.info('My Log Message!')
+
+        return RunMyExamplePigScript(output_base_path = self.output_base_path)
+
+    def output(self):
+        """
+        This output statement is needed because ShutdownClusters has no actual
+        output. We write a token with the class name to S3 to know that this task
+        has completed and it does not need to be run again.
+        """
+        return [S3Target((create_full_path(self.output_base_path, 'ShutdownClusters')))]
 
 if __name__ == "__main__":
-  """
-  The final task in your pipeline, which will in turn pull in any dependencies
-  need to be run should be called in the main method. In this case ShutdownClusters
-  is being called.
-  """
-  luigi.run(main_task_cls= ShutdownClusters)
+    """
+    The final task in your pipeline, which will in turn pull in any dependencies
+    need to be run should be called in the main method. In this case ShutdownClusters
+    is being called.
+    """
+    luigi.run(main_task_cls= ShutdownClusters)

data/lib/mortar/updater.rb

@@ -28,7 +28,11 @@ module Mortar
     def self.get_newest_version
       begin
         require "excon"
-        gem_data = Mortar::Helpers.json_decode(Excon.get('http://rubygems.org/api/v1/gems/mortar.json', {:connect_timeout => CONNECT_TIMEOUT, :read_timeout => READ_TIMEOUT}).body)
+        gem_data = Mortar::Helpers.json_decode(
+          Excon.get('https://rubygems.org/api/v1/gems/mortar.json', 
+            {:connect_timeout => CONNECT_TIMEOUT, 
+             :read_timeout => READ_TIMEOUT, 
+             :ssl_version => :TLSv1}).body)
         gem_data.default = "0.0.0"
         gem_data['version']
       rescue Exception => e

data/lib/mortar/version.rb

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

data/spec/mortar/auth_spec.rb

@@ -34,7 +34,9 @@ module Mortar
 
       FakeFS.activate!
       
-      stub(my_mode_output = Object.new).mode {"0600".to_i(8)}
+      my_mode_output = Object.new
+      stub(my_mode_output).mode {"0600".to_i(8)}
+      stub(my_mode_output).readable? {true}
       stub(FakeFS::File).stat {my_mode_output}
       stub(FakeFS::FileUtils).chmod
       stub(FakeFS::File).readlines do |path|
@@ -95,7 +97,9 @@ module Mortar
       stub(@cli).check
       #@cli.should_receive(:check_for_associated_ssh_key)
       @cli.reauthorize
-      Netrc.read(@cli.netrc_path)["api.#{@cli.host}"].should == (['one', 'two'])
+      netrc_response = Netrc.read(@cli.netrc_path)["api.#{@cli.host}"]
+      netrc_response[0].should == 'one'
+      netrc_response[1].should == 'two'
     end
 
     it "prompts for github_username when user doesn't have one." do

data/spec/mortar/command/local_spec.rb

@@ -161,60 +161,72 @@ PARAMS
     end
 
     context("configure") do
-
       it "errors if the project root doesn't exist or we can't cd there" do
         stderr, stdout = execute("local:configure --project-root /foo/baz")
         stderr.should == " !    No such directory /foo/baz\n"
       end
 
       it "errors if java can't be found" do
-        any_instance_of(Mortar::Local::Java) do |j|
-          stub(j).check_install.returns(false)
+        ENV['AWS_ACCESS_KEY'] = "foo"
+        ENV['AWS_SECRET_KEY'] = "BAR"
+        with_git_initialized_project do |p|
+          any_instance_of(Mortar::Local::Java) do |j|
+            stub(j).check_install.returns(false)
+          end
+
+          stderr, stdout = execute("local:configure")
+          stderr.should == Mortar::Local::Controller::NO_JAVA_ERROR_MESSAGE.gsub(/^/, " !    ")
         end
-        stderr, stdout = execute("local:configure")
-        stderr.should == Mortar::Local::Controller::NO_JAVA_ERROR_MESSAGE.gsub(/^/, " !    ")
       end
 
       it "errors if python can't be found" do
-        any_instance_of(Mortar::Local::Java) do |j|
-          stub(j).check_install.returns(true)
-        end
-        any_instance_of(Mortar::Local::Pig) do |j|
-          stub(j).install_pig.returns(true)
-          stub(j).install_lib.returns(true)
-        end
-        any_instance_of(Mortar::Local::Python) do |j|
-          stub(j).check_or_install.returns(false)
+        ENV['AWS_ACCESS_KEY'] = "foo"
+        ENV['AWS_SECRET_KEY'] = "BAR"
+        with_git_initialized_project do |p|
+          any_instance_of(Mortar::Local::Java) do |j|
+            stub(j).check_install.returns(true)
+          end
+          any_instance_of(Mortar::Local::Pig) do |j|
+            stub(j).install_pig.returns(true)
+            stub(j).install_lib.returns(true)
+          end
+          any_instance_of(Mortar::Local::Python) do |j|
+            stub(j).check_or_install.returns(false)
+          end
+          stderr, stdout = execute("local:configure")
+          stderr.should == Mortar::Local::Controller::NO_PYTHON_ERROR_MESSAGE.gsub(/^/, " !    ")
         end
-        stderr, stdout = execute("local:configure")
-        stderr.should == Mortar::Local::Controller::NO_PYTHON_ERROR_MESSAGE.gsub(/^/, " !    ")
       end
 
       it "checks for java, installs pig/python, and configures a virtualenv" do
-        any_instance_of(Mortar::Local::Java) do |j|
-          mock(j).check_install.returns(true)
-        end
-        any_instance_of(Mortar::Local::Pig) do |j|
-          mock(j).install_pig.with_any_args.returns(true)
-          stub(j).install_lib.returns(true)
-        end
-        any_instance_of(Mortar::Local::Python) do |j|
-          mock(j).check_or_install.returns(true)
-          mock(j).check_virtualenv.returns(true)
-          mock(j).setup_project_python_environment.returns(true)
-        end
-        any_instance_of(Mortar::Local::Jython) do |j|
-          mock(j).install_or_update.returns(true)
-        end
-        any_instance_of(Mortar::Local::Sqoop) do |j|
-          mock(j).install_or_update.returns(true)
-        end
-        any_instance_of(Mortar::Local::Controller) do |j|
-          mock(j).write_local_readme
-          mock(j).ensure_local_install_dirs_in_gitignore.returns(true)
+        ENV['AWS_ACCESS_KEY'] = "foo"
+        ENV['AWS_SECRET_KEY'] = "BAR"
+        with_git_initialized_project do |p|
+          any_instance_of(Mortar::Local::Java) do |j|
+            mock(j).check_install.returns(true)
+          end
+          any_instance_of(Mortar::Local::Pig) do |j|
+            mock(j).install_pig.with_any_args.returns(true)
+            stub(j).install_lib.returns(true)
+          end
+          any_instance_of(Mortar::Local::Python) do |j|
+            mock(j).check_or_install.returns(true)
+            mock(j).check_virtualenv.returns(true)
+            mock(j).setup_project_python_environment.returns(true)
+          end
+          any_instance_of(Mortar::Local::Jython) do |j|
+            mock(j).install_or_update.returns(true)
+          end
+          any_instance_of(Mortar::Local::Sqoop) do |j|
+            mock(j).install_or_update.returns(true)
+          end
+          any_instance_of(Mortar::Local::Controller) do |j|
+            mock(j).write_local_readme
+            mock(j).ensure_local_install_dirs_in_gitignore.returns(true)
+          end
+          stderr, stdout = execute("local:configure")
+          stderr.should == ""
         end
-        stderr, stdout = execute("local:configure")
-        stderr.should == ""
       end
 
     # configure
@@ -307,7 +319,6 @@ STDERR
           end
           any_instance_of(Mortar::Local::Controller) do |u|
             mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig09),'luigi')
-            mock(u).require_aws_keys()
           end
           any_instance_of(Mortar::Command::Local) do |u|
             mock(u).sync_code_with_cloud().returns("some-git-ref")
@@ -339,7 +350,6 @@ STDERR
           end
           any_instance_of(Mortar::Local::Controller) do |u|
             mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig09),'luigi')
-            mock(u).require_aws_keys()
           end
           any_instance_of(Mortar::Command::Local) do |u|
             mock(u).sync_code_with_cloud().returns("some-git-ref")

data/spec/mortar/local/controller_spec.rb

@@ -29,6 +29,7 @@ module Mortar::Local
       stub_core
       ENV['AWS_ACCESS_KEY'] = "foo"
       ENV['AWS_SECRET_KEY'] = "BAR"
+      ENV['MORTAR_PROJECT_NAME'] ='projectName'
     end
 
     context("aws keys") do        
@@ -50,8 +51,7 @@ module Mortar::Local
         ctrl = Mortar::Local::Controller.new
         previous_stderr, $stderr = $stderr, StringIO.new
         mock(Mortar::Auth).has_credentials{true}
-        stub(Mortar::Command::Base).new {'base'}
-        mock(ctrl).fetch_aws_keys(Mortar::Auth, 'base'){{}}
+        mock(ctrl).fetch_aws_keys(Mortar::Auth){{}}
         begin
           expect { ctrl.require_aws_keys }.to raise_error(SystemExit)
           $stderr.string.should eq(Mortar::Local::Controller::API_CONFIG_ERROR_MESSAGE.gsub(/^/, " !    "))
@@ -74,10 +74,9 @@ module Mortar::Local
       it "sets fetches and sets aws keys if missing and logged in" do
         ENV.delete('AWS_ACCESS_KEY')
         ctrl = Mortar::Local::Controller.new
-        stub(Mortar::Command::Base).new {'base'}
         stub(Mortar::Auth).has_credentials{true}
         previous_stderr, $stderr = $stderr, StringIO.new
-        mock(ctrl).fetch_aws_keys(Mortar::Auth, 'base'){ 
+        mock(ctrl).fetch_aws_keys(Mortar::Auth){ 
           {
             "aws_access_key_id"=>"key_id", 
             "aws_secret_access_key"=>"secret"
@@ -93,26 +92,21 @@ module Mortar::Local
         end
       end
 
-
-    
       it "fetches aws keys" do
         ctrl = Mortar::Local::Controller.new
-        auth = Mortar::Auth        
-        
+        auth = Mortar::Auth
 
         with_blank_project do
-          base = Mortar::Command::Base.new             
           with_git_initialized_project do |p|
             # stub api request
             configs = {}
-            mock(Mortar::Auth.api).get_config_vars("myproject").returns(Excon::Response.new(:body => {"config" => configs}))
+            mock(Mortar::Auth.api).get_config_vars("projectName").returns(Excon::Response.new(:body => {"config" => configs}))
             
-            ctrl.fetch_aws_keys(auth,base).should eq(configs)
+            ctrl.fetch_aws_keys(auth).should eq(configs)
           end          
         end        
       end
 
-
       it "returns if they are not present but override is in place" do
         ENV.delete('AWS_ACCESS_KEY')
         ENV['MORTAR_IGNORE_AWS_KEYS'] = 'true'
@@ -130,8 +124,13 @@ module Mortar::Local
 
     context("install_and_configure") do
       it "supplied default pig version" do
+        ENV.delete('MORTAR_PROJECT_NAME')
         ctrl = Mortar::Local::Controller.new
 
+        any_instance_of(Mortar::Command::Base) do |b|
+          mock(b).project.returns(Mortar::Project::Project)
+          mock(b).options.returns({:project =>'myproject'})
+        end
         any_instance_of(Mortar::Local::Java) do |j|
           mock(j).check_install.returns(true)
         end
@@ -150,12 +149,18 @@ module Mortar::Local
         mock(ctrl).write_local_readme
         mock(ctrl).ensure_local_install_dirs_in_gitignore
         ctrl.install_and_configure
+        ENV['MORTAR_PROJECT_NAME'].should eq('myproject')
       end
 
       it "install sqoop with command" do
+        ENV.delete('MORTAR_PROJECT_NAME')
         command = 'command'
         ctrl = Mortar::Local::Controller.new
 
+        any_instance_of(Mortar::Command::Base) do |b|
+          mock(b).project.returns(Mortar::Project::Project)
+          mock(b).options.returns({:project =>'myproject'})
+        end
         any_instance_of(Mortar::Local::Java) do |j|
           mock(j).check_install.returns(true)
         end
@@ -177,6 +182,9 @@ module Mortar::Local
         mock(ctrl).write_local_readme
         mock(ctrl).ensure_local_install_dirs_in_gitignore
         ctrl.install_and_configure(Mortar::PigVersion::Pig012.new, command, true)
+        begin
+          ENV['MORTAR_PROJECT_NAME'].should eq('myproject')
+        end
       end
     end
 
@@ -184,7 +192,6 @@ module Mortar::Local
 
       it "checks for aws keys, checks depenendency installation, runs script" do
         c = Mortar::Local::Controller.new
-        mock(c).require_aws_keys
         mock(c).install_and_configure("0.9", "run")
         test_script = "foobar-script"
         the_parameters = []
@@ -199,7 +206,6 @@ 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).require_aws_keys
         mock(c).install_and_configure("0.9", "illustrate")
         test_script = "foobar-script"
         script_alias = "some_alias"

data/spec/mortar/local/params_spec.rb

@@ -42,6 +42,7 @@ module Mortar::Local
       it "returns params for a logged-in user" do
         ENV['AWS_ACCESS_KEY'] = "abc"
         ENV['AWS_SECRET_KEY'] = "012"
+        ENV['MORTAR_PROJECT_NAME'] = "projectName"
 
         # setup fake auth
         stub_core
@@ -56,11 +57,13 @@ module Mortar::Local
         get_param_value(params, "AWS_SECRET_KEY").should == "012"
         get_param_value(params, "AWS_SECRET_ACCESS_KEY").should == "012"
         get_param_value(params, "aws_secret_access_key").should == "012"
+        get_param_value(params, "MORTAR_PROJECT_NAME").should =="projectName"
       end
 
       it "returns params for a non-logged-in user" do
         ENV['AWS_ACCESS_KEY'] = "abc"
         ENV['AWS_SECRET_KEY'] = "012"
+        ENV['MORTAR_PROJECT_NAME'] = "projectName"
 
         params = @params.automatic_parameters()
         get_param_value(params, "MORTAR_EMAIL").should == "notloggedin@user.org"
@@ -73,6 +76,7 @@ module Mortar::Local
         get_param_value(params, "AWS_SECRET_KEY").should == "012"
         get_param_value(params, "AWS_SECRET_ACCESS_KEY").should == "012"
         get_param_value(params, "aws_secret_access_key").should == "012"
+        get_param_value(params, "MORTAR_PROJECT_NAME").should =="projectName"
       end
     end
 

data/spec/mortar/updater_spec.rb

@@ -46,21 +46,21 @@ module Mortar
 
     context "get ruby version" do
       it "makes gem call" do
-        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT}) do
+        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT, :ssl_version => :TLSv1}) do
           {:body => Mortar::API::OkJson.encode({"version" => "1.0.0"}), :status => 200}
         end
         Updater.get_newest_version.should == "1.0.0"   
       end
 
       it "has no version field" do
-        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT}) do
+        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT, :ssl_version => :TLSv1}) do
           {:body => Mortar::API::OkJson.encode({"no_version" => "none"}), :status => 200}
         end
         Updater.get_newest_version.should == "0.0.0"
       end
 
       it "has an exception" do
-        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT}) do
+        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT, :ssl_version => :TLSv1}) do
           raise Exception
         end
         Updater.get_newest_version.should == "0.0.0"
@@ -69,7 +69,7 @@ module Mortar
 
     context "update check" do
       it "displays no message when we have a current version" do
-        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT}) do
+        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT, :ssl_version => :TLSv1}) do
           {:body => Mortar::API::OkJson.encode({"version" => "1.0.0"}), :status => 200}
         end
         capture_stderr do
@@ -81,7 +81,7 @@ module Mortar
       end
 
       it "displays message when we have an outdated version" do
-        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT}) do
+        Excon.stub({:method => :get, :path => "/api/v1/gems/mortar.json", :connect_timeout => Mortar::Updater::CONNECT_TIMEOUT, :read_timeout => Mortar::Updater::READ_TIMEOUT, :ssl_version => :TLSv1}) do
           {:body => Mortar::API::OkJson.encode({"version" => "2.0.0"}), :status => 200}
         end
         capture_stderr do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mortar
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 15
-  - 29
-  version: 0.15.29
+  - 30
+  version: 0.15.30
 platform: ruby
 authors: 
 - Mortar Data
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-10-15 00:00:00 Z
+date: 2014-10-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rdoc
@@ -41,12 +41,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 43
+        hash: 41
         segments: 
         - 0
         - 8
-        - 10
-        version: 0.8.10
+        - 11
+        version: 0.8.11
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency