tddium 1.25.5

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWRjMjRmMDgxYWRhOWY0YzZmMWM2ZDY4YmQzOTkxNDhmZmQwMDQzYQ==
+  data.tar.gz: !binary |-
+    Y2I3OTRkYTIyNjU2NGRlNjBjNjY5M2VlOThhZjRhYTFiMDlmZTM3Mg==
+SHA512:
+  metadata.gz: !binary |-
+    YzJhZmQwYzA0NTI4M2NmNmI4YTczZTc0ZjQ0NDJhNTc5MzljZTViM2UzMmU3
+    OWM5ZTYzNWFjNTQwM2UzYWI3MDY2NmNlNjIxN2ExYzVhNzJmNmZkZTQzYmQy
+    NjhkN2I0OTYwZjFlMDE1NWM2YjZmNmE5Y2M4OTg2ZDkyYWU2YWQ=
+  data.tar.gz: !binary |-
+    YzAyYmEzODdkMTI5NzMzOTVmNzk0MWNjM2E2MzE2NDY4NmEzMWRiNmFkOWZl
+    YjhiODU0OWI3MmM0NGZkNGRiNGY2NWM2ZjU5NTExYjM5OTY1NmNlNzZjNDU2
+    OWUzMTk2MjYzMTJjMDU4YTQzNDk4NDFiMmE4MDgwMmViYTEyZGE=

data/bin/tddium

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# 
+# Copyright (c) 2011, 2012, 2013, 2014 Solano Labs All Rights Reserved
+#
+
+require 'yaml'
+
+if RUBY_VERSION < "2.1.0" && defined?(YAML::ENGINE) then
+  YAML::ENGINE.yamler = 'syck'
+end
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+if ENV['COVERAGE']
+  begin
+    require 'rubygems'
+    require 'simplecov'
+    SimpleCov.root(ENV['COVERAGE_ROOT'])
+    SimpleCov.start do
+      add_group "Commands", "lib/cli/tddium/commands"
+    end
+  rescue => e
+    STDERR.puts "Can't load simplecov: #{e.inspect} #{e.backtrace}"
+  end
+end
+
+require "tddium"
+require "tddium/cli"
+Tddium::TddiumCli.start

data/lib/tddium.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 2011, 2012, 2013, 2014 Solano Labs All Rights Reserved
+
+require "tddium/constant"
+require "tddium/version"
+
+require "tddium/util"
+
+require "tddium/scm"
+require "tddium/ssh"
+
+module Tddium
+  class TddiumError < Exception
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+end

data/lib/tddium/agent.rb

@@ -0,0 +1,3 @@
+# Copyright (c) 2011, 2012, 2013, 2014 Solano Labs All Rights Reserved
+
+require 'tddium/agent/tddium'

data/lib/tddium/agent/tddium.rb

@@ -0,0 +1,122 @@
+# Copyright (c) 2011, 2012, 2013, 2014 Solano Labs All Rights Reserved
+
+require 'json'
+require 'fileutils'
+require 'securerandom'
+require 'tddium_client'
+
+module Tddium
+  class BuildAgent
+    MAXIMUM_ATTACHMENT_SIZE = 16*1024*1024
+
+    def initialize
+    end
+
+    # @return Boolean indicating whether or not we are running inside Tddium
+    def tddium?
+      return ENV.member?('TDDIUM')
+    end
+
+    # @return The current worker thread ID
+    # @note Id is not unique across workers; there is no accessible GUID
+    def thread_id
+      return fetch_id('TDDIUM_TID')
+    end
+
+    # @return Current session ID
+    def session_id
+      return fetch_id('TDDIUM_SESSION_ID')
+    end
+
+    # @return Per-execution unique ID of currently running test
+    def test_exec_id
+      return fetch_id('TDDIUM_TEST_EXEC_ID')
+    end
+
+    # @return Tddium environment (batch, interactive, etc.)
+    def environment
+      env = ENV['TDDIUM_MODE'] || 'none'
+      return env
+    end
+
+    # Status of build
+    # @param which :current or :last
+    # @return 'passed', 'failed', 'error', or 'unknown'
+    def build_status(which=:current)
+      status = 'unknown'
+      case which
+      when :current
+        status = ENV['TDDIUM_BUILD_STATUS']
+      when :last
+        status = ENV['TDDIUM_LAST_BUILD_STATUS']
+      end
+      status ||= 'unknown'
+      return status
+    end
+
+    # BOTCH: must be SCM agnostic
+    def current_branch
+      cmd = "cd #{ENV['TDDIUM_REPO_ROOT']} && git symbolic-ref HEAD"
+      `#{cmd}`.gsub("\n", "").split("/")[2..-1].join("/")
+    end
+
+    # Attach a blob to the session -- excessive storage use is billable
+    # @param data blob that is convertible into a string
+    # @param metadata hash of metadata options
+    # @note See attach_file for description of options
+    def attach(data, metadata)
+      if data.size > MAXIMUM_ATTACHMENT_SIZE then
+        raise TddiumError.new("Data are too large to attach to session")
+      end
+
+      if !metadata.member?(:name) then
+        guid = SecureRandom.hex(4)
+        metadata[:name] = "user.#{guid}.dat"
+      end
+
+      guid = SecureRandom.hex(8)
+      temp_path = File.join(ENV['HOME'], 'tmp', "attach-#{guid}.dat")
+      File.open(temp_path, File::CREAT|File::TRUNC|File::RDWR, 0600) do |file|
+        file.write(data)
+        attach_file(temp_path, metadata)
+      end
+    end
+
+    # Attach a blob to the session -- excessive storage use is billable
+    # @param data blob that is convertible into a string
+    # @param [Hash] metadata hash of metadata options
+    # @option metadata [String] :name Override name of attachment
+    # @option metadata [String] :exec_id Attach to named test execution
+    def attach_file(path, metadata={})
+      if !File.exists?(path) then
+        raise Errno::ENOENT.new(path)
+      end
+      if File.size(path) > MAXIMUM_ATTACHMENT_SIZE then
+        raise TddiumError.new("Data are too large to attach to session")
+      end
+      name = metadata[:name] || File.basename(path)
+      attach_path = attachment_path(name, metadata[:exec_id])
+      FileUtils.cp(path, attach_path)
+    end
+
+    # FUTURE: convert to call to internal agent API server
+    # Unregistered and authenticated files will be ignored
+    def attachment_path(name, exec_id=nil)
+      path = File.join(ENV['HOME'], 'results', session_id.to_s)
+      if exec_id.nil? then
+        path = File.join(path, 'session', name)
+      else
+        path = File.join(path, exec_id.to_s, name)
+      end
+      return path
+    end
+
+    protected
+
+    def fetch_id(name)
+      return nil unless tddium? && ENV.member?(name)
+      id = ENV[name]
+      return id.to_i
+    end
+  end
+end

data/lib/tddium/cli.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2011, 2012, 2013, 2014 Solano Labs All Rights Reserved
+
+require 'rubygems'
+require 'thor'
+require 'highline/import'
+require 'json'
+require 'launchy'
+require 'tddium_client'
+require 'shellwords'
+require 'base64'
+require 'msgpack_pure'
+require 'erb'
+require 'github_api'
+
+require 'tddium/script'
+require 'tddium/cli/params_helper'
+require 'tddium/cli/tddium'
+
+require 'tddium/cli/api'
+require 'tddium/cli/config'
+require 'tddium/cli/suite'
+require 'tddium/cli/prompt'
+require 'tddium/cli/show'
+require 'tddium/cli/util'
+require 'tddium/cli/text_helper'
+require 'tddium/cli/timeformat'

data/lib/tddium/cli/api.rb

@@ -0,0 +1,319 @@
+# Copyright (c) 2011, 2012, 2013, 2014 Solano Labs All Rights Reserved
+
+module Tddium
+  class TddiumAPI
+    include TddiumConstant
+
+    attr_reader :scm	# rspec
+
+    def initialize(api_config, tddium_client, scm)
+      @scm = scm
+      @api_config = api_config
+      @tddium_client = tddium_client
+    end
+
+    def call_api(method, api_path, params = {}, api_key = nil, show_error = true)
+      api_key ||= @api_config.get_api_key unless api_key == false
+
+      begin
+        result = @tddium_client.call_api(method, api_path, params, api_key)
+      rescue TddiumClient::Error::UpgradeRequired => e
+        abort e.message
+      rescue TddiumClient::Error::Base => e
+        say e.message.dup if show_error
+        raise e
+      end
+      result
+    end
+
+    def get_single_account_id
+      user_details = user_logged_in?(true, false)
+      return nil unless user_details
+      accounts = user_details["participating_accounts"]
+      unless accounts.length == 1
+        msg = "You are a member of more than one organization.\n"
+        msg << "Please specify the organization you want to operate on with "
+        msg << "'org:an_organization_name'.\n"
+        accounts.each do |acct|
+          msg << "  #{acct["account"]}\n"
+        end
+        raise msg
+      end
+      accounts.first["account_id"]
+    end
+
+    def get_account_id(acct_name)
+      user_details = user_logged_in?(true, false)
+      return nil unless user_details
+      accts = user_details["participating_accounts"]
+      acct = accts.select{|acct| acct["account"] == acct_name}.first
+      if acct.nil?
+        raise "You aren't a member of organization '%s'." % acct_name
+      end
+      acct["account_id"]
+    end
+
+    def env_path(scope, key=nil)
+      path = ['']
+
+      case scope
+      when "suite"
+        path << 'suites'
+        path << current_suite_id
+      when "repo"
+        path << 'repos'
+        path << current_repo_id
+      when "account", "org"
+        path << 'accounts'
+        path << get_single_account_id
+      when /\Aaccount:/
+        path << 'accounts'
+        path << get_account_id(scope.sub(/\Aaccount:/, ''))
+      when /\Aorg:/
+        path << 'accounts'
+        path << get_account_id(scope.sub(/\Aorg:/, ''))
+      else
+        raise "Unrecognized scope. Use 'suite', 'repo', 'org', or 'org:an_organization_name'."
+      end
+
+      path << 'env'
+      path << key if key
+      path.join('/')
+    end
+
+    def get_config_key(scope, key=nil)
+      path = env_path(scope, key)
+      call_api(:get, path)
+    end
+
+    def set_config_key(scope, key, value)
+      path = env_path(scope)
+      call_api(:post, path, :env=>{key=>value})
+    end
+
+    def delete_config_key(scope, key)
+      path = env_path(scope, key)
+      call_api(:delete, path)
+    end
+
+    def get_user(api_key=nil)
+      result = call_api(:get, Api::Path::USERS, {}, api_key, false) rescue nil
+      result && result['user']
+    end
+
+    def set_user(params)
+      call_api(:post, Api::Path::USERS, {:user => params}, false, false)
+    end
+
+    def update_user(user_id, params, api_key=nil)
+      call_api(:put, "#{Api::Path::USERS}/#{user_id}/", params, api_key, false)
+    end
+
+    def get_user_credentials(options = {})
+      params = {}
+
+      if options[:cli_token]
+        params[:cli_token] = options[:cli_token]
+      elsif options[:invited]
+        # prompt for email/invitation and password
+        token = options[:invitation_token] || ask(Text::Prompt::INVITATION_TOKEN)
+        params[:invitation_token] = token.strip
+        params[:password] = options[:password] || HighLine.ask(Text::Prompt::NEW_PASSWORD) { |q| q.echo = "*" }
+      else
+        say Text::Warning::USE_PASSWORD_TOKEN
+        params[:email] = options[:email] || HighLine.ask(Text::Prompt::EMAIL)
+        params[:password] = options[:password] || HighLine.ask(Text::Prompt::PASSWORD) { |q| q.echo = "*" }
+      end
+      params
+    end
+
+    def login_user(options = {})
+      # POST (email, password) to /users/sign_in to retrieve an API key
+      begin
+        user = options[:params]
+        login_result = call_api(:post, Api::Path::SIGN_IN, {:user => user}, false, options[:show_error])
+        @api_config.set_api_key(login_result["api_key"], user[:email])
+      rescue TddiumClient::Error::Base => e
+      end
+      login_result
+    end
+
+    def user_logged_in?(active = true, message = false)
+      global_api_key = @api_config.get_api_key(:global => true)
+      repo_api_key = @api_config.get_api_key(:repo => true)
+
+      if (global_api_key && repo_api_key && global_api_key != repo_api_key)
+        say Text::Error::INVALID_CREDENTIALS if message
+        return
+      end
+
+      result = repo_api_key || global_api_key
+
+      if message && result.nil? then
+        say Text::Error::NOT_INITIALIZED
+      end
+
+      if result && active
+        u = get_user
+        if message && u.nil?
+          say Text::Error::INVALID_CREDENTIALS
+        end
+        u
+      else
+        result
+      end
+    end
+
+    def get_memberships(params={})
+      result = call_api(:get, Api::Path::MEMBERSHIPS)
+      result['account_roles'] || []
+    end
+
+    def set_memberships(params={})
+      result = call_api(:post, Api::Path::MEMBERSHIPS, params)
+      result['memberships'] || []
+    end
+
+    def delete_memberships(email, params={})
+      call_api(:delete, "#{Api::Path::MEMBERSHIPS}/#{email}", params)
+    end
+
+    def get_usage(params={})
+      result = call_api(:get, Api::Path::ACCOUNT_USAGE_BY_ACCOUNT)
+      result['usage'] || []
+    end
+
+    def get_keys(params={})
+      result = call_api(:get, Api::Path::KEYS)
+      result['keys']|| []
+    end
+
+    def set_keys(params)
+      call_api(:post, Api::Path::KEYS, params)
+    end
+
+    def delete_keys(name, params={})
+      call_api(:delete, "#{Api::Path::KEYS}/#{name}", params)
+    end
+
+    def default_branch
+      @default_branch ||= @scm.default_branch
+    end
+
+    def current_branch
+      @current_branch ||= @scm.current_branch
+    end
+
+    def current_repo_id(options={})
+      # api_config.get_branch will query the server if there is no locally cached data
+      @api_config.get_branch(current_branch, 'repo_id', options)
+    end
+
+    def current_suite_id(options={})
+      # api_config.get_branch will query the server if there is no locally cached data
+      @api_config.get_branch(current_branch, 'id', options)
+    end
+
+    def current_suite_options(options={})
+      @api_config.get_branch(current_branch, 'options', options)
+    end
+
+    def default_suite_id(options={})
+      # api_config.get_branch will query the server if there is no locally cached data
+      @api_config.get_branch(default_branch, 'id', options)
+    end
+
+    def default_suite_options(options={})
+      @api_config.get_branch(default_branch, 'options', options)
+    end
+
+    # suites/user_suites returns:
+    # [                                                                               
+    #   'account',
+    #   'account_id',
+    #   'branch',                                                                          
+    #   'ci_ssh_pubkey', 
+    #   'git_repo_uri', 
+    #   'id', 
+    #   'org_name', 
+    #   'repo_name', 
+    #   'repo_url'                                  
+    # ]
+    def get_suites(params={})
+      current_suites = call_api(:get, "#{Api::Path::SUITES}/user_suites", params)
+      current_suites ||= {}
+      current_suites['suites'] || []
+    end
+
+    def get_suite_by_id(id, params={})
+      current_suites = call_api(:get, "#{Api::Path::SUITES}/#{id}", params)
+      current_suites ||= {}
+      current_suites['suite']
+    end
+
+    def create_suite(params)
+      account_id = params.delete(:account_id)
+      new_suite = call_api(:post, Api::Path::SUITES, {:suite => params, :account_id => account_id})
+      new_suite["suite"]
+    end
+
+    def update_suite(id, params={})
+      call_api(:put, "#{Api::Path::SUITES}/#{id}", params)
+    end
+
+    def permanent_destroy_suite(id, params={})
+      call_api(:delete, "#{Api::Path::SUITES}/#{id}/permanent_destroy", params)
+    end
+
+    def demand_repoman_account(id, params={})
+      call_api(:post, "#{Api::Path::ACCOUNTS}/#{id}/demand_repoman", params)
+    end
+
+    def get_sessions(params={})
+      begin
+        call_api(:get, Api::Path::SESSIONS, params)['sessions']
+      rescue TddiumClient::Error::Base
+        []
+      end
+    end
+
+    def create_session(suite_id, params = {})
+      new_session = call_api(:post, Api::Path::SESSIONS, params.merge(:suite_id=>suite_id))
+      new_session['session']
+    end
+
+    def update_session(session_id, params={})
+      result = call_api(:put, "#{Api::Path::SESSIONS}/#{session_id}", params)
+      result['session']
+    end
+
+    def register_session(session_id, suite_id, test_pattern, test_exclude_pattern=nil)
+      args = {:suite_id => suite_id, :test_pattern => test_pattern}
+      if test_exclude_pattern
+        args[:test_exclude_pattern] = test_exclude_pattern
+      end
+
+      call_api(:post, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::REGISTER_TEST_EXECUTIONS}", args)
+    end
+
+    def start_session(session_id, params)
+      call_api(:post, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::START_TEST_EXECUTIONS}", params)
+    end
+
+    def stop_session(ls_id, params = {})
+      call_api(:post, "#{Api::Path::SESSIONS}/#{ls_id}/stop", params)
+    end
+
+    def poll_session(session_id, params={})
+      call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::TEST_EXECUTIONS}")
+    end
+
+    def query_session(session_id, params={})
+      call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::QUERY_TEST_EXECUTIONS}")
+    end
+
+    def check_session_done(session_id)
+      call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/check_done")
+    end
+  end
+end