ops_team 1.21.1 → 2.0.0.rc3

data/lib/dependencies/versioned_dependency.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Dependencies
-	class VersionedDependency < Dependency
-		VERSION_SEPARATOR = " "
-
-		def dep_name
-			name_components[0]
-		end
-
-		def dep_version
-			name_components[1]
-		end
-
-		def versioned?
-			!!dep_version
-		end
-
-		private
-
-		def name_components
-			name.split(VERSION_SEPARATOR, 2)
-		end
-	end
-end

data/lib/dependency.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-require 'English'
-
-class Dependency
-	DESCRIPTION_TYPE_WIDTH = 8
-
-	attr_reader :name
-
-	def initialize(name)
-		@name = name
-	end
-
-	def met?
-		raise NotImplementedError
-	end
-
-	def meet
-		raise NotImplementedError
-	end
-
-	def unmeet
-		raise NotImplementedError
-	end
-
-	# should_meet? can be used to implement dependencies that should only be met on some platforms,
-	# e.g. brew on Macs and apt on Linux
-	# it can be used to base a decision on anything else that can be read from the environment at
-	# runtime
-	def should_meet?
-		true
-	end
-
-	# if true, this type of resource must always have `meet` and `unmeet` called;
-	# useful for resources that can't easily be checked to see if they're met
-	def always_act?
-		false
-	end
-
-	def type
-		self.class.name.split('::').last
-	end
-
-	def success?
-		@executor.nil? ? true : @executor.success?
-	end
-
-	def failure?
-		!success?
-	end
-
-	def output
-		@executor&.output
-	end
-
-	def exit_code
-		@executor&.exit_code
-	end
-
-	private
-
-	def execute(cmd)
-		@executor = Executor.new(cmd)
-		@executor.execute
-
-		@executor.success?
-	end
-end

data/lib/environment.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-class Environment
-	class << self
-		def environment
-			return 'dev' if ENV['environment'].nil? || ENV['environment'].empty?
-
-			ENV['environment']
-		end
-	end
-
-	def initialize(env_hash, config_path)
-		@env_hash = env_hash
-		@config_path = config_path
-	end
-
-	def set_variables
-		set_ops_variables
-		set_environment_aliases
-		set_configured_variables
-	end
-
-	private
-
-	def set_ops_variables
-		ENV["OPS_YML_DIR"] = File.dirname(@config_path)
-		ENV["OPS_VERSION"] = Version.version.to_s
-		ENV["OPS_SECRETS_FILE"] = Secrets.app_config_path
-		ENV["OPS_CONFIG_FILE"] = AppConfig.app_config_path
-	end
-
-	def set_environment_aliases
-		environment_aliases.each do |alias_name|
-			ENV[alias_name] = Environment.environment
-		end
-	end
-
-	def environment_aliases
-		Options.get("environment_aliases") || ['environment']
-	end
-
-	def set_configured_variables
-		@env_hash.each do |key, value|
-			ENV[key] = `echo #{value}`.chomp
-		end
-	end
-end

data/lib/executor.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class Executor
-	attr_reader :output, :exit_code
-
-	def initialize(command)
-		@command = command
-	end
-
-	def execute
-		@output, status = Open3.capture2e(@command)
-		@exit_code = status.exitstatus
-
-		success?
-	end
-
-	def success?
-		@exit_code.nil? ? true : @exit_code.zero?
-	end
-end

data/lib/forward.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-class Forward
-	def initialize(dir, args)
-		@dir = dir
-		@args = args
-	end
-
-	def run
-		Output.notice("Forwarding 'ops #{@args.join(" ")}' to '#{@dir}/'...")
-
-		Dir.chdir(@dir)
-		Ops.new(@args).run
-	end
-end

data/lib/forwards.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-class Forwards
-	def initialize(config, args = [])
-		@config = config
-		@args = args
-	end
-
-	def get(name)
-		Forward.new(forwards[name], @args) if forwards[name]
-	end
-
-	def forwards
-		@forwards ||= @config["forwards"] || {}
-	end
-end

data/lib/hook_handler.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-class HookHandler
-	class HookConfigError < StandardError; end
-
-	class HookExecError < StandardError; end
-
-	def initialize(config)
-		@config = config
-	end
-
-	def do_hooks(name)
-		raise HookConfigError, "'hooks.#{name}' must be a list" unless hooks(name).is_a?(Array)
-
-		execute_hooks(name)
-	end
-
-	private
-
-	def hooks(name)
-		@config.dig("hooks", name) || []
-	end
-
-	def execute_hooks(name)
-		hooks(name).each do |hook|
-			Output.notice("Running #{name} hook: #{hook}")
-			output, exit_code = execute_hook(hook)
-
-			next if exit_code.zero?
-
-			raise HookExecError, "#{name} hook '#{hook}' failed with exit code #{exit_code}:\n#{output}"
-		end
-	end
-
-	def execute_hook(name)
-		executor = Executor.new(name)
-		executor.execute
-
-		[executor.output, executor.exit_code]
-	end
-end

data/lib/ops.rb

@@ -1,129 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-Profiler.measure("ops:requires_external") do
-	require 'yaml'
-	require "rubygems"
-end
-
-Profiler.measure("ops:requires_internal") do
-end
-
-CONFIG_FILES = ["ops.yaml", "ops.yml"].freeze
-
-# executes commands based on local `ops.yml`
-class Ops
-	INVALID_SYNTAX_EXIT_CODE = 64
-	UNKNOWN_ACTION_EXIT_CODE = 65
-	ERROR_LOADING_APP_CONFIG_EXIT_CODE = 66
-	MIN_VERSION_NOT_MET_EXIT_CODE = 67
-	ACTION_CONFIG_ERROR_EXIT_CODE = 68
-	BUILTIN_SYNTAX_ERROR_EXIT_CODE = 69
-	ACTION_NOT_ALLOWED_IN_ENV_EXIT_CODE = 70
-
-	RECOMMEND_HELP_TEXT = "Run 'ops help' for a list of builtins and actions."
-
-	class << self
-		def project_name
-			File.basename(::Dir.pwd)
-		end
-	end
-
-	def initialize(argv, config_file: nil)
-		@action_name = argv[0]
-		@args = argv[1..-1]
-		@config_file = config_file || CONFIG_FILES.find { |file| File.exist?(file) } || "ops.yml"
-
-		Options.set(config["options"] || {})
-	end
-
-	# rubocop:disable Metrics/MethodLength
-	# better to have all the rescues in one place
-	def run
-		# "return" is here to allow specs to stub "exit" without executing everything after it
-		return exit(INVALID_SYNTAX_EXIT_CODE) unless syntax_valid?
-		return exit(MIN_VERSION_NOT_MET_EXIT_CODE) unless min_version_met?
-
-		Profiler.measure("runner:run") do
-			runner.run
-		end
-	rescue Runner::UnknownActionError => e
-		Output.error(e.to_s)
-		Output.out(RECOMMEND_HELP_TEXT) unless print_did_you_mean
-		exit(UNKNOWN_ACTION_EXIT_CODE)
-	rescue Runner::ActionConfigError => e
-		Output.error("Error(s) running action '#{@action_name}': #{e}")
-		exit(ACTION_CONFIG_ERROR_EXIT_CODE)
-	rescue Builtin::ArgumentError => e
-		Output.error("Error running builtin '#{@action_name}': #{e}")
-		exit(BUILTIN_SYNTAX_ERROR_EXIT_CODE)
-	rescue AppConfig::ParsingError => e
-		Output.error("Error parsing app config: #{e}")
-		exit(ERROR_LOADING_APP_CONFIG_EXIT_CODE)
-	rescue Runner::NotAllowedInEnvError => e
-		Output.error("Error running action #{@action_name}: #{e}")
-		exit(ACTION_NOT_ALLOWED_IN_ENV_EXIT_CODE)
-	end
-	# rubocop:enable Metrics/MethodLength
-
-	private
-
-	def syntax_valid?
-		return true unless @action_name.nil?
-
-		Output.error("Usage: ops <action>")
-		Output.out(RECOMMEND_HELP_TEXT)
-		false
-	end
-
-	def print_did_you_mean
-		Output.out("Did you mean '#{runner.suggestions.join(", ")}'?") if runner.suggestions.any?
-
-		runner.suggestions.any?
-	end
-
-	def min_version_met?
-		return true unless min_version
-
-		if Version.min_version_met?(min_version)
-			true
-		else
-			Output.error("ops.yml specifies minimum version of #{min_version}, but ops version is #{Version.version}")
-			false
-		end
-	end
-
-	def min_version
-		config["min_version"]
-	end
-
-	def runner
-		@runner ||= Runner.new(@action_name, @args, config, config_file_absolute_path)
-	end
-
-	def config
-		@config ||= if config_file_exists?
-			parsed_config_contents
-		else
-			Output.warn("File '#{@config_file}' does not exist.") unless @action_name == "init"
-			{}
-		end
-	end
-
-	def parsed_config_contents
-		YAML.load_file(@config_file)
-	rescue StandardError => e
-		Output.warn("Error parsing '#{@config_file}': #{e}")
-		{}
-	end
-
-	def config_file_exists?
-		File.exist?(@config_file)
-	end
-
-	def config_file_absolute_path
-		File.expand_path(@config_file)
-	end
-end
-
-Ops.new(ARGV).run if $PROGRAM_NAME == __FILE__

data/lib/options.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class Options
-	class << self
-		def get(path)
-			env_var = ENV[env_var(path)]
-			return YAML.safe_load(env_var) unless env_var.nil?
-
-			@options&.dig(*path.split('.'))
-		end
-
-		def set(options)
-			@options = options
-		end
-
-		private
-
-		def env_var(path)
-			"OPS__#{path.upcase.gsub(".", "__")}"
-		end
-	end
-end

data/lib/output.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'colorize'
-
-class Output
-	@out = STDOUT
-	@err = STDERR
-
-	STATUS_WIDTH = "50"
-
-	OKAY = "OK"
-	SKIPPED = "SKIPPED"
-	FAILED = "FAILED"
-
-	# used to silence output, e.g. in testing
-	class DummyOutput
-		def print(*_); end
-
-		def puts(*_); end
-	end
-
-	class << self
-		def status(name)
-			@out.print(format("%-#{STATUS_WIDTH}<name>s ", name: name))
-		end
-
-		def okay
-			@out.puts(OKAY.green)
-		end
-
-		def skipped
-			@out.puts(SKIPPED.yellow)
-		end
-
-		def failed
-			@out.puts(FAILED.red)
-		end
-
-		def warn(msg)
-			@err.puts(msg.yellow)
-		end
-
-		alias notice warn
-
-		def error(msg)
-			@err.puts(msg.red)
-		end
-
-		def out(msg)
-			@out.puts(msg)
-		end
-
-		def print(msg)
-			@out.print(msg)
-		end
-
-		def debug(msg)
-			return unless ENV["OPS_DEBUG_OUTPUT"]
-
-			@err.puts(msg.blue)
-		end
-
-		def silence
-			@out = @err = dummy_output
-		end
-
-		def dummy_output
-			@dummy_output ||= DummyOutput.new
-		end
-	end
-end

data/lib/profiler.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-class Profiler
-	INDENT = "  "
-
-	@measurements = {}
-
-	class << self
-		attr_reader :measurements
-
-		def measure(tag)
-			start = time_now
-			result = yield
-			add_measurement(tag, time_now - start)
-
-			result
-		end
-
-		def add_measurement(tag, seconds)
-			return unless profiling?
-
-			@measurements[tag] ||= []
-
-			@measurements[tag] << seconds
-		end
-
-		def summary
-			return unless profiling?
-
-			@summary ||= measurements.reverse_each.each_with_object([]) do |(tag, values), output|
-				output << "#{tag}:\n"
-				values.sort.reverse.each do |value|
-					value_str = format("%.3f", value * 1000)
-					output << format("%<indent>s%9<value>sms\n", indent: INDENT, value: value_str)
-				end
-			end.join
-		end
-
-		def profiling?
-			!ENV["OPS_PROFILE"].nil?
-		end
-
-		def time_now
-			Process.clock_gettime(Process::CLOCK_MONOTONIC)
-		end
-	end
-end

data/lib/runner.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-end
-
-class Runner
-	class UnknownActionError < StandardError; end
-
-	class ActionConfigError < StandardError; end
-
-	class NotAllowedInEnvError < StandardError; end
-
-	def initialize(action_name, args, config, config_path)
-		@action_name = action_name
-		@args = args
-		@config = config
-		@config_path = config_path
-	end
-
-	def run
-		return forward.run if forward
-
-		do_before_all
-
-		return builtin.run if builtin
-
-		raise UnknownActionError, "Unknown action: #{@action_name}" unless action
-		raise ActionConfigError, action.config_errors.join("; ") unless action.config_valid?
-
-		do_before_action
-
-		run_action
-	end
-
-	def suggestions
-		@suggestions ||= ActionSuggester.new(action_list.names + action_list.aliases + builtin_names).check(@action_name)
-	end
-
-	private
-
-	def do_before_all
-		AppConfig.load
-		Secrets.load if action&.load_secrets?
-		environment.set_variables
-	end
-
-	def do_before_action
-		return if ENV["OPS_RUNNING"] || action.skip_hooks?("before")
-
-		# this prevents before hooks from running in ops executed by ops
-		ENV["OPS_RUNNING"] = "1"
-		hook_handler.do_hooks("before")
-	end
-
-	def hook_handler
-		@hook_handler ||= HookHandler.new(@config)
-	end
-
-	def builtin
-		Profiler.measure("runner:require_builtin") do
-			@builtin ||= Builtin.class_for(name: @action_name)&.new(@args, @config)
-		end
-	rescue NameError
-		# this means there isn't a builtin with that name in that module
-		nil
-	end
-
-	def builtin_names
-		Builtins.constants.select { |c| Builtins.const_get(c).is_a? Class }.map(&:downcase)
-	end
-
-	def forward
-		@forward ||= Forwards.new(@config, @args).get(@action_name)
-	end
-
-	def run_action
-		unless action.allowed_in_env?(Environment.environment)
-			raise NotAllowedInEnvError, "Action not allowed in #{Environment.environment} environment."
-		end
-
-		unless action.execute_in_env?(Environment.environment)
-			Output.warn("Skipping action '#{action.name}' in environment #{Environment.environment}.")
-			return true
-		end
-
-		Output.notice("Running '#{action}' in environment '#{ENV['environment']}'...")
-		action.run
-	end
-
-	def action
-		return action_list.get(@action_name) if action_list.get(@action_name)
-		return action_list.get_by_alias(@action_name) if action_list.get_by_alias(@action_name)
-	end
-
-	def action_list
-		@action_list ||= begin
-			Output.warn("'ops.yml' has no 'actions' defined.") if @config.any? && @config["actions"].nil?
-
-			ActionList.new(@config["actions"], @args)
-		end
-	end
-
-	def env_vars
-		@config.dig("options", "environment") || {}
-	end
-
-	def environment
-		@environment ||= Environment.new(env_vars, @config_path)
-	end
-end

data/lib/secrets.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'open3'
-
-class Secrets < AppConfig
-	class << self
-		def default_filename
-			config_path_for(Environment.environment)
-		end
-
-		def config_path_for(env)
-			File.exist?(ejson_path_for(env)) ? ejson_path_for(env) : json_path_for(env)
-		end
-
-		def app_config_path
-			expand_path(Options.get("secrets.path") || default_filename)
-		end
-
-		private
-
-		def ejson_path_for(env)
-			"config/#{env}/secrets.ejson"
-		end
-
-		def json_path_for(env)
-			"config/#{env}/secrets.json"
-		end
-	end
-
-	def initialize(filename = "")
-		@filename = filename.empty? ? Secrets.default_filename : actual_filename_for(filename)
-	end
-
-	private
-
-	def actual_filename_for(filename)
-		File.exist?(filename) ? filename : filename.sub(".ejson", ".json")
-	end
-
-	def file_contents
-		@file_contents ||= @filename.match(/\.ejson$/) ? ejson_contents : super
-	end
-
-	def ejson_contents
-		@ejson_contents ||= begin
-			out, err, _status = Open3.capture3("ejson decrypt #{@filename}")
-
-			# TODO: err is only nil in testing, but I can't figure out why the stubbing isn't working
-			raise ParsingError, "#{@filename}: #{err}" unless err.nil? || err.empty?
-
-			out
-		end
-	end
-end

data/lib/version.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "rubygems"
-
-class Version
-	GEMSPEC_FILE = "#{__dir__}/../ops_team.gemspec"
-
-	class << self
-		# these class methods exist because I don't want to have to call `Version.new.version` elsewhere
-		def version
-			new.send(:version)
-		end
-
-		def min_version_met?(min_version)
-			new.send(:min_version_met?, min_version)
-		end
-	end
-
-	private
-
-	# these instance methods exist so that I don't have to clear class variables between tests
-	def version
-		unless gemspec
-			Output.error("Unable to load gemspec at '#{GEMSPEC_FILE}")
-			return nil
-		end
-
-		gemspec.version
-	end
-
-	def min_version_met?(min_version)
-		Gem::Version.new(version) >= Gem::Version.new(min_version)
-	end
-
-	def gemspec
-		@gemspec ||= Gem::Specification.load(GEMSPEC_FILE)
-	end
-end