rbcli 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '091cd6eaa815d90823dbb657bc8307322bc0b272a83cf372eaa68456c65aa504'
-  data.tar.gz: ac8bc103360d5748382020bf796ee11adb1a14c6bb4147158ad15030582b4371
+  metadata.gz: 4368206fc709a9d855156e9a447c8de3715f4916063af8d189a23dba1fb92c1a
+  data.tar.gz: 6f4dbed307cb87216c28a78a9c07774dde6245c3a8615afb921ab0d3d4df9764
 SHA512:
-  metadata.gz: e2229c9330274945480d37d3547faa7c22b5079ebbc89f880f028859b6d906726ce69b1330302fd8e38b88532c73c0d2fffb1c2be97e14f562c2c847bb46cd94
-  data.tar.gz: c3239439910f6f2ea594c426f94889eb18be945ea2ae3a335915200e20e217b61b5c396a3639af42b6737810e75c969c45ee31f1563653dff681e0b6426078b3
+  metadata.gz: 59a004efa92a3a62d0b6a9bfb1e2fc4c0f0ada6c7c61f26d920a85c7903ba1a0282bd2fcdf91e56db8b56c20e9c0e00fbc82fcde6fcae31c631b4e866813a433
+  data.tar.gz: a96255d756e764c65ea9c25616967194cc77922b813dfe8c7bf7601be107e50a705e12ed3641e0945261c12b510b0d5d821d094d0ca8182054c50003fc3a1985

data/Gemfile.lock

@@ -1,17 +1,46 @@
 PATH
   remote: .
   specs:
-    rbcli (0.1.3)
+    rbcli (0.1.4)
+      aws-sdk-dynamodb (~> 1.6)
       colorize (~> 0.8)
       deep_merge (~> 1.2)
+      macaddr (~> 1.7)
+      rufus-scheduler (~> 3.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    aws-eventstream (1.0.0)
+    aws-partitions (1.87.0)
+    aws-sdk-core (3.21.2)
+      aws-eventstream (~> 1.0)
+      aws-partitions (~> 1.0)
+      aws-sigv4 (~> 1.0)
+      jmespath (~> 1.0)
+    aws-sdk-dynamodb (1.6.0)
+      aws-sdk-core (~> 3)
+      aws-sigv4 (~> 1.0)
+    aws-sigv4 (1.0.2)
     colorize (0.8.1)
     deep_merge (1.2.1)
+    et-orbi (1.1.2)
+      tzinfo
+    fugit (1.1.1)
+      et-orbi (~> 1.1, >= 1.1.1)
+      raabro (~> 1.1)
+    jmespath (1.4.0)
+    macaddr (1.7.1)
+      systemu (~> 2.6.2)
     minitest (5.11.3)
+    raabro (1.1.5)
     rake (10.5.0)
+    rufus-scheduler (3.5.0)
+      fugit (~> 1.1, >= 1.1.1)
+    systemu (2.6.5)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -16,6 +16,10 @@ Some of its key features include:
 
 * __Local State Storage__: Easily manage a set of data that persists between runs. You get access to a hash that is automatically kept in-sync with a file on disk.
 
+* __Remote State__: It works just like Local State Storage, but store the data on a remote server! It can be used in tandem with Local State Storage or on its own. Currently supports AWS DyanmoDB.  
+
+* __State Locking and Sharing__: Share remote state safely between users with built-in locking! When enabled, it makes sure that only one user is accessing the data at any given time.
+
 ## Installation
 
 RBCli is available on rubygems.org. You can add it to your application's `Gemrile` or `gemspec`, or install it manually via `gem install rbcli`.
@@ -62,7 +66,7 @@ Creating a new skeleton command is as easy as running `rbcli init <filename>`. I
 ```ruby
 require 'rbcli'
 
-Rbcli::configurate do
+Rbcli::Configurate.me do
 	scriptname __FILE__.split('/')[-1]                                     # (Required) This line identifies the tool's executable. You can change it if needed, but this should work for most cases.
 	version '0.1.0'                                                        # (Required) The version number
 	description 'This is my test CLI tool.'                                # (Requierd) A description that will appear when the user looks at the help with -h. This can be as long as needed.
@@ -115,7 +119,8 @@ Once parsed, options will be placed in a hash where they can be accessed via the
 
 ```ruby
 Rbcli::Configurate.storage do
-	local_state '/var/mytool/localstate', force_creation: true, ignore_file_errors: false    # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.localstate[:yourkeyhere]
+	local_state '/var/mytool/localstate', force_creation: true, halt_on_error: true                                                     # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.local_state[:yourkeyhere]
+	remote_state_dynamodb table_name: 'mytable', region: 'us-east-1', force_creation: true, halt_on_error: true, locking: true          # (Optional) Creates a hash that is automatically saved to a DynamoDB table. It is recommended to keep halt_on_error=true when using a shared state.
 end
 ```
 
@@ -136,10 +141,12 @@ class Test < Rbcli::Command
 
 	action do |params, args, global_opts, config|                                      # (Required) Block to execute if the command is called.
 		Rbcli::log.info { 'These logs can go to STDERR, STDOUT, or a file' }               # Example log. Interface is identical to Ruby's logger
-		puts "\nArgs:\n#{args}"                # Arguments that came after the command on the CLI
-		puts "Params:\n#{params}"              # Parameters, as described through the option statements above
-		puts "Global opts:\n#{global_opts}"    # Global Parameters, as descirbed in the Configurate section
-		puts "Config:\n#{config}"              # Config file values
+		puts "\nArgs:\n#{args}"                    # Arguments that came after the command on the CLI
+		puts "Params:\n#{params}"                  # Parameters, as described through the option statements above
+		puts "Global opts:\n#{global_opts}"        # Global Parameters, as descirbed in the Configurate section
+		puts "Config:\n#{config}"                  # Config file values
+		puts "LocalState:\n#{Rbcli.local_state}"   # Local persistent state storage (when available) -- if unsure use Rbcli.local_state.nil?
+		puts "RemoteState:\n#{Rbcli.remote_state}" # Remote persistent state storage (when available) -- if unsure use Rbcli.remote_state.nil?
 		puts "\nDone!!!"
 	end
 end
@@ -225,18 +232,19 @@ logger:
 
 ```ruby
 Rbcli::Configurate.storage do
-	local_state '/var/mytool/localstate', force_creation: true, ignore_file_errors: false    # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.localstate[:yourkeyhere]
+	local_state '/var/mytool/localstate', force_creation: true, halt_on_error: true                                                   # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.local_state[:yourkeyhere]
+	remote_state_dynamodb table_name: 'mytable', region: 'us-east-1', force_creation: true, halt_on_error: true, locking: true        # (Optional) Creates a hash that is automatically saved to a DynamoDB table. It is recommended to keep halt_on_error=true when using a shared state.
 end
 ```
 
-### Local State
+### <a name="local_state"></a> Local State
 
 RBCli's local state storage gives you access to a hash that is automatically persisted to disk when changes are made.
 
 Once configured you can access it with a standard hash syntax:
 
 ```ruby
-Rbcli.localstate[:yourkeyhere]
+Rbcli.local_state[:yourkeyhere]
 ```
 
 For performance reasons, the only methods available for use are `=` (assignment operator), `delete`, `each`, and `key?`. Also, the `clear` method has been added, which resets the data back to an empty hash. Keys are accessed via either symbols or strings indifferently.
@@ -247,7 +255,7 @@ Every assignment will result in a write to disk, so if an operation will require
 
 ```ruby
 Rbcli::Configurate.storage do
-	local_state '/var/mytool/localstate', force_creation: true, ignore_file_errors: false    # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.localstate[:yourkeyhere]
+	local_state '/var/mytool/localstate', force_creation: true, halt_on_error: true                                   # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.local_state[:yourkeyhere]
 end
 ```
 
@@ -255,13 +263,67 @@ There are three parameters to configure it with:
 * The `path` as a string (self-explanatory)
 * `force_creation`
 	* This will attempt to create the path and file if it does not exist (equivalent to an `mkdir -p` and `touch` in linux)
-* `ignore_file_errors`
+* `halt_on_error`
 	* RBCli's default behavior is to raise an exception if the file can not be created, read, or updated at any point in time
-	* If this is set to `true`, RBCli will silence any errors pertaining to file access and will fall back to whatever data is available. Note that if this is enabled, changes made to the state may not be persisted to disk.
+	* If this is set to `false`, RBCli will silence any errors pertaining to file access and will fall back to whatever data is available. Note that if this is enabled, changes made to the state may not be persisted to disk.
 		* If creation fails and file does not exist, you start with an empty hash
 		* If file exists but can't be read, you will have an empty hash
 		* If file can be read but not written, the hash will be populated with the data. Writes will be stored in memory while the application is running, but will not be persisted to disk.
 
+### <a name="remote_state">Remote State
+
+RBCli's remote state storage gives you access to a hash that is automatically persisted to a remote storage location when changes are made. It has locking built-in, meaning that multiple users may share remote state without any data consistency issues!
+
+Once configured you can access it with a standard hash syntax:
+
+```ruby
+Rbcli.remote_state[:yourkeyhere]
+```
+
+This works the same way that [Local State](#local_state) does, with the same performance caveats (try not to do many writes!).
+
+#### DynamoDB Configuration
+
+Before DynamoDB can be used, AWS API credentials have to be created and made available. RBCli will attempt to find credentials from the following locations in order:
+
+1. User's config file
+2. Environment variables `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`
+3. User's AWSCLI configuration at `~/.aws/credentials`
+
+For more information about generating and storing AWS credentials, see [Configuring the AWS SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html).
+
+```ruby
+Rbcli::Configurate.storage do
+	remote_state_dynamodb table_name: 'mytable', region: 'us-east-1', force_creation: true, halt_on_error: true, locking: true        # (Optional) Creates a hash that is automatically saved to a DynamoDB table. It is recommended to keep halt_on_error=true when using a shared state.
+end
+```
+
+These are the parameters:
+* `table_name`
+	* The name of the DynamoDB table to use.
+* `region`
+	* The AWS region that the database is located
+* `force_creation`
+	* Creates the DynamoDB table if it does not already exist
+* `halt_on_error`
+	* Similar to the way [Local State](#local_state) works, setting this to `false` will silence any errors in connecting to the DynamoDB table. Instead, your application will simply have access to an empty hash that does not get persisted anywhere.
+	* This is good for use cases that involve using this storage as a cache to "pick up where you left off in case of failure", where a connection error might mean the feature doesn't work but its not important enough to interrupt the user.
+* `locking`
+	* This enables locking, for when you are sharing state between different instances of the application. For more information see the [section below](#distributed_locking).
+
+#### <a name="distributed_locking">Distributed Locking and State Sharing
+
+Distributed Locking allows a remote state to be shared among multiple users of the application without risk of data corruption. To use it, simply set the  `locking:` parameter to `true` when enabling remote state (see above).
+
+This is how locking works:
+
+1. The application attempts to acquire a lock on the remote state when it starts
+2. If the backend is locked by a different application, wait and try again
+3. If it succeeds, the lock is held and refreshed periodically
+4. When the application exits, the lock is released
+5. If the application does not refresh its lock, or fails to release it when it exits, the lock will automatically expire within 60 seconds
+6. If another application steals the lock (unlikely but possible), and the application tries to save data, a `StandardError` will be thrown
+7. You can manually attempt to lock/unlock by calling `Rbcli.remote_state.lock` or `Rbcli.remote_state.unlock`, respectively.
 
 ## Development
 

data/examples/mytool

@@ -35,7 +35,7 @@ Rbcli::Configurate.me do
 		puts 'This is a post-command hook. It executes after the command.'
 	end
 
-	first_run halt_after_running: true do                                  # (Optional) Allows providing a block of code that executes the first time that the application is run on a given system. If `halt_after_running` is set to `true` then parsing will not continue after this code is executed. All subsequent runs will not execute this code.
+	first_run halt_after_running: false do                                 # (Optional) Allows providing a block of code that executes the first time that the application is run on a given system. If `halt_after_running` is set to `true` then parsing will not continue after this code is executed. All subsequent runs will not execute this code.
 		puts "This is the first time the mytool command is run! Don't forget to generate a config file with the `-g` option before continuing."
 	end
 end
@@ -47,7 +47,8 @@ end
 # are configured here.
 ###############################
 Rbcli::Configurate.storage do
-	local_state '/var/mytool/localstate', force_creation: true, ignore_file_errors: false    # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.localstate[:yourkeyhere]
+	local_state '/var/mytool/localstate', force_creation: true, halt_on_error: true                                                   # (Optional) Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.localstate[:yourkeyhere]
+	remote_state_dynamodb table_name: 'mytable', region: 'us-east-1', force_creation: true, halt_on_error: true, locking: :auto       # (Optional) Creates a hash that is automatically saved to a DynamoDB table. It is recommended to keep halt_on_error=true when using a shared state. Locking can be one of (:manual :auto :none) -- see the README for details
 end
 
 #########################
@@ -67,10 +68,12 @@ class Test < Rbcli::Command
 
 	action do |params, args, global_opts, config|                                      # (Required) Block to execute if the command is called.
 		Rbcli::log.info { 'These logs can go to STDERR, STDOUT, or a file' }               # Example log. Interface is identical to Ruby's logger
-		puts "\nArgs:\n#{args}"                # Arguments that came after the command on the CLI
-		puts "Params:\n#{params}"              # Parameters, as described through the option statements above
-		puts "Global opts:\n#{global_opts}"    # Global Parameters, as descirbed in the Configurate section
-		puts "Config:\n#{config}"              # Config file values
+		puts "\nArgs:\n#{args}"                    # Arguments that came after the command on the CLI
+		puts "Params:\n#{params}"                  # Parameters, as described through the option statements above
+		puts "Global opts:\n#{global_opts}"        # Global Parameters, as descirbed in the Configurate section
+		puts "Config:\n#{config}"                  # Config file values
+		puts "LocalState:\n#{Rbcli.local_state}"   # Local persistent state storage (when available) -- if unsure use Rbcli.local_state.nil?
+		puts "RemoteState:\n#{Rbcli.remote_state}" # Remote persistent state storage (when available) -- if unsure use Rbcli.remote_state.nil?
 		puts "\nDone!!!"
 	end
 end

data/lib/rbcli/stateful_systems/state_storage.rb

@@ -0,0 +1,89 @@
+require 'fileutils'
+require 'json'
+
+
+module Rbcli::State
+
+	## Main State Class
+	class StateStorage
+
+		def initialize path, force_creation: false, halt_on_error: true
+			@path = path
+			@force_creation = force_creation
+			@halt_on_error = halt_on_error
+
+			state_subsystem_init
+
+			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
+		end
+
+		def []= key, value
+			@data[:data][key.to_sym] = value
+			save_state
+			@data[:data][key.to_sym]
+		end
+
+		def [] key
+			@data[:data][key.to_sym]
+		end
+
+		def delete key, &block
+			result = @data[:data].delete key.to_sym, block
+			save_state
+			result
+		end
+
+		def refresh
+			load_state
+		end
+
+		def clear
+			@data[:data] = {}
+			save_state
+		end
+
+		def each &block
+			@data[:data].each &block
+			save_state
+		end
+
+		def key? key
+			@data[:data].key? key.to_sym
+		end
+
+		def to_h
+			@data[:data]
+		end
+
+		def to_s
+			to_h.to_s
+		end
+
+		# For framework's internal use
+
+		def rbclidata key = nil
+			return @data[:rbcli][key.to_sym] unless key.nil?
+			@data[:rbcli]
+		end
+
+		def set_rbclidata key, value
+			@data[:rbcli][key.to_sym] = value
+			save_state
+		end
+
+	end
+end

data/lib/rbcli/stateful_systems/storagetypes/localstate.rb

@@ -0,0 +1,65 @@
+require 'fileutils'
+require 'json'
+
+## Configuration Interface
+module Rbcli::ConfigurateStorage
+	@data[:localstate] = nil
+
+	def self.local_state path, force_creation: false, halt_on_error: false
+		@data[:localstate] = Rbcli::State::LocalStorage.new(path, force_creation: force_creation, halt_on_error: halt_on_error)
+	end
+end
+
+## User Interface
+module Rbcli
+	def self.local_state
+		Rbcli::ConfigurateStorage.data[: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.exists? @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/stateful_systems/storagetypes/remote_state_connectors/dynamodb.rb

@@ -0,0 +1,240 @@
+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[:scriptname]
+			@locking = locking
+			@scheduler = nil
+			@lock_timeout = lock_timeout
+
+			@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
+			@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
+						at_exit do
+							unlock
+						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
+			@dynamo_client.get_item(
+					{
+							key: {'Script Name' => "#{@item_name}_lock"},
+							table_name: @dynamo_table_name,
+					}
+			).item
+		end
+
+	end
+end

data/lib/rbcli/stateful_systems/storagetypes/remotestate_dynamodb.rb

@@ -0,0 +1,109 @@
+## Configuration Interface
+module Rbcli::ConfigurateStorage
+	@data[:remotestate] = nil
+	@data[:remotestate_init_params] = nil
+
+	def self.remote_state_dynamodb table_name: nil, region: nil, force_creation: false, halt_on_error: true, locking: false
+		raise StandardError "Must decalre `table_name` and `region` to use remote_state_dynamodb" if table_name.nil? or region.nil?
+		@data[:remotestate_init_params] = {
+				dynamodb_table: table_name,
+				region: region,
+				locking: locking
+		}
+		@data[:remotestate] = Rbcli::State::DynamoDBStorage.new(table_name, force_creation: force_creation, halt_on_error: halt_on_error)
+	end
+end
+
+## User Interface
+module Rbcli
+	def self.remote_state
+		Rbcli::ConfigurateStorage.data[:remotestate]
+	end
+end
+
+## Remote State Module
+module Rbcli::State
+
+	class DynamoDBStorage < StateStorage
+
+		# def initialize dynamodb_table, region, force_creation: false, halt_on_error: true
+		#
+		# 	# Set defaults in Rbcli's config
+		# 	Rbcli::State::RemoteStorage::Connectors::DynamoDB.save_defaults
+		#
+		# 	# Create DynamoDB Connector
+		# 	@dynamodb = Rbcli::State::RemoteStorage::Connectors::DynamoDB.new dynamodb_table, region, Rbcli::config[:aws_access_key_id], Rbcli::config[:aws_secret_access_key]
+		#
+		# 	super dynamodb_table, force_creation: force_creation, halt_on_error: halt_on_error
+		# end
+
+		def state_subsystem_init
+			@locking = Rbcli::ConfigurateStorage::data[:remotestate_init_params][:locking]
+			dynamodb_table = Rbcli::ConfigurateStorage::data[:remotestate_init_params][:dynamodb_table]
+			region = Rbcli::ConfigurateStorage::data[:remotestate_init_params][:region]
+
+			# Set defaults in Rbcli's config
+			Rbcli::State::RemoteConnectors::DynamoDB.save_defaults
+
+			# Create DynamoDB Connector
+			@dynamodb = Rbcli::State::RemoteConnectors::DynamoDB.new dynamodb_table, region, Rbcli::config[:aws_access_key_id], Rbcli::config[:aws_secret_access_key], locking: Rbcli::ConfigurateStorage::data[:remotestate_init_params][:locking]
+		end
+
+		def state_exists?
+			return false unless make_dynamo_call { @dynamodb.table_exists? }
+			make_dynamo_call { @dynamodb.object_exists? }
+		end
+
+		def create_state
+			make_dynamo_call do
+				@dynamodb.create_table
+			end
+		end
+
+		def load_state
+			make_dynamo_call do
+				@data = @dynamodb.get_object.deep_symbolize!
+			end
+		end
+
+		def save_state
+			make_dynamo_call do
+				@dynamodb.save_object @data
+			end
+		end
+
+		def lock
+			@dynamodb.lock_or_wait if @locking
+		end
+
+		def unlock
+			@dynamodb.unlock if @locking
+		end
+
+		def error text
+			raise RemoteStateError.new "Error accessing remote state: #{text}"
+		end
+
+		class RemoteStateError < StandardError;
+		end
+
+		private
+
+		def make_dynamo_call &block
+			begin
+				yield
+			rescue Aws::Errors::MissingCredentialsError
+				error "Missing AWS Credentials: unable to sign in. Please put the credentials in your config file or update them on the local system." if @halt_on_error
+			rescue Aws::DynamoDB::Errors::UnrecognizedClientException
+				error "Unauthorized AWS Credentials: unable to sign in. Please check the credentials that you are using to make sure they are valid." if @halt_on_error
+			rescue
+				raise if @halt_on_error
+			end
+		end
+
+	end
+
+end
+
+
+require 'rbcli/stateful_systems/storagetypes/remote_state_connectors/dynamodb'

data/lib/rbcli/util/config.rb

@@ -114,7 +114,8 @@ module Rbcli::Config
 	end
 
 	def self.generate_userconf filename
-		filepath = "#{(filename) ? filename : "#{Dir.pwd}/config.yml"}"
+		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"
@@ -128,7 +129,7 @@ module Rbcli::Config
 				text += "\n# #{opts[:description]}\n"
 				text += "#{name.to_s}:\n"
 				opts[:config].each do |opt, v|
-					text += "  #{opt.to_s}: #{v[:value]}".ljust(30) + " # #{v[:description]}\n"
+					text += "  #{opt.to_s}: #{(v[:value].nil?) ? '~' : v[:value]}".ljust(30) + " # #{v[:description]}\n"
 				end
 			end
 			File.open(filepath, 'a') do |f|

data/lib/rbcli/version.rb

@@ -1,3 +1,3 @@
 module Rbcli
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/rbcli.rb

@@ -8,7 +8,9 @@ require "rbcli/util"
 
 # STATE TOOLS
 require "rbcli/stateful_systems/configuratestorage"
-require "rbcli/stateful_systems/localstorage/localstate"
+require "rbcli/stateful_systems/state_storage"
+require "rbcli/stateful_systems/storagetypes/localstate"
+require "rbcli/stateful_systems/storagetypes/remotestate_dynamodb"
 # END STATE TOOLS
 
 require "rbcli/configurate"

data/rbcli.gemspec

@@ -40,5 +40,9 @@ Gem::Specification.new do |spec|
 
 	spec.add_dependency 'colorize', '~> 0.8'
 	spec.add_dependency 'deep_merge', '~> 1.2'
+	spec.add_dependency 'aws-sdk-dynamodb', '~> 1.6'
+	spec.add_dependency 'macaddr', '~> 1.7'
+	spec.add_dependency 'rufus-scheduler', '~> 3.5'
+
 	#spec.add_dependency 'trollop', '~> 2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbcli
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Andrew Khoury
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-27 00:00:00.000000000 Z
+date: 2018-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-dynamodb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: macaddr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
 description: RBCli is a framework to quickly develop command-line tools.
 email:
 - akhoury@live.com
@@ -106,7 +148,10 @@ files:
 - lib/rbcli/engine/command.rb
 - lib/rbcli/engine/parser.rb
 - lib/rbcli/stateful_systems/configuratestorage.rb
-- lib/rbcli/stateful_systems/localstorage/localstate.rb
+- lib/rbcli/stateful_systems/state_storage.rb
+- lib/rbcli/stateful_systems/storagetypes/localstate.rb
+- lib/rbcli/stateful_systems/storagetypes/remote_state_connectors/dynamodb.rb
+- lib/rbcli/stateful_systems/storagetypes/remotestate_dynamodb.rb
 - lib/rbcli/util.rb
 - lib/rbcli/util/config.rb
 - lib/rbcli/util/hash_deep_symbolize.rb

data/lib/rbcli/stateful_systems/localstorage/localstate.rb

@@ -1,124 +0,0 @@
-require 'fileutils'
-require 'json'
-
-## Configuration Interface
-module Rbcli::ConfigurateStorage
-	@data[:localstate] = nil
-
-	def self.local_state path, force_creation: false, ignore_file_errors: false
-		@data[:localstate] = Rbcli::LocalState.new path, force_creation: force_creation, ignore_file_errors: ignore_file_errors
-	end
-end
-
-## User Interface
-module Rbcli
-	def self.local_state
-		Rbcli::ConfigurateStorage.data[:localstate]
-	end
-end
-
-
-## Local State Class
-class Rbcli::LocalState
-
-	def initialize path, force_creation: false, ignore_file_errors: false
-		@path = File.expand_path path
-		@ignore_file_errors = ignore_file_errors
-
-		base_data = {
-				data: {},
-				rbcli: {}
-		}
-
-		if File.exist? @path
-			load
-		elsif force_creation
-			create_file
-			@data = base_data
-			save
-		else
-			error "File #{@path} does not exist." unless @ignore_file_errors
-			@data = base_data
-		end
-	end
-
-	def []= key, value
-		@data[:data][key.to_sym] = value
-		save
-		@data[:data][key.to_sym]
-	end
-
-	def [] key
-		@data[:data][key.to_sym]
-	end
-
-	def delete key, &block
-		result = @data[:data].delete key.to_sym, block
-		save
-		result
-	end
-
-	def clear
-		@data[:data] = {}
-		save
-	end
-
-	def each &block
-		@data[:data].each &block
-		save
-	end
-
-	def key? key
-		@data[:data].key? key.to_sym
-	end
-
-	def to_h
-		@data[:data]
-	end
-
-	# For internal use
-
-	def rbclidata key = nil
-		return @data[:rbcli][key.to_sym] unless key.nil?
-		@data[:rbcli]
-	end
-
-	def set_rbclidata key, value
-		@data[:rbcli][key.to_sym] = value
-		save
-	end
-
-	private
-
-	def create_file
-		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." unless @ignore_file_errors
-		end
-	end
-
-	def load
-		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." unless @ignore_file_errors
-		end
-	end
-
-	def save
-		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." unless @ignore_file_errors
-		end
-	end
-
-	def error text
-		raise Rbcli::LocalStateError.new "Error accessing local state: #{text}"
-	end
-
-end
-
-class Rbcli::LocalStateError < StandardError; end