solano 1.31.0

data/lib/solano/cli/commands/keys.rb

@@ -0,0 +1,81 @@
+# Copyright (c) 2011-2015 Solano Labs All Rights Reserved
+
+module Solano
+  class SolanoCli < Thor
+    desc "keys", "List SSH keys authorized for Solano CI"
+    def keys
+      user_details = solano_setup({:scm => false})
+
+      begin
+        if user_details then
+          show_third_party_keys_details(user_details)
+        end
+
+        keys_details = @solano_api.get_keys
+        show_keys_details(keys_details)
+      rescue TddiumClient::Error::API => e
+        exit_failure Text::Error::LIST_KEYS_ERROR
+      end
+    end
+
+    desc "keys:add [NAME] [PATH]", "Authorize an existing keypair for Solano CI"
+    method_option :dir, :type=>:string, :default=>nil
+    define_method "keys:add" do |name, path|
+      solano_setup({:scm => false})
+
+      path = File.expand_path(path)
+
+      output_dir = options[:dir] || ENV['SOLANO_GEM_KEY_DIR']
+      output_dir ||= Default::SSH_OUTPUT_DIR
+
+      begin
+        keydata = Solano::Ssh.validate_keys name, path, @solano_api
+        say Text::Process::ADD_KEYS_ADD % name
+        result = @solano_api.set_keys({:keys => [keydata]})
+
+        priv_path = path.sub(/[.]pub$/, '')
+        say Text::Process::ADD_KEYS_ADD_DONE % [name, priv_path, result["git_server"] || Default::GIT_SERVER, priv_path]
+      rescue TddiumClient::Error::API => e
+        exit_failure Text::Error::ADD_KEYS_ERROR % name
+      rescue SolanoError => e
+        exit_failure e.message
+      end
+    end
+
+    map "generate" => :gen
+    desc "keys:gen [NAME]", "Generate and authorize a keypair for Solano CI"
+    method_option :dir, :type=>:string, :default=>nil
+    define_method "keys:gen" do |name|
+      solano_setup({:scm => false})
+
+      output_dir = options[:dir] || ENV['SOLANO_GEM_KEY_DIR']
+      output_dir ||= Default::SSH_OUTPUT_DIR
+
+      begin
+        keydata = Solano::Ssh.validate_keys name, output_dir, @solano_api, true
+        say Text::Process::ADD_KEYS_GENERATE % name
+
+        result = @solano_api.set_keys({:keys => [keydata]})
+        outfile = File.expand_path(File.join(output_dir, "identity.solano.#{name}"))
+        say Text::Process::ADD_KEYS_GENERATE_DONE % [name, result["git_server"] || Default::GIT_SERVER, outfile]
+      rescue TddiumClient::Error::API => e
+        exit_failure Text::Error::ADD_KEYS_ERROR % name
+      rescue SolanoError => e
+        exit_failure e.message
+      end
+    end
+
+    desc "keys:remove [NAME]", "Remove a key that was authorized for Solano CI"
+    define_method "keys:remove" do |name|
+      solano_setup({:scm => false})
+
+      begin
+        say Text::Process::REMOVE_KEYS % name
+        result = @solano_api.delete_keys(name)
+        say Text::Process::REMOVE_KEYS_DONE % name
+      rescue TddiumClient::Error::API => e
+        exit_failure Text::Error::REMOVE_KEYS_ERROR % name
+      end
+    end
+  end
+end  

data/lib/solano/cli/commands/login.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2011-2015 Solano Labs All Rights Reserved
+
+module Solano
+  class SolanoCli < Thor
+    desc "login [[TOKEN]]", "Log in using your email address or token (see: https://ci.solanolabs.com/user_settings/token)"
+    method_option :email, :type => :string, :default => nil
+    method_option :password, :type => :string, :default => nil
+    method_option :ssh_key_file, :type => :string, :default => nil
+    def login(*args)
+      user_details = solano_setup({:login => false, :scm => false})
+
+      login_options = options.dup
+
+      if args.first && args.first =~ /@/
+        login_options[:email] ||= args.first 
+      elsif args.first
+        # assume cli token
+        login_options[:cli_token] = args.first
+      end
+
+      if user_details then
+        say Text::Process::ALREADY_LOGGED_IN
+      elsif user = @solano_api.login_user(:params => @solano_api.get_user_credentials(login_options), :show_error => true)
+        say Text::Process::LOGGED_IN_SUCCESSFULLY 
+        if @scm.repo? then
+          @api_config.populate_branches(@solano_api.current_branch)
+        end
+        @api_config.write_config
+      else
+        exit_failure
+      end
+      if prompt_missing_ssh_key then
+        say Text::Process::NEXT_STEPS
+      end
+    end
+  end
+end

data/lib/solano/cli/commands/logout.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 2011-2015 Solano Labs All Rights Reserved
+
+module Solano
+  class SolanoCli < Thor
+    desc "logout", "Log out of solano"
+    def logout
+      solano_setup({:login => false, :scm => false})
+
+      @api_config.logout
+
+      say Text::Process::LOGGED_OUT_SUCCESSFULLY
+    end
+  end
+end

data/lib/solano/cli/commands/password.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2011-2015 Solano Labs All Rights Reserved
+
+module Solano
+  class SolanoCli < Thor
+    desc "password", "Change password"
+    map "passwd" => :password
+    def password
+      user_details = solano_setup({:scm => false})
+
+      params = {}
+      params[:current_password] = HighLine.ask(Text::Prompt::CURRENT_PASSWORD) { |q| q.echo = "*" }
+      params[:password] = HighLine.ask(Text::Prompt::NEW_PASSWORD) { |q| q.echo = "*" }
+      params[:password_confirmation] = HighLine.ask(Text::Prompt::PASSWORD_CONFIRMATION) { |q| q.echo = "*" }
+
+      begin
+        user_id = user_details["id"]
+        @solano_api.update_user(user_id, {:user => params})
+        say Text::Process::PASSWORD_CHANGED
+      rescue TddiumClient::Error::API => e
+        exit_failure Text::Error::PASSWORD_ERROR % e.explanation
+      rescue TddiumClient::Error::Base => e
+        exit_failure e.message
+      end
+    end
+  end
+end

data/lib/solano/cli/commands/rerun.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2011-2015 Solano Labs All Rights Reserved
+
+module Solano
+  class SolanoCli < Thor
+    desc "rerun SESSION", "Rerun failing tests from a session"
+    method_option :account, :type => :string, :default => nil,
+      :aliases => %w(--org --organization)
+    method_option :max_parallelism, :type => :numeric, :default => nil
+    method_option :no_op, :type=>:boolean, :default => false, :aliases => ["-n"]
+    method_option :force, :type=>:boolean, :default => false
+    method_option :profile, :type => :string, :default => nil, :aliases => %w(--profile-name)
+    def rerun(session_id=nil)
+      params = {:scm => true, :repo => false}
+      if session_id.nil? then
+        params = {:repo => true, :suite => true}
+      end
+      solano_setup(params)
+
+      session_id ||= session_id_for_current_suite
+
+      begin
+        result = @solano_api.query_session_tests(session_id)
+      rescue TddiumClient::Error::API => e
+        exit_failure Text::Error::NO_SESSION_EXISTS
+      end
+
+      tests = result['session']['tests']
+      tests = tests.select{ |t| [
+        'failed', 'error', 'notstarted', 'started'].include?(t['status']) }
+      tests = tests.map{ |t| t['test_name'] }
+
+      profile = options[:profile] || result['non_passed_profile_name']
+
+      cmd = "solano run"
+      cmd += " --max-parallelism=#{options[:max_parallelism]}" if options[:max_parallelism]
+      cmd += " --org=#{options[:account]}" if options[:account]
+      cmd += " --force" if options[:force]
+      cmd += " --profile=#{profile}" if profile
+      cmd += " #{tests.join(" ")}"
+
+      say cmd
+      Kernel.exec(cmd) if !options[:no_op]
+    end
+
+    private
+
+    def session_id_for_current_suite
+      return unless suite_for_current_branch?
+      suite_params = {
+        :suite_id => @solano_api.current_suite_id,
+        :active => false,
+        :limit => 1,
+        :origin => %w(ci cli)
+      }
+      session = @solano_api.get_sessions(suite_params)
+      session[0]["id"]
+    end
+  end
+end

data/lib/solano/cli/commands/server.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2014, 2015 Solano Labs All Rights Reserved
+
+module Solano
+  class SolanoCli < Thor
+    desc 'server', "displays the saved connection info"
+    def server
+      solano_setup({:scm => false, :login => false})
+      self.class.display
+    end
+
+    desc 'server:set --host HOST [--port PORT] [--proto PROTO] [--insecure]', "saves connection info"
+    method_option :host, type: :string, required: true
+    method_option :port, type: :numeric, default: 443
+    method_option :proto, type: :string, default: 'https'
+    method_option :insecure, type: :boolean, default: false
+    define_method 'server:set' do
+      solano_setup({:scm => false, :login => false})
+      self.class.write_params options
+    end
+  end
+end

data/lib/solano/cli/commands/spec.rb

@@ -0,0 +1,401 @@
+# Copyright (c) 2011-2016 Solano Labs All Rights Reserved
+require 'digest'
+require 'net/http'
+
+module Solano
+  class SolanoCli < Thor
+    map "cucumber" => :spec
+    map "test" => :spec
+    map "run" => :spec
+    desc "run [PATTERN]", "Run the test suite, or tests that match PATTERN"
+    method_option :account, :type => :string, :default => nil,
+      :aliases => %w(--org --organization)
+    method_option :tag, :type => :string, :default => nil
+    method_option :user_data_file, :type => :string, :default => nil
+    method_option :max_parallelism, :type => :numeric, :default => nil
+    method_option :test_pattern, :type => :string, :default => nil
+    method_option :test_exclude_pattern, :type => :string, :default => nil
+    method_option :force, :type => :boolean, :default => false
+    method_option :quiet, :type => :boolean, :default => false
+    method_option :machine, :type => :boolean, :default => false
+    method_option :session_id, :type => :numeric, :default => nil
+    method_option :tool, :type => :hash, :default => {}
+    method_option :env, :type=>:hash, :default => {}
+    method_option :profile, :type => :string, :default => nil, :aliases => %w(--profile-name)
+    method_option :queue, :type => :string, :default => nil
+    method_option :session_manager, :type => :string, :default => nil
+    method_option :default_branch, :type => :string, :default => nil
+    method_option :force_snapshot, :type => :boolean, :default => false
+    method_option :volume, :type => :string, :default => nil
+    def spec(*pattern)
+      machine_data = {}
+
+      solano_setup({:repo => true})
+
+      suite_auto_configure unless options[:machine]
+
+      exit_failure unless suite_for_current_branch?
+
+      if !options[:machine] && @solano_api.get_keys.empty? then
+        warn(Text::Warning::NO_SSH_KEY)
+      end
+
+      if @scm.changes?(options) then
+        exit_failure(Text::Error::SCM_CHANGES_NOT_COMMITTED) if !options[:force]
+        warn(Text::Warning::SCM_CHANGES_NOT_COMMITTED)
+      end
+
+      test_execution_params = {}
+
+      if user_data_file_path = options[:user_data_file] then
+        if File.exists?(user_data_file_path) then
+          user_data = File.open(user_data_file_path) { |file| file.read }
+          test_execution_params[:user_data_text] = Base64.encode64(user_data)
+          test_execution_params[:user_data_filename] = File.basename(user_data_file_path)
+          say Text::Process::USING_SPEC_OPTION[:user_data_file] % user_data_file_path
+        else
+          exit_failure Text::Error::NO_USER_DATA_FILE % user_data_file_path
+        end
+      end
+
+      if max_parallelism = options[:max_parallelism] then
+        test_execution_params[:max_parallelism] = max_parallelism
+        say Text::Process::USING_SPEC_OPTION[:max_parallelism] % max_parallelism
+      end
+
+      test_execution_params[:tag] = options[:tag] if options[:tag]
+      test_pattern = nil
+
+      if pattern.is_a?(Array) && pattern.size > 0 then
+        test_pattern = pattern.join(",")
+      end
+
+      test_pattern ||= options[:test_pattern]
+      if test_pattern then
+        say Text::Process::USING_SPEC_OPTION[:test_pattern] % test_pattern
+      end
+
+      test_exclude_pattern ||= options[:test_exclude_pattern]
+      if test_exclude_pattern then
+        say Text::Process::USING_SPEC_OPTION[:test_exclude_pattern] % test_exclude_pattern
+      end
+
+      tries = 0
+      while tries < Default::SCM_READY_TRIES do
+        # Call the API to get the suite and its tests
+        suite_details = @solano_api.get_suite_by_id(@solano_api.current_suite_id,
+                                                    :session_id => options[:session_id])
+
+        if suite_details["repoman_current"] == true
+          break
+        else
+          @solano_api.demand_repoman_account(suite_details["account_id"])
+
+          say Text::Process::SCM_REPO_WAIT
+          sleep @api_config.scm_ready_sleep
+        end
+
+        tries += 1
+      end
+      exit_failure Text::Error::SCM_REPO_NOT_READY unless suite_details["repoman_current"]
+
+      #update_suite_parameters!(suite_details, options[:session_id])
+
+      start_time = Time.now
+
+      new_session_params = {
+        :commits_encoded => read_and_encode_latest_commits,
+        :cache_control_encoded => read_and_encode_cache_control,
+        :cache_save_paths_encoded => read_and_encode_cache_save_paths,
+        :raw_config_file => read_and_encode_config_file
+      }
+
+      if options[:profile]
+        if  options[:session_id].nil?
+          say Text::Process::USING_PROFILE % options[:profile]
+          new_session_params[:profile_name] = options[:profile]
+        else
+          exit_fail Text::Error::CANNOT_OVERRIDE_PROFILE
+        end
+      end
+
+     if options[:queue]
+        if  options[:session_id].nil?
+          say Text::Process::USING_PROFILE % options[:profile]
+          new_session_params[:queue] = options[:queue]
+        else
+          exit_fail Text::Error::CANNOT_OVERRIDE_QUEUE
+        end
+      end
+
+      if options[:env]
+        say Text::Process::USING_CUSTOM_USER_ENV_VARS % "#{options[:env]}"
+        new_session_params[:env] = options[:env]
+      end
+
+      if options[:volume]
+        say Text::Process::VOLUME_OVERRIDE % options[:volume]
+        new_session_params[:volume] = options[:volume]
+      end
+
+      if options[:session_manager] then
+          say Text::Process::USING_SESSION_MANAGER % options[:session_manager]
+          new_session_params[:session_manager] = options[:session_manager]
+      end
+
+      new_session_params[:cli_current_commit] = @scm.current_commit
+
+      # Create a session
+      # or use an already-created session
+      #
+      session_id = options[:session_id]
+      session_data = if session_id && session_id > 0
+        @solano_api.update_session(session_id, new_session_params)
+      else
+        sess, manager = @solano_api.create_session(@solano_api.current_suite_id, new_session_params)
+        sess
+      end
+
+      session_data ||= {}
+      session_id ||= session_data["id"]
+
+      if manager == 'DestroFreeSessionManager'
+        begin
+          if !options[:force_snapshot] then
+            #check if there is a snapshot
+            res = @solano_api.get_snapshot_commit({:session_id => session_id})
+            if res['snap_commit'] then
+              snapshot_commit = res['snap_commit']
+            #No snapshot
+            else
+              say Text::Process::NO_SNAPSHOT
+              res = @scm.create_snapshot(session_id, {:api => @solano_api, :default_branch => options[:default_branch]})
+              snapshot_commit = @scm.get_snap_id
+            end
+            say Text::Process::SNAPSHOT_COMMIT % snapshot_commit
+            #if we already had a snapshot or we created a master snapshot
+            #create a patch
+            @scm.create_patch(session_id, {:api => @solano_api, :commit => snapshot_commit})
+          #forced snapshot creation
+          else
+            say Text::Process::FORCED_SNAPSHOT
+            res = @scm.create_snapshot(session_id, {:api => @solano_api, :force => true})
+            snapshot_commit = @scm.get_snap_id
+          end
+          #start tests
+          start_test_executions = @solano_api.start_destrofree_session(session_id, {:test_pattern => test_pattern, :test_exclude_pattern=>test_exclude_pattern})
+        rescue Exception, RuntimeError => e
+           @solano_api.stop_session(session_id)
+           say "ERROR: #{e.message}"
+           return
+        end
+      else
+
+        push_options = {}
+        if options[:machine]
+          push_options[:use_private_uri] = true
+        end
+
+        if !@scm.push_latest(session_data, suite_details, push_options) then
+          exit_failure Text::Error::SCM_PUSH_FAILED
+        end
+
+        machine_data[:session_id] = session_id
+
+        # Register the tests
+        @solano_api.register_session(session_id, @solano_api.current_suite_id, test_pattern, test_exclude_pattern)
+
+        # Start the tests
+        start_test_executions = @solano_api.start_session(session_id, test_execution_params)
+
+
+        num_tests_started = start_test_executions["started"].to_i
+
+        say Text::Process::STARTING_TEST % num_tests_started.to_s
+      end
+      tests_finished = false
+      finished_tests = {}
+      latest_message = -100000
+      test_statuses = Hash.new(0)
+      session_status = nil
+      messages = nil
+      last_finish_timestamp = nil
+
+      report = start_test_executions["report"]
+
+      # In CI mode, just hang up here.  The session will continue running.
+      if options[:machine] then
+        say Text::Process::BUILD_CONTINUES
+        return
+      end
+
+      say ""
+      say Text::Process::CHECK_TEST_REPORT % report
+      say Text::Process::TERMINATE_INSTRUCTION
+      say ""
+
+      # Catch Ctrl-C to interrupt the test
+      Signal.trap(:INT) do
+        say Text::Process::INTERRUPT
+        say Text::Process::CHECK_TEST_STATUS
+        tests_finished = true
+        session_status = "interrupted"
+      end
+
+      while !tests_finished do
+        current_test_executions = @solano_api.poll_session(session_id)
+        session_status = current_test_executions['session_status']
+
+        messages, latest_message = update_messages(latest_message,
+                                                   finished_tests,
+                                                   messages,
+                                                   current_test_executions["messages"])
+
+        # Print out the progress of running tests
+        current_test_executions["tests"].each do |test_name, result_params|
+          if finished_tests.size == 0 && result_params["finished"] then
+            say ""
+            say Text::Process::CHECK_TEST_REPORT % report
+            say Text::Process::TERMINATE_INSTRUCTION
+            say ""
+          end
+          if result_params["finished"] && !finished_tests[test_name]
+            test_status = result_params["status"]
+            message = case test_status
+                      when "passed" then [".", :green, false]
+                      when "failed" then ["F", :red, false]
+                      when "error" then ["E", nil, false]
+                      when "pending" then ["*", :yellow, false]
+                      when "skipped" then [".", :yellow, false]
+                      else [".", nil, false]
+                      end
+            finished_tests[test_name] = test_status
+            last_finish_timestamp = Time.now
+            test_statuses[test_status] += 1
+            say *message
+          end
+        end
+
+        # XXX time out if all tests are done and the session isn't done.
+        if current_test_executions['session_done'] || current_test_executions['phase'] == 'done' &&
+          ((!num_tests_started.nil? && finished_tests.size >= num_tests_started) && (Time.now - last_finish_timestamp) > Default::TEST_FINISH_TIMEOUT)
+          tests_finished = true
+        end
+
+        sleep(Default::SLEEP_TIME_BETWEEN_POLLS) if !tests_finished
+      end
+
+      display_alerts(messages, 'error', Text::Status::SPEC_ERRORS)
+
+      # Print out the result
+      say ""
+      say Text::Process::RUN_SOLANO_WEB
+      say ""
+      say Text::Process::FINISHED_TEST % (Time.now - start_time)
+      say "#{finished_tests.size} tests, #{test_statuses["failed"]} failures, #{test_statuses["error"]} errors, #{test_statuses["pending"]} pending, #{test_statuses["skipped"]} skipped"
+
+      if test_statuses['failed'] > 0
+        say ""
+        say Text::Process::FAILED_TESTS
+        finished_tests.each do |name, status|
+          next if status != 'failed'
+          say " - #{name}"
+        end
+        say ""
+      end
+
+      say Text::Process::SUMMARY_STATUS % session_status
+      say ""
+
+      suite = suite_details.merge({"id" => @solano_api.current_suite_id})
+      @api_config.set_suite(suite)
+      @api_config.write_config
+
+      exit_failure if session_status != 'passed'
+    rescue TddiumClient::Error::API => e
+      exit_failure "Failed due to error: #{e.explanation}"
+    rescue TddiumClient::Error::Base => e
+      exit_failure "Failed due to error: #{e.message}"
+    rescue RuntimeError => e
+      exit_failure "Failed due to internal error: #{e.inspect} #{e.backtrace}"
+    end
+
+    private
+
+    def update_messages(latest_message, finished_tests, messages, current, display=true)
+      messages = current
+      if !options[:machine] && finished_tests.size == 0 && messages
+        messages.each do |m|
+          seqno = m["seqno"].to_i
+          if seqno > latest_message
+            if !options[:quiet] || m["level"] == 'error' then
+              display_message(m)
+            end
+            latest_message = seqno
+          end
+        end
+      end
+      [messages, latest_message]
+    end
+
+    def read_and_encode_latest_commits
+      commits = @scm.commits
+      commits_packed = Solano.message_pack(commits)
+      commits_encoded = Base64.encode64(commits_packed)
+      commits_encoded
+    end
+
+    def docker_enabled
+      if @repo_config['system'] then
+         if @repo_config['system']['docker'] then
+           @repo_config['system']['docker']
+         else
+           false
+         end
+      else
+        false
+      end
+    end
+
+    def cache_control_config
+      @repo_config['cache'] || {}
+    end
+
+    def read_and_encode_cache_control
+      cache_key_paths = cache_control_config['key_paths'] || cache_control_config[:key_paths]
+      cache_key_paths ||= ["Gemfile", "Gemfile.lock", "requirements.txt", "packages.json", "package.json"]
+      cache_key_paths.reject!{|x| x =~ /(solano|tddium).yml$/}
+
+      if docker_enabled then
+        cache_key_paths << "Dockerfile"
+      end
+
+      cache_control_data = {}
+      cache_key_paths.each do |p|
+        if File.exists?(p) then
+          cache_control_data[p] = Digest::SHA1.file(p).to_s
+        end
+      end
+
+      msgpack = Solano.message_pack(cache_control_data)
+      cache_control_encoded = Base64.encode64(msgpack)
+    end
+
+    def read_and_encode_cache_save_paths
+      cache_save_paths = cache_control_config['save_paths'] || cache_control_config[:save_paths]
+
+      if docker_enabled then
+        (cache_save_paths ||= []) << "HOME/docker-graph"
+      end
+
+      msgpack = Solano.message_pack(cache_save_paths)
+      cache_save_paths_encoded = Base64.encode64(msgpack)
+    end
+
+    def read_and_encode_config_file
+      config, raw_config = @repo_config.read_config(false)
+      encoded = Base64.encode64(raw_config)
+      return encoded
+    end
+  end
+end