epc 1.0.2

data/lib/epc/command/attach_libraryset_command.rb

@@ -0,0 +1,32 @@
+module EPC::Command
+  class AttachLibrarysetCommand < BaseCommand
+    required_arguments_count 1, :message => "You must specify a library-set"
+    
+    def execute(set = nil)
+      path = File.expand_path(".")
+      solution_id, solution_name = infer_solution_context(@options[:solution_name], path)
+      project_id, project_name = infer_project_context(@options[:project_name], path, solution_id)
+
+      raise InputError, "Project could not be inferred" if project_id.nil?
+
+      set_id = retrieve_library_set_identifier(set)
+
+      if @options[:detach].present? && @options[:detach]
+        status, response, headers = client.delete(EPC::Config::PROJECTS_PATH + "/#{project_id}/detach_set/#{set_id}")
+      else
+        status, response, headers = client.post(EPC::Config::PROJECTS_PATH + "/#{project_id}/attach_set/#{set_id}")
+      end
+
+      if status.successful?
+        say("Library set #{@options[:detach] ? "detached" : "attached"}")
+      else
+        say("Request failed: [#{response[:message]}]")
+      end
+
+      return status
+       
+
+    end
+
+  end
+end

data/lib/epc/command/attach_runtime_command.rb

@@ -0,0 +1,27 @@
+module EPC::Command
+  class AttachRuntimeCommand < BaseCommand
+    required_arguments_count 1, :message => "You must specify a runtime id"
+    required_options :stage, :mode => :any?, :message => "You must specify the stage"
+
+    def execute(runtime = nil)
+
+      path = File.expand_path(".")
+
+      solution_id, solution_name = infer_solution_context(@options[:solution_name], path) 
+      project_id, project_name = infer_project_context(@options[:project_name], path, solution_id)
+
+      raise InputError, "Project could not be inferred" if project_id.nil?
+
+      status, response, headers = client.put(EPC::Config::PROJECTS_PATH + "/#{project_id}/set_runtime_env", {:runtime_env_id => runtime, :stage_name => @options[:stage]})
+
+      if status.successful?
+        say("Runtime attached")
+      else
+        say("Request failed: [#{response[:message]}]")
+      end
+
+      return status
+
+    end
+  end
+end

data/lib/epc/command/base_command.rb

@@ -0,0 +1,451 @@
+require 'fileutils'
+require 'pathname'
+
+module EPC
+  module Command
+    class BaseCommand
+      include PersistentAttributes
+      include Error
+
+      attr_reader :client
+      attr_reader :options
+
+      @@retrieval_rules = {
+        :system_role => {
+          :match_attribute => :name,
+          :required_attribute => :id,
+          :required_type => :numeric, 
+          :source => EPC::Config::ROLES_PATH + "/system/true"
+        },
+        :user => {
+          :match_attribute => :name,
+          :required_attribute => :id,
+          :required_type => :numeric,
+          :source => EPC::Config::USERS_PATH
+        },
+        :user_group => {
+          :match_attribute => :name,
+          :required_attribute => :id,
+          :required_type => :numeric,
+          :source => EPC::Config::GROUPS_PATH
+        },
+        :library_set => {
+          :match_attribute => :name,
+          :required_attribute => :id,
+          :required_type => :numeric,
+          :source => EPC::Config::LIBRARY_SETS_PATH
+
+        }
+      }
+
+      @@required_arguments = {:count => 0}
+      @@required_options = []
+
+      SLEEP_TIME  = 1
+      
+      # Numerators are in secs
+      TICKER_TICKS  = 25/SLEEP_TIME
+      GIVEUP_TICKS  = 120/SLEEP_TIME
+
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /^retrieve_(.+)_identifier$/ 
+          retrieve_identifier_for($1, *args, &block)
+        else
+          super
+        end
+      end 
+
+      def respond_to?(meth)
+        if meth.to_s =~ /^retrieve_.*_identifier$/
+          true
+        else
+          super
+        end
+      end
+
+      def self.inherited(subklass)
+        # Here login is required for all commands that inherit
+        subklass.require_login
+      end
+
+      def self.required_arguments_count(count, options_hash = {})
+        opt = {
+          :message => "Please specify all the mandatory arguments"
+        }.merge(options_hash)
+        @@required_arguments = {:count => count, :message => opt[:message]}
+      end
+
+      def self.required_options(*opts, opt_hash)
+        options_hash = {
+          :mode => :any?,
+          :message => "You need to specify all required options"
+        }.merge(opt_hash)
+        @@required_options << {:name => opts, :mode => options_hash[:mode], :message => options_hash[:message]}
+      end
+
+      def initialize(client, options = {})
+        @client = client
+        @options = options.dup
+        if @options[:skip_prompts].present?
+          create_method(:ask) {|text, arr| return "Y"}
+        end
+      end
+
+      def go(*args)
+        if (login_required?) && (!logged_in?)
+          say("You must be logged in to run this command")
+          return 1
+        else
+          check_requirements(*args)
+          return translate_status_to_exit_code(execute(*args))
+        end
+      end
+
+      private
+
+      def translate_status_to_exit_code(status)
+        if status.successful?
+          return 0
+        else
+          return status
+        end
+      end
+
+      def self.dont_require_login
+        @login_required = false
+      end
+
+      def self.require_login
+        @login_required = true
+      end
+
+      def self.login_required?
+        !!@login_required
+      end
+
+      def login_required?
+        self.class.login_required?
+      end
+
+      def create_method(name, &block)
+        self.class.send(:define_method, :ask, &block)
+      end
+
+      def logged_in?
+        !(auth_token.nil? || auth_token.empty?)
+      end
+
+      def blank?(value)
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+
+      def check_requirements(*args)
+        raise FatalError, @@required_arguments[:message] if args.size < @@required_arguments[:count] 
+        @@required_options.each do |req_opt|
+          raise FatalError, req_opt[:message] unless req_opt[:name].map{|opt| @options[opt].present?}.send(req_opt[:mode])
+        end
+      end
+
+      def numeric?(value)
+        return value.is_a?(Integer) || (value =~ /\d/) == 0
+      end
+
+      def ask_yn(question)
+        return ask(question, ["Y", "y", "N", "n", ""])
+      end
+
+      def mkdir(name, options = {})
+        result = :ok
+
+        begin
+          FileUtils.mkdir(name, options)
+        rescue SystemCallError => ex
+          result = :failed
+          say("Failed to create local directory [#{name}] - [#{ex}]")
+        end
+
+        result
+      end
+
+      def read_file(path)
+        begin
+          content = File.read(path)
+        rescue Exception => ex
+          say("Failed to read file at #{path}: [#{ex}]")
+        end
+        content
+      end
+
+      def parse_timeout_value
+        return if @options[:timeout].blank?
+        if numeric?(@options[:timeout][-1])
+          @timeout = @options[:timeout].to_i
+          return
+        end
+        unit = @options[:timeout][-1]
+        time = @options[:timeout][0...-1].to_i
+        if unit.downcase == "m"
+          @timeout =  60 * time
+          return
+        end
+        @timeout = time
+      end
+
+      def project_solution_path(path)
+        return path if EPC::Config.is_solution_dir?(path)
+        return File.join(File.split(path)[0...-1])
+      end
+
+      def normalize_params(params)
+        return params if is_target_param?(params.first)
+        return params.insert(0, "")
+      end
+
+      def is_target_param?(param)
+        target_type = param.split(":").first rescue ""
+        return object_types.include?(target_type.downcase)
+      end
+
+      def object_types
+        return ["solution", "project"]
+      end
+
+      def retrieve_identifier_for(entity, *args, &block)
+        entity = entity.to_sym
+        match_value = args.first
+        raise InternalError if match_value.blank?
+        raise InternalError unless @@retrieval_rules.keys.include?(entity)
+        rule = @@retrieval_rules[entity]
+        if rule[:required_type] == :numeric
+          if numeric?(match_value)
+            return match_value.to_i
+          elsif
+            entity_identifier = get_resource_attribute(rule[:source],
+                                                       rule[:required_attribute],
+                                                       rule[:match_attribute],
+                                                       match_value)
+          end
+        end
+
+        raise InputError, "Request failed: [Resource Not Found]" if entity_identifier.nil?
+        return entity_identifier
+      end
+
+      def infer_solution_context(s_identifier, path, options = {})
+        if s_identifier.nil?
+          if EPC::Config.is_solution_dir?(path)
+            solution_id = EPC::Config.get_solution_value(path, "id")
+            solution_name = EPC::Config.get_solution_value(path, "name")
+            return solution_id, solution_name
+          elsif EPC::Config.is_project_dir?(path)
+            solution_path = project_solution_path(path)
+            solution_id = EPC::Config.get_solution_value(solution_path, "id")
+            solution_name = EPC::Config.get_solution_value(solution_path, "name")
+            return solution_id, solution_name
+          else
+            return [nil, nil]
+          end
+        else
+          if numeric?(s_identifier)
+            s_identifier = s_identifier.to_i
+            if options[:get_solution_name].present? && options[:get_solution_name]
+              solution_name = get_resource_name(EPC::Config::SOLUTIONS_PATH + "?include=archived", :id, s_identifier)
+            end
+            return s_identifier, solution_name
+          else
+            if EPC::Config.is_solution_dir?(path)
+              path_solution_name = EPC::Config.get_solution_value(path, "name")
+              if path_solution_name == s_identifier
+                solution_id = EPC::Config.get_solution_value(path, "id")
+                solution_name = EPC::Config.get_solution_value(path, "name")
+                return solution_id, solution_name
+              end
+            elsif EPC::Config.is_project_dir?(path)
+              solution_path = project_solution_path(path)
+              path_solution_name = EPC::Config.get_solution_value(solution_path, "name")
+              if path_solution_name == s_identifier
+                solution_id = EPC::Config.get_solution_value(solution_path, "id")
+                solution_name = EPC::Config.get_solution_value(solution_path, "name")
+                return solution_id, solution_name
+              end
+            end
+            solution_id = get_resource_id(EPC::Config::SOLUTIONS_PATH + "?include=archived", :name, s_identifier)
+            return solution_id, s_identifier
+          end
+        end
+      end
+
+      # OPTIONS:
+      # :get_project_name : for when you have a numeric project_id, but you also want the name
+      def infer_project_context(p_identifier, path, s_identifier = nil, options = {})
+        if p_identifier.nil?
+
+          if EPC::Config.is_project_dir?(path)
+            project_id = EPC::Config.get_project_value(path, "id")
+            project_name = EPC::Config.get_project_value(path, "name")
+            return project_id, project_name
+          else
+            return nil, nil
+          end
+
+        else
+
+          if numeric?(p_identifier)
+            if !options[:get_project_name].nil? && options[:get_project_name] && !s_identifier.nil?
+              project_name = get_resource_name(EPC::Config::SOLUTIONS_PATH + "/#{s_identifier}/projects?include=archived", :id, p_identifier)
+            end
+            return p_identifier, project_name
+          else
+            if s_identifier.present?
+              project_id = get_resource_id(EPC::Config::SOLUTIONS_PATH + "/#{s_identifier}/projects?include=archived", :name, p_identifier)
+              return project_id, p_identifier
+            elsif EPC::Config.is_solution_dir?(path)
+              project_path = File.join(path, p_identifier)
+              if File.exists?(project_path)
+                project_id = EPC::Config.get_project_value(project_path, "id")
+                return project_id, p_identifier
+              end
+            elsif EPC::Config.is_project_dir?(path)
+              path_project_name = EPC::Config.get_project_value(path, "name")
+              if path_project_name == p_identifier
+                return EPC::Config.get_project_value(path, "id"), p_identifier
+              end
+            else
+              return nil, p_identifier
+            end
+          end
+
+        end
+      end
+
+      def retrieve_libraries(libraries)
+        status, response, headers = @client.get(EPC::Config::LIBRARIES_PATH)
+        raise FatalError, "Library retrieval failed: [#{response['message']}]" if status.failure?
+
+        ids = []
+        libraries.each do |lib|
+          raise FatalError, "An entry is missing the name" if lib[:name].nil?
+          lib_id = response.detect { |rlib|
+            found = (rlib[:name] == lib[:name])
+            found = found && (rlib[:library_version].to_s == lib[:library_version])
+            found = found && (rlib[:group].to_s == lib[:group])
+            found
+          }[:id] rescue nil
+
+          raise FatalError, "Could not find [#{lib[:name]}] library" if lib_id.nil?
+          ids << lib_id
+        end
+
+        ids
+      end
+
+
+      def get_resource_name(url, field, field_value)
+        return get_resource_attribute(url, :name, field, field_value.to_i)
+      end
+
+      def get_resource_id(url, field, field_value, options = {})
+        return get_resource_attribute(url, :id, field, field_value, options)
+      end
+
+      def get_resource_attribute(url, attribute, match_field, match_value, options = {})
+        opt = {
+          :case_sensitivity => true
+        }.merge(options)
+
+        status, response, message = client.get(url)
+        raise InputError, "Retrieval failed with message [#{response[:message]}]" unless status.successful?
+        value = response.detect do |entity|
+          if opt[:case_sensitivity]
+            entity[match_field.to_sym] == match_value
+          else
+            entity[match_field.to_sym].downcase == match_value.downcase
+          end
+        end
+        return value[attribute.to_sym] rescue nil
+      end
+
+      def http_client
+        return @http_client if @http_client
+        @http_client = EPC::Client::HttpClient.new(target_url, caller_id, auth_token)
+      end
+
+      def sha1(zip_path)
+        digest = Digest::SHA1.new
+
+        buffer_size = 1024
+        buffer = String.new
+
+        open(zip_path) { |io|
+          digest.update(buffer) while io.read(buffer_size, buffer)
+        }
+
+        digest.hexdigest
+      end
+
+      def extract_configuration_level(path, target_string)
+        config_type, config_id = target_string.split(":") rescue [nil, nil]
+
+        if config_id.nil?
+          if EPC::Config.is_project_dir?(path)
+            config_id = EPC::Config.get_project_value(path, "id")
+            config_type = "Project"
+          elsif EPC::Config.is_solution_dir?(path)
+            config_id = EPC::Config.get_solution_value(path, "id")
+            config_type = "Solution"
+          end
+        end
+
+        return [config_type, config_id]
+      end
+
+      def show_build_status(build_id)
+        status, response, headers = client.get("#{EPC::Config::BUILDS_PATH}/#{build_id}/status")
+        @status = status
+        if status.successful?
+          return true, response[:id], response[:message], response[:status]
+        else
+          return false
+        end
+      end
+      
+
+      def poll_for_build_status(build_id)
+        count = 0
+        failed = false
+
+        while count <= @timeout
+          STDOUT.print('.')
+          STDOUT.flush
+          sleep(SLEEP_TIME)
+
+          shown, id, message, status = show_build_status(build_id)
+          if shown
+            count += 1
+            next unless status == "BUILT" || status == "FAILED" || status == "ERROR"
+
+            if status == "BUILT"
+              say("\nBuild completed successfully.")
+              return 0
+            else
+              say("\nBuild failed: #{status} - #{message}")
+              return 1
+            end
+            break
+          else
+            say("Poller failed to get the build status. Aborting.")
+            return 1
+          end
+        end
+
+        unless failed
+          if count > @timeout
+            say("\nServer is taking too long to update the build status. Please contact the AgileMethods support team.")
+            return 1
+          end
+        end
+      end    
+
+  end
+  end
+end