rbcli 0.3.2 → 0.4.0

data/lib/rbcli/features/userconfig.rb

@@ -1,163 +0,0 @@
-##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program is free software: you can redistribute it and/or modify       #
-#     it under the terms of the GNU General Public License as published by       #
-#     the Free Software Foundation, either version 3 of the License, or          #
-#     (at your option) any later version.                                        #
-#                                                                                #
-#     This program is distributed in the hope that it will be useful,            #
-#     but WITHOUT ANY WARRANTY; without even the implied warranty of             #
-#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
-#     GNU General Public License for more details.                               #
-#                                                                                #
-#     You should have received a copy of the GNU General Public License          #
-#     along with this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
-##################################################################################
-
-####
-# Config Module
-####
-# The config module manages two distinct sets of config: one is the user's, and one is the application's default.
-# This allows you to set default values for your configuration files, and can use the default values to generate a
-# new user config file at any time by writing them to a file.
-#
-# Usage
-#
-# Rbcli::config[:key]
-#   Provides access to config file hash values under :key.
-#   Note the lowercase 'c' in config, which is different from the rest of the functions below.
-#
-# Rbcli::Config::set_file(filename, autoload:true, merge_defaults: false)
-#   This function allows you to set the path for the user's config file (eg: /etc/myscript/config.yml).
-#     autoload will load the file at the same time
-#     merge_defaults will fill in missing values in the user's config with default ones
-#
-# Rbcli::Config::add_defaults(filename)
-#   This function loads the contents of a YAML or JSON file into the default config. Used for custom configuration.
-#
-# Rbcli::Config::load
-#   This forces a reload of the config file.
-#
-# Rbcli::Config::generate_userconf
-#   This writes the config defaults to the filename set using the set_file command.
-####
-
-require 'yaml'
-require 'fileutils'
-require 'deep_merge'
-
-module Rbcli
-	def self.config
-		Rbcli::Config::config
-	end
-end
-
-module Rbcli::Config
-
-	@config = nil
-	@config_file = nil
-	@config_defaults = nil
-	@merge_defaults = false
-	@categorized_defaults = nil
-	@loaded = false
-
-	def self.set_userfile filename, merge_defaults: true, required: false
-		return if filename.nil?
-		@config_file = File.expand_path filename
-		@merge_defaults = merge_defaults
-		@userfile_required = required
-		@loaded = false
-	end
-
-	def self.add_categorized_defaults name, description, config
-		@categorized_defaults ||= {}
-		@categorized_defaults[name.to_sym] = {
-				description: description,
-				config: config
-		}
-
-		@config_defaults ||= {}
-		@config_defaults[name.to_sym] = {}
-		config.each do |k, v|
-			@config_defaults[name.to_sym][k.to_sym] = v[:value]
-		end
-		@loaded = false
-	end
-
-	def self.add_default name, description: nil, default: nil
-		@config_individual_lines ||= []
-		text = "#{name.to_s}: #{default}".ljust(30) + " # #{description}"
-		@config_individual_lines.push text unless @config_individual_lines.include? text
-		@config_defaults[name.to_sym] = default
-		@loaded = false
-	end
-
-	def self.add_defaults filename=nil, text: nil
-		filename = File.expand_path filename
-		return unless filename and File.exist? filename
-		@config_text ||= ''
-		@config_text += "\n" unless @config_text.empty?
-		File.readlines(filename).each do |line|
-			if line.start_with? '---' or line.start_with? '...'
-				@config_text << "\n" unless @config_text.empty?
-			else
-				@config_text << line unless @config_text.include? line
-			end
-		end if filename and File.exist? filename
-		@config_text << "\n\n" << text if text
-
-		@config_defaults ||= {}
-		@config_defaults.deep_merge! YAML.safe_load(@config_text, [], [], true).deep_symbolize!
-		@loaded = false
-	end
-
-	def self.load
-		if (! @config_file.nil?) and File.exist? @config_file
-			@config = YAML.safe_load(File.read(@config_file), [], [], true).deep_symbolize!
-			@config.deep_merge! @config_defaults if @merge_defaults
-		elsif @userfile_required
-			puts "User's config file not found at #{@config_file}. Please run this tool with the `--generate-config` option to generate it."
-			exit 1
-		else
-			@config = @config_defaults
-		end
-		@loaded = true
-		@config
-	end
-
-	def self.config
-		self.load unless @loaded
-		(@config.nil?) ? @config_defaults : @config
-	end
-
-	def self.generate_userconf filename
-		filepath = File.expand_path "#{(filename) ? filename : "#{Dir.pwd}/config.yml"}"
-		FileUtils.touch filepath
-		File.write filepath, @config_text
-		File.open(filepath, 'a') do |f|
-			f.puts "# Individual Settings"
-			@config_individual_lines.each { |l| f.puts l }
-		end if @config_individual_lines
-
-
-		if @categorized_defaults
-			text = ''
-			@categorized_defaults.each do |name, opts|
-				text += "\n# #{opts[:description]}\n"
-				text += "#{name.to_s}:\n"
-				opts[:config].each do |opt, v|
-					text += "  #{opt.to_s}: #{(v[:value].nil?) ? '~' : v[:value]}".ljust(30) + " # #{v[:description]}\n"
-				end
-			end
-			File.open(filepath, 'a') do |f|
-				f.puts text
-			end
-		end
-	end
-
-end
-

data/lib/rbcli/state_storage/common/state_storage.rb

@@ -1,138 +0,0 @@
-##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program is free software: you can redistribute it and/or modify       #
-#     it under the terms of the GNU General Public License as published by       #
-#     the Free Software Foundation, either version 3 of the License, or          #
-#     (at your option) any later version.                                        #
-#                                                                                #
-#     This program is distributed in the hope that it will be useful,            #
-#     but WITHOUT ANY WARRANTY; without even the implied warranty of             #
-#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
-#     GNU General Public License for more details.                               #
-#                                                                                #
-#     You should have received a copy of the GNU General Public License          #
-#     along with this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
-##################################################################################
-
-require 'fileutils'
-require 'json'
-
-
-module Rbcli::State
-
-	## Main State Class
-	class StateStorage
-
-		def initialize path, force_creation: false, halt_on_error: true, lazy_load: true
-			@path = path
-			@force_creation = force_creation
-			@halt_on_error = halt_on_error
-
-			state_subsystem_init
-
-			# Lazy load option
-			@loaded = false
-			state_create unless lazy_load
-		end
-
-		def []= key, value
-			state_create unless @loaded
-			@data[:data][key.to_sym] = value
-			save_state
-			@data[:data][key.to_sym]
-		end
-
-		def [] key
-			state_create unless @loaded
-			@data[:data][key.to_sym]
-		end
-
-		def delete key, &block
-			state_create unless @loaded
-			result = @data[:data].delete key.to_sym, &block
-			save_state
-			result
-		end
-
-		def refresh
-			if @loaded
-				load_state
-			else
-				state_create
-			end
-		end
-
-		def commit
-			save_state if @loaded
-		end
-
-		def clear
-			state_create unless @loaded
-			@data[:data] = {}
-			save_state
-		end
-
-		def disconnect
-			unlock if self.class.method_defined? :unlock
-			@loaded = false
-			@data[:data] = nil
-		end
-
-		def each &block
-			state_create unless @loaded
-			@data[:data].each &block
-			save_state
-		end
-
-		def key? key
-			state_create unless @loaded
-			@data[:data].key? key.to_sym
-		end
-
-		def to_h
-			state_create unless @loaded
-			@data[:data]
-		end
-
-		def to_s
-			state_create unless @loaded
-			to_h.to_s
-		end
-
-		# For framework's internal use
-
-		def rbclidata key = nil
-			state_create unless @loaded
-			return @data[:rbcli][key.to_sym] unless key.nil?
-			@data[:rbcli]
-		end
-
-		def set_rbclidata key, value
-			state_create unless @loaded
-			@data[:rbcli][key.to_sym] = value
-			save_state
-		end
-
-		private
-
-		def state_create
-			base_data = {data: {}, rbcli: {}}
-			if state_exists?
-				load_state
-			elsif @force_creation
-				create_state
-				@data = base_data
-				save_state
-			else
-				raise StandardError "State location #{@path} does not exist or can not be accessed." if @halt_on_error
-				@data = base_data
-			end
-			@loaded = true
-		end
-
-	end
-end

data/lib/rbcli/state_storage/localstate.rb

@@ -1,77 +0,0 @@
-##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program is free software: you can redistribute it and/or modify       #
-#     it under the terms of the GNU General Public License as published by       #
-#     the Free Software Foundation, either version 3 of the License, or          #
-#     (at your option) any later version.                                        #
-#                                                                                #
-#     This program is distributed in the hope that it will be useful,            #
-#     but WITHOUT ANY WARRANTY; without even the implied warranty of             #
-#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
-#     GNU General Public License for more details.                               #
-#                                                                                #
-#     You should have received a copy of the GNU General Public License          #
-#     along with this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
-##################################################################################
-
-require 'rbcli/state_storage/common/state_storage'
-require 'fileutils'
-require 'json'
-
-## User Interface
-module Rbcli
-	def self.local_state
-		Rbcli.configuration(:storage, :localstate)
-	end
-end
-
-## Local State Module
-module Rbcli::State
-
-	class LocalStorage < StateStorage
-
-		def state_subsystem_init
-			@path = File.expand_path @path
-		end
-
-		def state_exists?
-			File.exist? @path
-		end
-
-		def create_state
-			begin
-				FileUtils.mkdir_p File.dirname(@path)
-				FileUtils.touch @path
-			rescue Errno::EACCES => e
-				error "Can not create file #{@path}. Please make sure the directory is writeable." if @halt_on_error
-			end
-		end
-
-		def load_state
-			begin
-				@data = JSON.parse(File.read(@path)).deep_symbolize!
-			rescue Errno::ENOENT, Errno::EACCES => e
-				error "Can not read from file #{@path}. Please make sure the file exists and is readable." if @halt_on_error
-			end
-		end
-
-		def save_state
-			begin
-				File.write @path, JSON.dump(@data)
-			rescue Errno::ENOENT, Errno::EACCES => e
-				error "Can not write to file #{@path}. Please make sure the file exists and is writeable." if @halt_on_error
-			end
-		end
-
-		def error text
-			raise LocalStateError.new "Error accessing local state: #{text}"
-		end
-
-		class LocalStateError < StandardError; end
-	end
-
-end

data/lib/rbcli/state_storage/placeholders.rb

@@ -1,29 +0,0 @@
-##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program is free software: you can redistribute it and/or modify       #
-#     it under the terms of the GNU General Public License as published by       #
-#     the Free Software Foundation, either version 3 of the License, or          #
-#     (at your option) any later version.                                        #
-#                                                                                #
-#     This program is distributed in the hope that it will be useful,            #
-#     but WITHOUT ANY WARRANTY; without even the implied warranty of             #
-#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
-#     GNU General Public License for more details.                               #
-#                                                                                #
-#     You should have received a copy of the GNU General Public License          #
-#     along with this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
-##################################################################################
-
-module Rbcli
-	def self.local_state
-		raise Exception.new "Warning: Usage of Local State requires Local State Storage to be enabled in your application's configuration."
-	end
-
-	def self.remote_state
-		raise Exception.new "Warning: Usage of Remote State requires Remote State Storage to be enabled in your application's configuration."
-	end
-end

data/lib/rbcli/state_storage/remote_state_connectors/dynamodb.rb

@@ -1,272 +0,0 @@
-##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program is free software: you can redistribute it and/or modify       #
-#     it under the terms of the GNU General Public License as published by       #
-#     the Free Software Foundation, either version 3 of the License, or          #
-#     (at your option) any later version.                                        #
-#                                                                                #
-#     This program is distributed in the hope that it will be useful,            #
-#     but WITHOUT ANY WARRANTY; without even the implied warranty of             #
-#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
-#     GNU General Public License for more details.                               #
-#                                                                                #
-#     You should have received a copy of the GNU General Public License          #
-#     along with this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
-##################################################################################
-
-require 'aws-sdk-dynamodb'
-require 'macaddr'
-require 'digest/sha2'
-require 'rufus-scheduler'
-
-module Rbcli::State::RemoteConnectors
-	class DynamoDB
-
-		def self.save_defaults aws_access_key_id: nil, aws_secret_access_key: nil
-			Rbcli::Config::add_categorized_defaults :dynamodb_remote_state, 'Remote State Settings - requires DynamoDB', {
-					access_key_id: {
-							description: 'AWS Access Key ID -- leave as null to look for AWS credentials on system. See: https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html',
-							value: aws_access_key_id
-					},
-					secret_access_key: {
-							description: 'AWS Secret Access Key -- leave as null to look for AWS credentials on system.',
-							value: aws_secret_access_key
-					}
-			}
-		end
-
-		def initialize dynamodb_table, region, aws_access_key_id, aws_secret_access_key, locking: false, lock_timeout: 60
-			@region = region
-			@dynamo_table_name = dynamodb_table
-			@item_name = Rbcli::configuration(:me, :scriptname)
-			@locking = locking
-			@scheduler = nil
-			@lock_timeout = lock_timeout
-			@exit_code_set = false
-			@should_unlock_at_exit = false
-
-			@dynamo_client = Aws::DynamoDB::Client.new(
-					region: @region,
-					access_key_id: aws_access_key_id,
-					secret_access_key: aws_secret_access_key
-			)
-		end
-
-		def create_table
-			# We only need to create the table
-			unless table_exists?
-				print "Creating DynmoDB Table. Please wait..."
-				@dynamo_client.create_table(
-						{
-								attribute_definitions: [
-										{
-												attribute_name: "Script Name",
-												attribute_type: "S"
-										}
-								],
-								key_schema: [
-										{
-												attribute_name: "Script Name",
-												key_type: "HASH"
-										}
-								],
-								provisioned_throughput: {
-										read_capacity_units: 5,
-										write_capacity_units: 5,
-								},
-								table_name: @dynamo_table_name,
-						}
-				)
-				wait_for_table_creation
-			end
-		end
-
-		def table_exists?
-			@dynamo_client.list_tables.table_names.to_a.include? @dynamo_table_name
-		end
-
-		def object_exists?
-			begin
-				item = @dynamo_client.get_item(
-						{
-								key: {'Script Name' => @item_name},
-								table_name: @dynamo_table_name,
-						}
-				)
-				return (!item.item.nil?)
-			rescue Aws::DynamoDB::Errors::ResourceNotFoundException
-				return false
-			end
-		end
-
-		def get_object
-			lock_or_wait
-			item = @dynamo_client.get_item(
-					{
-							key: {'Script Name' => @item_name},
-							table_name: @dynamo_table_name,
-					}
-			).item
-			item.delete 'Script Name'
-			item
-		end
-
-		def save_object datahash
-			raise StandardError "DynamoDB has been locked by another user since the last change. Please try again later." if locked?
-			lock_or_wait
-			@dynamo_client.put_item(
-					{
-							table_name: @dynamo_table_name,
-							item: datahash.merge({'Script Name' => @item_name})
-					}
-			)
-		end
-
-		def lock
-			@dynamo_client.put_item(
-					{
-							table_name: @dynamo_table_name,
-							item: {
-									'Script Name' => "#{@item_name}_lock",
-									'locked' => true,
-									'locked_until' => (Time.now + @lock_timeout).getutc.strftime('%s'),
-									'locked_by' => Digest::SHA2.hexdigest(Mac.addr)
-							}
-					}
-			)
-		end
-
-		def unlock
-			@dynamo_client.put_item(
-					{
-							table_name: @dynamo_table_name,
-							item: {
-									'Script Name' => "#{@item_name}_lock",
-									'locked' => false,
-									'locked_until' => Time.now.getutc.strftime('%s'),
-									'locked_by' => false
-							}
-					}
-			)
-			@scheduler.shutdown :kill if @scheduler
-			@should_unlock_at_exit = false
-			@scheduler = nil
-		end
-
-		def locked?
-			lockdata = get_lockdata
-			(lockdata['locked']) and (lockdata['locked_until'].to_i > Time.now.getutc.to_i) and (lockdata['locked_by'] != Digest::SHA2.hexdigest(Mac.addr))
-		end
-
-		def lock_or_wait recursed = false
-			return true unless @locking
-			delay_in_seconds = 2
-			lockdata = get_lockdata
-
-			should_claim = false
-
-			# First, we identify if the lock is active
-			if lockdata['locked']
-				# If the lock is not ours, we have to check the expiration
-				if lockdata['locked_by'] != Digest::SHA2.hexdigest(Mac.addr)
-					# If the lock is not ours, and it has expired, we claim it
-					if lockdata['locked_until'].to_i < Time.now.getutc.to_i
-						should_claim = true
-						# If the lock data is not ours and has not expired, we wait and try again
-					else
-						print 'Acquiring lock on DynamoDB. Please wait..' unless recursed
-						print '.'
-						sleep delay_in_seconds
-						lock_or_wait true
-					end
-
-					# If the lock is ours, we check the expiry
-				else
-					# If the lock is ours and is close to expiry or has expired, we refresh it
-					if lockdata['locked_until'].to_i < (Time.now - (@lock_timeout / 10)).getutc.to_i
-						should_claim = true
-						# If the lock is ours and is not near expiry, do nothing
-					else
-						# Do nothing! But do finish the string that's shown to the user
-						puts 'done!' if recursed
-					end
-				end
-			else # If clearly unlocked, we claim it
-				should_claim = true
-			end
-
-
-			if should_claim
-				# We attempt to get a lock then validate our success
-				lock
-				# If we succeeded then we set up a scheduler to ensure we keep it
-				lockdata = get_lockdata
-				if (lockdata['locked_by'] == Digest::SHA2.hexdigest(Mac.addr)) and (lockdata['locked_until'].to_i > Time.now.getutc.to_i)
-					# Of course, if the scheduler already exists, we don't bother
-					unless @scheduler
-						@scheduler ||= Rufus::Scheduler.new
-						@scheduler.every "#{@lock_timeout - 2}s" do
-							lock
-						end
-						# We also make sure we release the lock at exit. In case this doesn't happen, the lock will expire on its own
-						@should_unlock_at_exit = true
-						unless @exit_code_set
-							at_exit {unlock if @should_unlock_at_exit}
-							@exit_code_set = true
-						end
-					end
-					puts 'done!' if recursed
-					# If we failed locking then we need to try the process all over again
-				else
-					print 'Error: Failed to lock DynamoDB. Retrying...'
-					sleep delay_in_seconds
-					lock_or_wait true
-				end
-
-			end
-
-		end
-
-		# END lock_or_wait
-
-		private
-
-		def wait_for_table_creation
-			delay_in_seconds = 2
-			active = false
-			while not active
-				sleep delay_in_seconds
-				print '.'
-				#@dynamo_table = @dynamo_db.table @dynamo_table_name
-				begin
-					result = @dynamo_client.describe_table({table_name: @dynamo_table_name})
-					active = (result.table.table_status == "ACTIVE")
-						#active = (@dynamo_table.table_status == "ACTIVE")
-				rescue Aws::DynamoDB::Errors::ResourceNotFoundException
-					# We want to ignore this exception since we expect the table to be created at some point.
-					# In real usage this error likely won't occur, and instead we will see table_status == "CREATING"
-				end
-			end
-			puts "done!"
-		end
-
-		def get_lockdata
-			item = @dynamo_client.get_item(
-					{
-							key: {'Script Name' => "#{@item_name}_lock"},
-							table_name: @dynamo_table_name
-					}
-			).item
-			if item.nil?
-				lock
-				return get_lockdata
-			end
-			item
-		end
-
-	end
-end