407 lines
15 KiB
Ruby
407 lines
15 KiB
Ruby
require "metaforce"
|
|
require "base64"
|
|
|
|
module AbuseTheForce
|
|
attr_accessor :client, :can_notify
|
|
|
|
begin
|
|
require "terminal-notifier"
|
|
@can_notify = true
|
|
rescue LoadError
|
|
@can_notify = false
|
|
end
|
|
|
|
# Write error to screen
|
|
def self.pute(s, fatal=false)
|
|
puts "Error: #{s}"
|
|
|
|
# If fatal error, exit
|
|
if fatal
|
|
exit 1
|
|
end
|
|
end
|
|
|
|
# Write warning to screen
|
|
def self.putw(s)
|
|
puts "Warning: #{s}"
|
|
end
|
|
|
|
# builds the client instance of Metaforce
|
|
def self.build_client
|
|
target = Atf_Config.active_target
|
|
|
|
puts target.username
|
|
|
|
@client = Metaforce.new :username => target.username,
|
|
:password => target.get_password,
|
|
:security_token => target.security_token
|
|
|
|
Metaforce.configuration.host = target.host
|
|
|
|
# Supress some of the verbose logging
|
|
Metaforce.configuration.log = false
|
|
end
|
|
|
|
# Fetches a single file from the server
|
|
def self.retrieve_file(metadata_type, full_name)
|
|
|
|
if @client == nil
|
|
build_client
|
|
end
|
|
|
|
# Backup old Manifest
|
|
FileUtils.copy(
|
|
File.join(Atf_Config.get_project_path, 'package.xml'),
|
|
File.join(Atf_Config.get_project_path, 'package.xml-bak')
|
|
)
|
|
|
|
manifest = Metaforce::Manifest.new(metadata_type => [full_name])
|
|
|
|
@client.retrieve_unpackaged(manifest).
|
|
extract_to(Atf_Config.get_project_path).
|
|
on_complete { |job| puts "Finished retrieve #{job.id}!" }.
|
|
on_error { |job| puts "Something bad happened!" }.
|
|
on_poll { |job| puts "Polling for #{job.id}!" }.
|
|
perform
|
|
|
|
# Restore old Manifest
|
|
FileUtils.move(
|
|
File.join(Atf_Config.get_project_path, 'package.xml-bak'),
|
|
File.join(Atf_Config.get_project_path, 'package.xml')
|
|
)
|
|
end
|
|
|
|
# Fetches a whole project from the server
|
|
def self.retrieve_project()
|
|
|
|
if @client == nil
|
|
build_client
|
|
end
|
|
|
|
if File.file? File.join(Atf_Config.get_project_path, 'package.xml')
|
|
@client.retrieve_unpackaged(File.expand_path(Atf_Config.src + '/package.xml')).
|
|
extract_to(Atf_Config.get_project_path).
|
|
on_complete { |job| puts "Finished retrieve #{job.id}!" }.
|
|
on_error { |job| puts "Something bad happened!" }.
|
|
on_poll { |job| puts "Polling for #{job.id}!" }.
|
|
perform
|
|
else
|
|
puts "#{Atf_Config.get_project_path}: Not a valid project path"
|
|
end
|
|
end
|
|
|
|
def self.deploy_test(dpath, test_name)
|
|
|
|
options = { :run_tests => [ test_name ], :rollback_on_error => true }
|
|
|
|
deploy_project(dpath, options)
|
|
end
|
|
|
|
def self.deploy_project(dpath=Atf_Config.get_project_path, options={ :rollback_on_error => true })
|
|
|
|
# Result hash that we can use for our results
|
|
atf_result = {:success => nil, :run => nil, :failed => nil}
|
|
|
|
if @client == nil
|
|
build_client
|
|
end
|
|
|
|
# Set auto update
|
|
options[:auto_update_package] = true
|
|
|
|
if File.file? File.join(dpath, 'package.xml')
|
|
@client.deploy(File.expand_path(dpath), options).
|
|
on_complete { |job|
|
|
puts "Finished deploy #{job.id}!"
|
|
result = job.result
|
|
|
|
if result != nil
|
|
|
|
# Need messages in an array
|
|
unless result.messages.kind_of? Array
|
|
result.messages = [].push result.messages
|
|
end
|
|
|
|
# If running a test, see if there really was a success
|
|
if options[:run_tests] != nil
|
|
result.success = true
|
|
result.messages.each do |m|
|
|
result.success = result.success && m.success
|
|
end
|
|
end
|
|
|
|
# Check if this was a test execution and successfully deployed
|
|
if options[:run_tests] != nil && result.success
|
|
|
|
atf_result[:success] = result.run_test_result.num_failures == "0"
|
|
# Display a quick Success or Failure
|
|
puts "\nTests #{atf_result[:success] ? "SUCCESS" : "FAILURE"}"
|
|
|
|
# Display overview of number of successes and failures
|
|
atf_result[:run] = result.run_test_result.num_tests_run
|
|
atf_result[:failed] = result.run_test_result.num_failures
|
|
puts "TESTS RUN: #{atf_result[:run]} FAILURES: #{atf_result[:failed]}"
|
|
|
|
if result.run_test_result.failures != nil
|
|
|
|
# Make sure failures is an array
|
|
unless result.run_test_result.failures.kind_of? Array
|
|
result.run_test_result.failures = [].push result.run_test_result.failures
|
|
end
|
|
|
|
result.run_test_result.failures.each do |m|
|
|
|
|
# Print our error in teh format "filename:line:column type in object message"
|
|
if !m.success
|
|
puts "#{m.name}.#{m.method_name}: #{m.message}"
|
|
puts "Stack Trace: #{m.stack_trace}"
|
|
puts ""
|
|
end # not success
|
|
end # loop through test faiulres
|
|
end # failures != nil
|
|
|
|
if Atf_Config.notify == nil
|
|
Atf_Config.notify = @can_notify
|
|
Atf_Config.dump_settings
|
|
end
|
|
|
|
if @can_notify && Atf_Config.notify
|
|
TerminalNotifier.notify("Tests run: #{atf_result[:run]} Failures: #{atf_result[:failed]}",
|
|
:title => "AbuseTheForce",
|
|
:subtitle => "Test Execution: #{(atf_result[:success] ? "SUCCESS" : "FAILURE")}"
|
|
)
|
|
end
|
|
|
|
else # run_test_result != nil
|
|
|
|
puts "\nDeploy #{result.success ? "SUCCESS" : "FAILURE"}"
|
|
atf_result[:success] = result.success
|
|
|
|
# Not a test execution, so deployment
|
|
|
|
# If a failed deploy, print errors
|
|
if result.success == false
|
|
|
|
if result.messages.any?
|
|
puts "DEPLOY ERRORS: #{result.messages.reject { |m| m.success }.size}"
|
|
|
|
result.messages.each do |m|
|
|
|
|
# If the path is not from the project, fix it
|
|
unless m.file_name.starts_with? Atf_Config.src
|
|
m.file_name = m.file_name.sub(/[a-zA-Z._-]*\//, Atf_Config.src + '/')
|
|
end
|
|
|
|
# Print our error in the format "filename:line:column type in object message"
|
|
if !m.success
|
|
puts "#{m.file_name}:#{m.line_number}:#{m.column_number} #{m.problem_type} in #{m.full_name} #{m.problem}"
|
|
end
|
|
end
|
|
else
|
|
puts "DEPLOY ERRORS: UKNOWN"
|
|
end
|
|
end # success == false
|
|
|
|
if Atf_Config.notify == nil
|
|
Atf_Config.notify = @can_notify
|
|
Atf_Config.dump_settings
|
|
end
|
|
|
|
if @can_notify && Atf_Config.notify
|
|
TerminalNotifier.notify(" ",
|
|
:title => "AbuseTheForce",
|
|
:subtitle => "Deploy: #{(atf_result[:success] ? "SUCCESS" : "FAILURE")}"
|
|
)
|
|
end
|
|
|
|
end # end result.run_test_result != null else
|
|
end # result != nil
|
|
}.
|
|
on_error { |job| puts "Something bad happened!" }.
|
|
on_poll { |job| puts "Polling for #{job.id}!" }.
|
|
perform
|
|
else
|
|
puts "#{dpath}: Not a valid project path"
|
|
end
|
|
|
|
return atf_result
|
|
end
|
|
|
|
class Atf_Config
|
|
class << self
|
|
attr_accessor :targets, :active_target, :src, :root_dir, :notify
|
|
SETTINGS_FILE=".abusetheforce.yaml"
|
|
|
|
def locate_root(path = '.')
|
|
|
|
temp_path = path
|
|
|
|
# Look for a settings file in this path and up to root
|
|
until File.file? File.join(temp_path, SETTINGS_FILE)
|
|
# If we hit root, stop
|
|
if temp_path == '/'
|
|
break
|
|
end
|
|
|
|
# Didn't find one so go up one level
|
|
temp_path = File.absolute_path File.dirname(temp_path)
|
|
end
|
|
|
|
# If we actually found it
|
|
if File.file? File.join(temp_path, SETTINGS_FILE)
|
|
# Return
|
|
return temp_path
|
|
else
|
|
# Return the original path
|
|
return path
|
|
end
|
|
|
|
end
|
|
|
|
# Loads configurations from yaml
|
|
def load()
|
|
|
|
# Get the project root directory
|
|
@root_dir = locate_root
|
|
|
|
if File.file? File.join(@root_dir, SETTINGS_FILE)
|
|
settings = YAML.load_file File.join(@root_dir, SETTINGS_FILE)
|
|
@targets = settings[:targets]
|
|
@src = settings[:src]
|
|
@notify = settings[:notify]
|
|
else
|
|
puts "No settings file found, creating one now"
|
|
# Settings file doesn't exist
|
|
# Create it
|
|
@targets = {}
|
|
@active_target = nil
|
|
@src = './src'
|
|
@notify = true
|
|
|
|
dump_settings
|
|
end
|
|
|
|
# Set the default target
|
|
@targets.values.each do |target|
|
|
# Check if this one is active
|
|
if target.active == true
|
|
# Set it if there is no default target set yet
|
|
if @active_target == nil
|
|
@active_target = target
|
|
else
|
|
puts "Two active targets set. Using #{@active_target.print}"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# write settings to a yaml file
|
|
def dump_settings
|
|
File.open(SETTINGS_FILE, 'w') do |out|
|
|
YAML.dump( { :targets => @targets, :src => @src }, out)
|
|
end
|
|
end
|
|
|
|
# Adds a new target to the config
|
|
def add_target(target)
|
|
|
|
# If there are no targets yet, use this one as the default
|
|
if @active_target == nil #@targets.empty?
|
|
target.active = true
|
|
@active_target = target
|
|
end
|
|
|
|
# Push the new target
|
|
@targets[target.name] = target
|
|
|
|
#write out the config
|
|
dump_settings
|
|
|
|
puts "Target Added"
|
|
target.print
|
|
end
|
|
|
|
# Selects one target as the active target for deployment
|
|
def set_active_target(name)
|
|
|
|
# Empty out current active target
|
|
@active_target = nil
|
|
|
|
# Go through each pair
|
|
@targets.each_pair do |target_name, target|
|
|
# If you find a matching item
|
|
if name == target_name
|
|
# Check if there is already a default
|
|
if @active_target == nil
|
|
# Set active
|
|
target.active = true
|
|
# Make it default
|
|
@active_target = target
|
|
end
|
|
else # name != name
|
|
# make not active
|
|
target.active = false
|
|
end
|
|
end
|
|
|
|
if @active_target != nil
|
|
# Save to yaml
|
|
dump_settings
|
|
# Notify the user
|
|
puts "Active target changed"
|
|
@active_target.print
|
|
else
|
|
AbuseTheForce.pute "Target with alias #{name} was not found."
|
|
end
|
|
|
|
end
|
|
|
|
# Sets project path from default ./src
|
|
def set_project_path(ppath)
|
|
if File.file? File.join(ppath, 'package.xml')
|
|
@src = ppath
|
|
dump_settings
|
|
else
|
|
pute("No package.xml found in #{ppath}", true)
|
|
end
|
|
end
|
|
|
|
# Gets the full path to the src folder
|
|
def get_project_path
|
|
return File.absolute_path File.join(root_dir, src)
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
# Class for holding a target
|
|
class Atf_Target
|
|
attr_accessor :name, :username, :password, :security_token, :host, :active
|
|
|
|
def initialize(name, username, password, security_token, host="login.salesforce.com")
|
|
@name = name
|
|
@username = username
|
|
set_password(password)
|
|
@security_token = security_token
|
|
@host = host
|
|
@active = false;
|
|
end
|
|
|
|
# TODO: Provide 2 way encryption with a lock to decode passwords
|
|
def set_password(password)
|
|
@password = Base64.encode64(password)
|
|
end
|
|
|
|
def get_password()
|
|
return Base64.decode64(@password)
|
|
end
|
|
|
|
def print
|
|
#puts "#{@name}\t#{@username}\t#{@host}\t#{(@active && 'Active') || ''}"
|
|
puts "#{(@active ? '*' : ' ')} #{@name}\t\t#{@username}\t#{(@host.starts_with?('test') ? 'sandbox' : '')}\t"
|
|
end
|
|
end
|
|
|
|
end
|
|
|