forcer 0.4.0

data/lib/metadata_services/metadata_service.rb

@@ -0,0 +1,171 @@
+require "savon"
+require_relative "../metadata_services/sfdc_directory_service"
+require_relative "../utilities/status_print_service"
+
+=begin
+client.operations => [
+  :cancel_deploy,
+  :check_deploy_status,
+  :check_retrieve_status,
+  :create_metadata,
+  :delete_metadata,
+  :deploy,
+  :deploy_recent_validation,
+  :describe_metadata,
+  :describe_value_type,
+  :list_metadata,
+  :read_metadata,
+  :rename_metadata,
+  :retrieve,
+  :update_metadata,
+  :upsert_metadata
+]
+=end
+module Metadata
+  class MetadataService
+
+    API_VERSION = 33.0 # todo move to constants file
+    attr_accessor :metadata_client, :current_session_id, :zip_name
+
+    def initialize(args = {})
+      @args = args
+      @metadata_client = get_client
+    end
+
+    # lists metadata types like Classes, Pages
+    def list
+      default_list = ["CustomObject", "ApexClass", "ApexTrigger", "CustomLabels", "CustomTab", "EmailTemplate",
+        "Profile", "Queue", "StaticResource", "ApexComponent", "ApexPage"]
+
+      # assume components listed in terminal without commas as option to program
+      if @args[:types] != nil
+        types = @args[:types]
+      elsif
+        types = default_list
+      end
+
+      queries = ""
+      types.each do |type|
+        queries += "<met:type>#{type.to_s}</met:type><met:folder>#{type.to_s}</met:folder>"
+      end
+
+      list_metadata_template = File.read(File.dirname(__FILE__) + "/list_metadata_request.xml")
+      xml_param = list_metadata_template % [@current_session_id, queries, API_VERSION]
+      response = @metadata_client.call(:list_metadata, :xml => xml_param)
+
+      return response
+    end
+
+    def deploy
+      begin
+        dir_zip_service = SfdcDirectoryService.new(@args)
+        @zip_name = dir_zip_service.write
+        blob_zip = Base64.encode64(File.open(@zip_name, "rb").read)
+
+        # todo read options from console arguments
+        options = {
+          singlePackage: true,
+          rollbackOnError: true,
+          checkOnly: false,
+          allowMissingFiles: false,
+          runAllTests: false,
+          ignoreWarnings: false
+        }
+
+        # prepare xml for deployment
+        deploy_options_snippet = ""
+        options.each do |k, v|
+          # todo take care of array options if any
+          value = @args[k].nil? ? v.to_s : @args[k].to_s
+          key = k.to_s
+          deploy_options_snippet += "<met:#{key}>#{value}</met:#{key}>"
+        end
+
+        debug_options_snippet = "" #by default no debug options
+
+        deploy_request_xml = File.read(File.dirname(__FILE__) + "/deploy_request.xml");
+        xml_param = deploy_request_xml % [debug_options_snippet, @current_session_id, blob_zip, deploy_options_snippet]
+        response = @metadata_client.call(:deploy, :xml => xml_param)
+        # todo catch exceptions
+
+        if response.body[:deploy_response][:result][:state] == "Queued"
+          p "DEPLOYMENT STARTED. YOU CAN ALSO CHECK DEPLOYMENT STATUS IN SALESFORCE ORG."
+
+          Forcer::StatusPrintService.new().run_status_check(
+              {id: response.body[:deploy_response][:result][:id], session_id: @current_session_id},
+              lambda { |header, body| @metadata_client.call(:check_deploy_status, soap_header: header) { message(body) }}
+          ) unless @args[:unit_test_running]
+
+        else
+          p "DEPLOYMENT FAILED. CHECK DEPLOYMENT STATUS LOG IN SALESFORCE ORG."
+        end
+      ensure
+        p "deleting zip file with project metadata"
+        FileUtils.rm_f @zip_name
+      end
+
+      return response
+    end
+
+    private
+    # login to salesforce and obtain session information
+    def login
+      "login request to #{@args[:host]}"
+      endpoint_url = @args[:host]
+      options = {
+        endpoint: "#{endpoint_url}/services/Soap/c/#{API_VERSION}",
+        wsdl: File.expand_path("../enterprise.wsdl", __FILE__),
+        :headers => {
+          "Authentication" => "secret"
+        }
+      }
+      enterprise_client = Savon.client(options)
+
+      message = {
+        username: @args[:username],
+        password: "#{@args[:password]}#{@args[:security_token]}"
+      }
+
+      # === login
+      response = enterprise_client.call(:login, message: message)
+      # todo catch exceptions
+      @current_session_id = response.body[:login_response][:result][:session_id]
+      @metadata_server_url = response.body[:login_response][:result][:metadata_server_url]
+    end
+
+    # using session information create metadata client
+    def get_client
+      login
+      p "creating metadata client from wsdl"
+      options = {
+        wsdl: File.expand_path("../metadata.wsdl", __FILE__),
+        endpoint: @metadata_server_url,
+        soap_header: {
+          "tns:SessionHeader" => {
+            "tns:sessionId" => @current_session_id
+          }
+        },
+        read_timeout: 60 * 10,
+        open_timeout: 60 * 10
+      }
+      return Savon.client(options)
+    end
+
+  end # class MetadataService
+end # module Metadata
+
+# test area
+
+  # args = {
+  #   host: "https://test.salesforce.com",
+  #   username: "gaziz@eventbrite.com.comitydev",
+  #   password: "?kMMTR[d}X7`Fd}>@T.",
+  #   security_token: "fpX1t6k2We39Qtq42NKbnLWSQ"
+  # }
+  # metadata_service = Metadata::MetadataService.new(
+  #   File.expand_path("../../../tmp/TestProject", __FILE__),
+  #   args
+  # )
+  #
+  # p metadata_service.list.body
+# p metadata_service.deploy.body[:deploy_response][:result][:state]

data/lib/metadata_services/sfdc_directory_service.rb

@@ -0,0 +1,190 @@
+require "zip"
+require "securerandom"
+require "yaml"
+require "nokogiri"
+require "Find"
+
+module Metadata
+
+  class SfdcDirectoryService
+
+    public
+
+    def initialize(args = {})
+      @args = args
+      @output_file_name = tempfile_name("zip")
+      @files_to_exclude = Set.new()
+      @snippets_to_exclude = {}
+      find_source_dir
+      prepare_files_to_exclude
+      prepare_xml_nodes_to_exclude
+    end
+
+    # copy files from original directory to be xml_filtered later
+    # Create zip file with contents of force.com project
+    # Return absolute path to the file
+    def write
+      begin
+        @zip_io = Zip::File.open(@output_file_name, Zip::File::CREATE)
+        raise "package.xml NOT FOUND" unless verify_package_xml
+
+        p "making temporary copy of project folder"
+        tmpdir = Dir.mktmpdir
+        FileUtils.cp_r(@input_dir_name, tmpdir)
+        @input_dir_name = tmpdir.to_s + "/src"
+
+        entries = dir_content(@input_dir_name)
+        p "excluding specified components from deployment"
+        p "filtering deployment files removing specified XML elements"
+        write_entries(entries, "")
+      ensure
+        @zip_io.close # close before deleting tmpdir, or NOT_FOUND exception
+        p "deleting temporary copy of project folder"
+        FileUtils.remove_entry(tmpdir)
+      end
+
+      # FileUtils.cp_r(@output_file_name, "/Users/gt/Desktop/temp.zip")
+      return @output_file_name
+    end
+
+    private
+
+    def find_source_dir
+      raise Exception unless Dir.exists?(@args[:source])
+      @input_dir_name = ""
+      Find.find(@args[:source]) do |entry|
+        if entry.end_with?("src") && File.directory?(entry)
+          @input_dir_name = entry
+          p "found 'src' directory"
+          break
+        end
+      end
+      raise Exception if @input_dir_name.empty?
+    end
+
+    def prepare_files_to_exclude()
+      exclude_filename = @args[:exclude_components]
+      if exclude_filename.nil? || exclude_filename.empty? || not(File.exists?(exclude_filename))
+        exclude_filename = File.expand_path("../exclude_components.yml", __FILE__)
+      end
+
+      @files_to_exclude = Set.new()
+      YAML.load_file(exclude_filename).each do |name|
+        @files_to_exclude.add(name.to_s.downcase)
+      end
+    end
+
+    def prepare_xml_nodes_to_exclude()
+      exclude_filename = @args[:exclude_xml]
+      if exclude_filename.nil? || exclude_filename.empty? || not(File.exists?(exclude_filename))
+        exclude_filename = File.expand_path("../exclude_xml_nodes.yml", __FILE__)
+      end
+
+      @snippets_to_exclude = YAML.load_file(exclude_filename)
+      # YAML.load_file(exclude_filename).each do |suffix, expressions|
+      #   @snippets_to_exclude[key] << value
+      #   pp "=== #{key} => #{value}"
+      #   expressions.each do |exp, flag|
+      #     pp "=== exp => #{exp}"
+      #     pp "=== exp => #{flag}"
+      #   end
+      # end
+      # pp "====== snippets => #{@snippets_to_exclude} ==== #{@snippets_to_exclude.class}"
+    end
+
+    # Opens file. Removes all bad xml snippets. Rewrites results back into original file
+    def filter_xml(filename)
+      doc = Nokogiri::XML(File.read(filename))
+      # if (filename.end_with?("package.xml"))
+      #   p "======= errors of package.xml => #{doc.errors}"
+      # end
+      file_modified = false
+      @snippets_to_exclude.each do |suffix, expressions|
+        next unless filename.end_with?(suffix.to_s)
+        # p "==== processing suffix = #{suffix} vs #{filename}"
+        # p "==== processing snippets = #{snippets}"
+        expressions.each do |search_string, should_remove_parent|
+          # pp "==== processing snippet = #{search_string}"
+          nodes = doc.search(search_string.to_s)
+          unless nodes.empty?
+            file_modified = true
+            nodes.each do |n|
+              parent = n.parent
+              n.remove unless should_remove_parent
+              parent.remove if should_remove_parent # || parent.content.strip.empty?
+            end
+          end
+        end
+      end
+      File.open(filename, "w") do |file|
+        file.print(doc.to_xml)
+      end if file_modified
+      # if (filename.end_with?("Admin.profile"))
+      #   FileUtils.cp(filename, "/Users/gt/Desktop/testAdmin.profile")
+      # end
+    end
+
+    def write_entries(entries, path)
+      entries.each do |entry|
+        # need relative local file path to use in new zip file too
+        zip_file_path = (path == "" ? entry : File.join(path, entry)) # maybe without if/else
+        next if @files_to_exclude.include?(zip_file_path.downcase) # avoid if directory/file excluded
+
+        # need full file path to use in copy/paste
+        disk_file_path = File.join(@input_dir_name, zip_file_path)
+
+        if File.directory?(disk_file_path)
+          @zip_io.mkdir(zip_file_path)
+          sub_dir = dir_content(disk_file_path)
+          write_entries(sub_dir, zip_file_path)
+        else
+          filter_xml(disk_file_path)
+          @zip_io.add(zip_file_path, disk_file_path)
+        end
+      end
+    end
+
+    # Returns array of files for the specified directory (full_path) without current_dir "." and
+    # prev directory ".."
+    def dir_content(full_path)
+      content = Dir.entries(full_path)
+      content.delete("..")
+      content.delete(".")
+      return content
+    end
+
+    # Creates random string to guarantee uniqueness of filename
+    # Adds extension to filename
+    def random_filename(extension)
+      return "#{SecureRandom.urlsafe_base64}.#{extension}"
+    end
+
+    # Creates unique filename including path to temporary directory
+    # Adds extension to filename. Default is "zip".
+    def tempfile_name(extension = "zip")
+      return "#{Dir.tmpdir}/#{random_filename(extension)}"
+    end
+
+    # Creates unique filename including path to temporary directory
+    # Adds extension to filename. Default is "zip".
+    def tempdir_name()
+      return "#{Dir.tmpdir}/#{random_filename("")}"
+    end
+
+    # check if exists or create if doesn't
+    def verify_package_xml
+      path = File.join(File.expand_path(@input_dir_name, __FILE__), "package.xml")
+      if File.exists?(path)
+        p "package.xml FOUND"
+        return true
+      else
+        # todo logic to create package.xml. use default file
+        return false
+      end
+    end
+  end # class SfdcDirectoryService
+end # module Metadata
+
+# simple test
+# test_generator = Metadata::SfdcDirectoryService.new("/Users/gt/Desktop/TestProject")
+# test_generator.write

data/lib/utilities/action_options_service.rb

@@ -0,0 +1,31 @@
+require "yaml"
+
+module Forcer
+  class ActionOptionsService
+
+    # attempts to read salesforce org information from yaml
+    def self.load_config_file(old_options = {})
+      p "attempting to load configuration.yml"
+      options = {}
+      old_options.each do |k, v|
+        options.store(k.to_sym, v)
+      end
+
+      config_file_path = File.join(Dir.pwd, "/configuration.yml")
+      return options unless File.exists?(config_file_path)
+
+      dest = options[:dest]
+      configuration = YAML.load_file(config_file_path).to_hash
+
+      return options if configuration[dest].nil?
+
+      configuration[dest].each do |key, value|
+        options.store(key.to_sym, value.to_s)  unless value.to_s.empty?
+      end
+      options[:host] = "https://#{options[:host]}" unless options[:host].include?("http")
+
+      return options
+    end
+
+  end
+end

data/lib/utilities/status_print_service.rb

@@ -0,0 +1,63 @@
+
+module Forcer
+  class StatusPrintService
+    MAX_NUMBER_RETRIES = 3 # todo move to common constants
+
+    def initialize(suppress_periodic_requests = false)
+      @suppress_periodic_requests = suppress_periodic_requests
+    end
+
+    public
+
+    # run thread to check process status
+    def run_status_check(ids, lambda_metadata)
+      header = {
+          "tns:SessionHeader" => {
+              "tns:sessionId" => ids[:session_id]
+          }
+      }
+      body = {
+          asyncProcessId: ids[:id]
+      }
+      p "REQUESTING STATUS"
+
+      response = {}
+      number_retries = 0
+      status_thread = Thread.new do
+        begin
+          response = lambda_metadata.call(header, body)
+          response_details = response.body
+          print_status(response_details)
+          break if (response_details[:check_deploy_status_response][:result][:done] || @suppress_periodic_requests)
+          sleep(5)
+        rescue Exception => ex
+          if number_retries < MAX_NUMBER_RETRIES
+            p "==== exception => #{ex}"
+            p "==== retrying"
+            response = {}
+            number_retries += 1
+            sleep(4)
+            retry
+          else
+            p "EXCEEDED MAX_NUMBER_RETRIES (#{MAX_NUMBER_RETRIES}). EXITING NOW."
+            raise ex
+          end
+        end while(number_retries < MAX_NUMBER_RETRIES)
+      end
+
+      status_thread.join()
+
+      return response
+    end
+
+    private
+    def print_status(details)
+      # status =  "DONE : #{details[:check_deploy_status_response][:result][:done]} | "
+      status = "STATUS : #{details[:check_deploy_status_response][:result][:status]} | "
+      status += "SUCCESS : #{details[:check_deploy_status_response][:result][:success]}"
+      p status
+      p "==============="
+    end
+
+  end
+end