ops_team 1.21.1 → 2.0.0.rc3

data/lib/action.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-# represents one action to be performed in the shell
-# can assemble a command line from a command and args
-class Action
-	attr_reader :name
-
-	def initialize(name, config, args)
-		@name = name
-		@config = config || {}
-		@args = args
-	end
-
-	def run
-		Output.error(Profiler.summary) if Profiler.summary
-
-		if perform_shell_expansion?
-			Kernel.exec(to_s)
-		else
-			Kernel.exec(*to_a)
-		end
-	end
-
-	def to_s
-		"#{command} #{@args.join(' ')}".strip
-	end
-
-	def alias
-		@config["alias"] || @config["aliases"]&.first
-	end
-
-	def aliases
-		return [@config["alias"]].compact unless @config["aliases"]
-
-		([@config["alias"]] + @config["aliases"]).compact
-	end
-
-	def command
-		return @config if @config.is_a?(String)
-
-		@config["command"]
-	end
-
-	def description
-		@config["description"]
-	end
-
-	def skip_hooks?(name)
-		@config["skip_#{name}_hooks"]
-	end
-
-	def config_valid?
-		config_errors.empty?
-	end
-
-	def config_errors
-		@config_errors ||= begin
-			errors = []
-
-			errors << "No 'command' specified in 'action'." unless command
-
-			errors
-		end
-	end
-
-	def load_secrets?
-		@config["load_secrets"].nil? ? false : @config["load_secrets"]
-	end
-
-	def execute_in_env?(env)
-		!skip_in_envs.include?(env)
-	end
-
-	def allowed_in_env?(env)
-		return false if not_in_envs.include?(env)
-
-		return false if in_envs.any? && !in_envs.include?(env)
-
-		true
-	end
-
-	private
-
-	def to_a
-		command.split(" ").reject(&:nil?) | @args
-	end
-
-	def not_in_envs
-		@config["not_in_envs"] || []
-	end
-
-	def in_envs
-		@config["in_envs"] || []
-	end
-
-	def skip_in_envs
-		@config["skip_in_envs"] || []
-	end
-
-	def perform_shell_expansion?
-		@config["shell_expansion"].nil? ? true : @config["shell_expansion"]
-	end
-end

data/lib/action_list.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-class ActionList
-	class UnknownActionError < StandardError; end
-
-	def initialize(actions_list, args)
-		@actions_list = actions_list
-		@args = args
-
-		process_action_list
-	end
-
-	def get(name)
-		@actions[name]
-	end
-
-	def get_by_alias(name)
-		@aliases[name]
-	end
-
-	def names
-		@actions.keys
-	end
-
-	def aliases
-		@aliases.keys
-	end
-
-	private
-
-	def actions_list
-		@actions_list ||= []
-	end
-
-	def process_action_list
-		@actions = {}
-		@aliases = {}
-
-		actions_list.each do |name, config|
-			action = Action.new(name, config, @args)
-
-			@actions[name] = action
-			action.aliases.each do |aliaz|
-				check_duplicate_alias(name, aliaz)
-				@aliases[aliaz] = action
-			end
-		end
-	end
-
-	def check_duplicate_alias(name, aliaz)
-		return if @aliases[aliaz].nil?
-
-		Output.warn("Duplicate alias '#{aliaz}' detected in action '#{name}'.")
-	end
-end

data/lib/action_suggester.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-class ActionSuggester
-	def initialize(dictionary)
-		@dictionary = dictionary
-	end
-
-	def check(word)
-		spellchecker.correct(word)
-	end
-
-	private
-
-	def spellchecker
-		@spellchecker ||= DidYouMean::SpellChecker.new(dictionary: @dictionary)
-	end
-end

data/lib/app_config.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-class AppConfig
-	class ParsingError < StandardError; end
-
-	class << self
-		def load
-			new(app_config_path).load
-		end
-
-		def default_filename
-			config_path_for(Environment.environment)
-		end
-
-		def config_path_for(env)
-			"config/#{env}/config.json"
-		end
-
-		def app_config_path
-			expand_path(Options.get("config.path") || default_filename)
-		end
-
-		private
-
-		def expand_path(path)
-			`echo #{path}`.chomp
-		end
-	end
-
-	def load
-		config['environment']&.each do |key, value|
-			if Options.get("config.preserve_existing_env_vars") && ENV[key]
-				Output.debug("Environment variable '$#{key}' already set; skipping...")
-				next
-			end
-
-			ENV[key] = value.is_a?(Hash) || value.is_a?(Array) ? value.to_json : value.to_s
-		end
-	end
-
-	private
-
-	def initialize(filename = "")
-		@filename = filename
-	end
-
-	def config
-		@config ||= if file_contents == ""
-			Output.warn("Config file '#{@filename}' exists but is empty.")
-			{}
-		elsif file_contents
-			YAML.safe_load(file_contents)
-		else
-			{}
-		end
-	rescue YAML::SyntaxError => e
-		raise ParsingError, "#{@filename}: #{e}"
-	end
-
-	def file_contents
-		@file_contents ||= begin
-			File.open(@filename).read
-		rescue Errno::ENOENT
-			nil
-		end
-	end
-end

data/lib/builtin.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-class Builtin
-	class ArgumentError < StandardError; end
-
-	attr_reader :args, :config
-
-	class << self
-		BUILTIN_DIR = "builtins"
-
-		def description
-			"no description"
-		end
-
-		def class_for(name:)
-			file = file_for(name: name)
-			unless File.exist?(file)
-				require 'require_all'
-				require_rel "builtins"
-			end
-
-			get_const(name: builtin_class_name_for(name: name))
-		end
-
-		private
-
-		def get_const(name:)
-			Builtins.const_get(name, false)
-		rescue NameError
-			# no such constant
-			nil
-		end
-
-		def file_for(name:)
-			File.join(File.dirname(__FILE__), BUILTIN_DIR, "#{name}.rb")
-		end
-
-		def builtin_class_name_for(name:)
-			name.capitalize.to_sym
-		end
-	end
-
-	def initialize(args, config)
-		@args = args
-		@config = config
-	end
-
-	def run
-		raise NotImplementedError
-	end
-end

data/lib/builtins/background.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	class Background < ::Builtin
-		DEFAULT_LOG_FILE_PREFIX = "/tmp/ops_bglog_"
-
-		class << self
-			def description
-				"runs the given command in a background session"
-			end
-
-			def log_filename
-				Options.get("background.log_filename") || "#{DEFAULT_LOG_FILE_PREFIX}#{Ops.project_name}"
-			end
-		end
-
-		def run
-			subprocess = fork do
-				set_bglog_file_permissions
-				run_ops(args)
-			end
-
-			Process.detach(subprocess)
-
-			true
-		end
-
-		private
-
-		def set_bglog_file_permissions
-			File.new(Background.log_filename, "w").chmod(0o600)
-		end
-
-		def run_ops(args)
-			Output.notice("Running '#{args.join(' ')}' with stderr and stdout redirected to '#{Background.log_filename}'")
-			$stdout.sync = $stderr.sync = true
-			$stdout.reopen(Background.log_filename, "w")
-			$stderr.reopen($stdout)
-
-			Ops.new(args).run
-		end
-	end
-
-	# set an alias
-	Bg = Background
-end

data/lib/builtins/background_log.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	class BackgroundLog < Builtin
-		class << self
-			def description
-				"displays the log from the current or most recent background task from this project"
-			end
-		end
-
-		def run
-			unless File.exist?(Background.log_filename)
-				Output.warn("No background log found at '#{Background.log_filename}'.")
-				return 0
-			end
-
-			Output.notice("Displaying background log '#{Background.log_filename}'...")
-			display_file
-		end
-
-		private
-
-		def display_file
-			if args.any?
-				exec("tail #{args.join(' ')} '#{Background.log_filename}'")
-			else
-				exec("cat '#{Background.log_filename}'")
-			end
-		end
-	end
-
-	# set an alias
-	Bglog = BackgroundLog
-end

data/lib/builtins/common/up_down.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	module Common
-		class UpDown < Builtin
-			class << self
-				def description
-					"attempts to meet dependencies listed in ops.yml"
-				end
-			end
-
-			def run
-				meet_dependencies
-
-				return true unless fail_on_error?
-
-				deps_to_meet.all?(&:success?)
-			end
-
-			private
-
-			def meet_dependencies
-				deps_to_meet.each do |dependency|
-					Output.status("[#{dependency.type}] #{dependency.name}")
-
-					meet_dependency(dependency)
-
-					break if dependency.failure? && exit_on_error?
-				end
-			end
-
-			def meet_dependency(dependency)
-				handle_dependency(dependency) if !dependency.met? || dependency.always_act?
-
-				if dependency.success?
-					Output.okay
-				else
-					Output.failed
-					Output.error("Error meeting #{dependency.type} dependency '#{dependency.name}':")
-					Output.out(dependency.output)
-				end
-			end
-
-			def deps_to_meet
-				@deps_to_meet ||= dependency_handler.dependencies.select(&:should_meet?)
-			end
-
-			def dependency_handler
-				Helpers::DependencyHandler.new(dependencies)
-			end
-
-			def dependencies
-				return @config["dependencies"] if @args.empty?
-
-				@config["dependencies"].select { |dep, _names| @args.include?(dep) }
-			end
-
-			def fail_on_error?
-				Options.get("up.fail_on_error") || false
-			end
-
-			def exit_on_error?
-				Options.get("up.exit_on_error") || false
-			end
-		end
-	end
-end

data/lib/builtins/countdown.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module Builtins
-	class Countdown < Builtin
-		USAGE_STRING = "Usage: ops countdown <seconds>"
-
-		class << self
-			def description
-				"Like `sleep`, but displays time remaining in terminal."
-			end
-		end
-
-		def run
-			check_args
-
-			timer_task.execute
-
-			while timer_task.running?
-				sleep(1)
-				timer_task.shutdown if task_complete?
-			end
-			Output.out("\rCountdown complete after #{sleep_seconds}s.")
-
-			true
-		end
-
-		private
-
-		def check_args
-			check_arg_count
-			check_arg_is_positive_int
-		end
-
-		def check_arg_count
-			raise Builtin::ArgumentError, USAGE_STRING unless args.length == 1
-		end
-
-		def check_arg_is_positive_int
-			raise Builtin::ArgumentError, USAGE_STRING unless sleep_seconds.positive?
-		# raised when the arg is not an int
-		rescue ::ArgumentError
-			raise Builtin::ArgumentError, USAGE_STRING
-		end
-
-		def timer_task
-			@timer_task ||= Concurrent::TimerTask.new(run_now: true, execution_interval: 1) do
-				Output.print("\r      \r#{seconds_left}")
-			end
-		end
-
-		def sleep_seconds
-			Integer(args.first)
-		end
-
-		def task_start_time
-			@task_start_time ||= Time.now
-		end
-
-		def task_end_time
-			@task_end_time ||= task_start_time + sleep_seconds
-		end
-
-		def task_complete?
-			Time.now > task_end_time
-		end
-
-		def seconds_left
-			Integer(task_end_time - Time.now + 1)
-		end
-	end
-end

data/lib/builtins/down.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	class Down < Common::UpDown
-		def handle_dependency(dependency)
-			dependency.unmeet
-		end
-	end
-end

data/lib/builtins/env.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	class Env < Builtin
-		class << self
-			def description
-				"prints the current environment, e.g. 'dev', 'production', 'staging', etc."
-			end
-		end
-
-		def run
-			Output.print(environment)
-
-			true
-		end
-
-		def environment
-			ENV['environment']
-		end
-	end
-end

data/lib/builtins/envdiff.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	class Envdiff < Builtin
-		class << self
-			def description
-				"compares keys present in config and secrets between different environments"
-			end
-		end
-
-		def run
-			check_args
-
-			if source_only_keys.empty? && dest_only_keys.empty?
-				Output.out("Environments '#{source_env}' and '#{dest_env}' define the same #{source_keys.length} key(s).")
-				return
-			end
-
-			output_key_summary(source_only_keys, source_env, dest_env) if source_only_keys.any?
-			output_key_summary(dest_only_keys, dest_env, source_env) if dest_only_keys.any?
-
-			true
-		end
-
-		private
-
-		def output_key_summary(keys, in_env, not_in_env)
-			Output.warn("Environment '#{in_env}' defines keys that '#{not_in_env}' does not:\n")
-			keys.each do |key|
-				Output.warn("   - #{key}")
-			end
-			Output.out("")
-		end
-
-		def source_only_keys
-			@source_only_keys ||= source_keys - dest_keys
-		end
-
-		def dest_only_keys
-			@dest_only_keys ||= dest_keys - source_keys
-		end
-
-		def source_keys
-			@source_keys ||= keys_for(source_env)
-		end
-
-		def dest_keys
-			@dest_keys ||= keys_for(dest_env)
-		end
-
-		def keys_for(env)
-			tagged_config_keys_for(env) + tagged_secrets_keys_for(env)
-		end
-
-		def tagged_config_keys_for(env)
-			config_keys_for(env).map do |key|
-				"[CONFIG] #{key}"
-			end
-		end
-
-		def tagged_secrets_keys_for(env)
-			secrets_keys_for(env).map do |key|
-				"[SECRET] #{key}"
-			end
-		end
-
-		def config_keys_for(env)
-			(config_for(env)["environment"]&.keys || []) - ignored_keys
-		end
-
-		def secrets_keys_for(env)
-			(secrets_for(env)["environment"]&.keys || []) - ignored_keys
-		end
-
-		def config_for(env)
-			YAML.load_file(config_path_for(env))
-		end
-
-		def secrets_for(env)
-			YAML.load_file(secrets_path_for(env))
-		end
-
-		def check_args
-			raise Builtin::ArgumentError, "Usage: ops envdiff <env_one> <env_two>" unless args.length == 2
-
-			check_environment(source_env)
-			check_environment(dest_env)
-		end
-
-		def source_env
-			args[0]
-		end
-
-		def dest_env
-			args[1]
-		end
-
-		def check_environment(name)
-			raise_missing_file_error(config_path_for(name)) unless config_file_exists?(name)
-			raise_missing_file_error(secrets_path_for(name)) unless secrets_file_exists?(name)
-		end
-
-		def raise_missing_file_error(path)
-			raise Builtin::ArgumentError, "File '#{path}' does not exist."
-		end
-
-		def config_file_exists?(env)
-			File.exist?(config_path_for(env))
-		end
-
-		def secrets_file_exists?(env)
-			File.exist?(secrets_path_for(env))
-		end
-
-		def config_path_for(env)
-			AppConfig.config_path_for(env)
-		end
-
-		def secrets_path_for(env)
-			Secrets.config_path_for(env)
-		end
-
-		def ignored_keys
-			Options.get("envdiff.ignored_keys") || []
-		end
-	end
-end

data/lib/builtins/exec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Builtins
-	class Exec < Builtin
-		class << self
-			def description
-				"executes the given command in the `ops` environment, i.e. with environment variables set"
-			end
-		end
-
-		def run
-			Secrets.load if Options.get("exec.load_secrets")
-
-			if args.any?
-				Output.error(Profiler.summary) if Profiler.summary
-				Kernel.exec(args.join(" "))
-			else
-				Output.error("Usage: ops exec '<command>'")
-
-				false
-			end
-		end
-	end
-end