cloud_powers 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 345005638bc5e69081209792b8b9884ba2db2605
-  data.tar.gz: f5b69e0a4d366da8e6512b2ea6062c18bf17dc34
+  metadata.gz: 536b4abf5027aa70d284971a54fa2ec662cc8983
+  data.tar.gz: 8bd347c9a99d78f4dce7dec27b837dfa6bd21e22
 SHA512:
-  metadata.gz: 09ec8ecacab90dc97ea58cfe3b70c1359d3ed381076403edbca261265bc9eeee71d5e1ace2b5dea55401eb57d2c79c2ea258aef8242846c75ccd57d1eceb2542
-  data.tar.gz: e4c21cdb59a03d37fd45d4dba3cf8e3b5d6732a3deaa6351ef7c24220035f5cc42c2f78a81fec804abed81f8d211b3d6441caeecc6d26d021fb93479a2a0d8de
+  metadata.gz: 78dd9784282f4d316dce04003efb37cf579b3a52f9c2bd5187f92c6c3afde853cfdeb2038e079a489bf1fcd9fa360121c920ba74829575e0a31fddd02ff8dc9d
+  data.tar.gz: b59c25e12a62757894c46cc1fdf00be0a3b4ff79b06001f18cd9118af2eaeea4c961e2a646b57841d9007c45918ee91bfeecaaeb6d0b0f40dd3d57a9c00953f2

data/.test.env.example

@@ -25,4 +25,4 @@ FINISHED_QUEUE_ADDRESS=""
 
 
 # --THIS SHOULD ALWAYS BE THE LAST LINE-- < delete everything below this line for production
-TESTING="true"
+TEST="true"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cloud_powers (0.2.3)
+    cloud_powers (0.2.4)
       activesupport-core-ext (~> 4)
       aws-sdk (~> 2)
       dotenv (~> 2.1)

data/cloud_powers.gemspec

@@ -11,13 +11,14 @@ Gem::Specification.new do |spec|
   spec.email                  =       'adam.phillipps@gmail.com'
   spec.summary                =       %q{Cloud providers wrapper.  Currently only AWS is supported.}
   spec.description            =       <<-EOF
-    CloudPowers is a wrapper around AWS and other cloud services.
-    It was developed specifically for the Brain project
-    but hopefully can be used in any other ruby project that needs to use cloud
-    service providers' resources.  Version 0.2.3 has a little EC2, S3, SQS, SNS
-    and Kinesis.  V-0.2.4 should be out in a day or so and it will include IoT
-    basics and specs too.  This project is actively being developed, so more
-    additions, specs and docs will be updated frequently.  I always welcome input.
+    CloudPowers is a wrapper around AWS and in the future, other cloud service Providers.
+    It was developed specifically for the Brain project but hopefully can be used
+    in any other ruby project that needs to use cloud service providers' resources.
+    Version 0.2.3 has a little EC2, S3, SQS, SNS and Kinesis.  V 0.2.4 includes
+    a Context a Workflow revamp.  Websockets will be next.
+    This project is actively being developed, so more additions, specs and docs
+    will be updated frequently with new funcionality but the gem will follow good
+    practices for versioning.  I always welcome input.
     Enjoy!
   EOF
   spec.homepage               =       'https://github.com/adam-phillipps/cloud_powers'

data/lib/cloud_powers/context.rb

@@ -0,0 +1,235 @@
+require 'json'
+require_relative 'helper'
+
+module Smash
+  module CloudPowers
+    # The Context class is the class that handles serializing the Context so that it
+    # can be passed from node to node and rebuilt.  This provides a way for nodes in
+    # the same Brain to have an awareness of required communication modes, for example.
+    # Because resources generally require some sort of information to connect with
+    # or create and a Brain operates in the same Context, it can use the Context to
+    # decouple the creation and usage from the coordination.
+    class Context
+      include Smash::CloudPowers::Helper
+
+      attr_accessor :package # The given data structure that is used to build @structure
+      attr_reader :structure # A Hash that is used to represent the scheme of the Context
+
+      # Attempts to create a Context out of the argument(s) you've
+      # passed.
+      # === @params args <Hash|JSON|Array|enumerable list>
+      #   - exp Hash:
+      #     `{ task: 'demo', queue: [:backlog, :sned], pipe: :status_stream }`
+      #     each key is a module or class that is in CloudPowers and each value
+      #     is either an array of configurations information or a single configuration.
+      #   - exp Array
+      #     `[:task, 'demo', :queue, :backlog, :sned, :pipe, :status_stream]`
+      #     each key is followed by 0..n valid configurations information
+      # === @returns
+      #   `Smash::Context`
+      def initialize(args)
+        byebug unless valid_args?(args)
+        unless valid_args?(args)
+          raise ArgumentError.new 'Can be either a Hash, JSON, or an Enumerable ' +
+            "arguments: #{args}"
+        end
+        @package = args
+        @structure = decipher(args)
+      end
+
+      # # Decipher figures out which translation method to use by making some simple
+      # # type checks, etc. and then routing the args to the correct method.
+      def decipher(args)
+        case args
+        when Hash
+          args
+        when String
+          translate_json(args)
+        when Enumerable
+          translate_list(args)
+        end
+      end
+
+      # Creates a flat Array of the 2-D Array that gets returned from `#simplify()`
+      # === @returns <Array>
+      def flatten
+        simplify.flatten
+      end
+
+      # Create an array version of @sructure by calling `#to_a()` on it
+      # === @returns Array<Array..n>
+      # TODO: Check if this has a limit to n-layers
+      def simplify
+        @structure.to_a
+      end
+
+      #
+      def structure
+        symbolize_keys(@structure)
+      end
+
+      # Valid scheme for @structure is assured by running the arguments through
+      # the decipher method, which is how @structure is set in `#new(args)`
+      def structure=(args)
+        @structure = decipher(args)
+      end
+
+      # Parse the given JSON
+      # === @param: json_string <String::Json>
+      # === @returns <Hash>
+      def translate_json(json_string)
+        begin
+          JSON.parse(json_string)
+        rescue JSON::ParserError
+          raise ArgumentError "Incorrectly formatted JSON"
+        end
+      end
+
+      # Re-layer this flattened Array or enumerable list so that it looks like the
+      #  Hash that it used to be before the Smash::Context#flatten() method was called
+      #  === @param list
+      #    `<Array|List <Enumerable>`
+      #    e.g.
+      #      flat
+      #      ```
+      #      [
+      #        object_name_1, config_1a, config_2a, ...,
+      #        object_2, config_1b, etc,
+      #        ...
+      #      ]
+      #      ```
+      #      grouped
+      #      or
+      #      ```
+      #      [
+      #        [object_name_1, config_1a, config_2a, ...],
+      #        [object_2, config_1b, etc],
+      #        ...
+      #      ]
+      #      ```
+      #      structured
+      #      or
+      #      ```
+      #      [
+      #        [object_name_1, [config_1a, config_2a, ...]],
+      #        [object_2, [config_1b, etc]],
+      #        ...
+      #      ]
+      #      ```
+      #      returns
+      #      ```
+      #      {
+      #        object_1: [config_1a, config_2a, ...],
+      #        object_2: [config_1b, ...],
+      #        ...
+      #      }
+      #      ```
+      # === @returns Hash
+      #   If `#valid_package_hash?()` is called on this Hash, it will return true
+      def translate_list(list)
+        list.first.kind_of?(Enumerable) ? translate_simplified(list) : translate_flattened(list)
+      end
+
+      # Translates an Array into a valid @structure Hash
+      # === @param arr <Array>
+      #   e.g.
+      #   ```
+      #   [:task, 'demo', :queue, 'name1', {other config hash},...,:pipe, 'name1']
+      #   ```
+      # === @returns Hash
+      #   calling `#valid_hash_format?()` on returned Hash will return true
+      def translate_flattened(list)
+        arr = list.to_a
+        results = []
+        # get the indexes of CloudPowers resources in arr
+        key_locations = arr.each_with_index.collect do |key, i, _|
+          i if available_resources.include?(to_pascal(key).to_sym)
+        end.reject(&:nil?)
+        key_locations << arr.size # add the last index into the ranges
+        # use each pair as ranges to slice up the Array
+        key_locations.each_cons(2) do |current_i, next_i|
+          results << [arr[current_i], arr[(current_i+1)..(next_i-1)]]
+        end
+
+        translate_simplified(results)
+      end
+
+      # Translates a 2D Array into a valid @structure Hash
+      # === @param arr <Array>
+      #   e.g.
+      #   ```
+      #     [
+      #       [:task, 'demo'],
+      #       [:queue, 'name1', {other config hash},...],
+      #       [:pipe, 'name1']
+      #       ...
+      #     ]
+      #   ```
+      #   - Needs to be a 2D Array
+      #   - First object of each inner-Array is the key
+      #   - All following values in that inner Array are separate configuration
+      #     information pieces that can be used in the `#create!()` method for that particular resource
+      # === @returns Hash
+      #   well formatted for the @structure
+      def translate_simplified(arr)
+        arr.inject({}) do |hash, key_config_map|
+          hash.tap do |h|
+            key = key_config_map.shift
+            h[key.to_sym] = *key_config_map.flatten
+          end
+        end
+      end
+
+      # Uses `#to_json()` on the @structure
+      # === @returns Hash
+      def to_json
+        structure.to_json
+      end
+
+      # The Context class can be initialized in any of the formats that a Context
+      # class _should_ exist in.  It can be a vanilla version, where the @structure
+      # is a Hash, structured correctly or it can be serialized into JSON or it can
+      # be an Array
+      def valid_args?(args)
+        case args
+        when Hash
+          valid_hash_format?(args)
+        when String
+          valid_json_format?(args)
+        when Enumerable
+          valid_array_format?(args)
+        else
+          false
+        end
+      end
+
+      # Makes sure that the list is enumerable and that at least the first term
+      # is a resource name from Smash::CloudPowers.  All other objects can
+      # potentially be configurations.
+      # @param list <Array|Enumerable>
+      # @returns Boolean
+      def valid_array_format?(list)
+        use = list.first.kind_of?(Enumerable) ? list.first.first : list.first
+        ((list.kind_of? Enumerable) && (available_resources.include?(to_pascal(use).to_sym)))
+      end
+
+      # Makes sure that each key is the name of something CloudPowers can interact with
+      # @param hash <Hash>
+      # @returns Boolean
+      def valid_hash_format?(hash)
+        keys_arr = hash.keys.map { |key| to_pascal(key).to_sym }
+        (keys_arr - available_resources).empty?
+      end
+
+      # Parses the json_string which yields a Hash or an exception.  From there,
+      # use the #valid_hash_format?() method
+      def valid_json_format?(json_string)
+        begin
+          valid_hash_format?(JSON.parse(json_string))
+        rescue JSON::ParserError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cloud_powers/helper.rb

@@ -1,8 +1,8 @@
 require 'logger'
 require 'pathname'
+require 'uri'
 require 'syslog/logger'
 require_relative 'smash_error'
-require 'byebug'
 
 module Smash
   module CloudPowers
@@ -16,6 +16,13 @@ module Smash
         end
       end
 
+      # This is a way to find out if you are trying to work with a resource
+      # available to CloudPowers
+      # === @returns <Array>
+      def available_resources
+        [:Task].concat(Smash::CloudPowers.constants)
+      end
+
       def called_from
         File.expand_path(File.dirname($0))
       end
@@ -74,6 +81,10 @@ module Smash
         end
       end
 
+      def symbolize_keys(hash)
+        hash.inject({}) { |carry, (k, v)| carry.tap { |h| h[k.to_sym] = v } }
+      end
+
       # Gives the path from the project root to lib/tasks[/#{file}.rb]
       # @params:
       #   * [file] <String>: name of a file
@@ -158,6 +169,10 @@ module Smash
           false
         end
       end
+
+      def valid_url?(url)
+        url =~ /\A#{URI::regexp}\z/
+      end
     end
   end
 end

data/lib/cloud_powers/synapse/queue/queue.rb

@@ -8,6 +8,17 @@ module Smash
         include Smash::CloudPowers::Helper
         include Smash::CloudPowers::AwsResources
 
+        # A simpl Struct that acts as a Name to URL map
+        NUMap = Struct.new(:set_name, :set_url) do
+          def name
+            set_name || url.split('/').last # Queue names are last in the URL path
+          end
+
+          def url
+            set_url || Smash::CloudPowers::Queue::Board.new(name).best_guess_address
+          end
+        end
+
         # This method can be used to parse a queue name from its address.  It can be handy if you need the name
         # of a queue but you don't want the overhead of creating a Board object.
         def board_name(url)
@@ -15,29 +26,30 @@ module Smash
         end
 
         # This method allows you to create a queue on SQS without explicitly creating a Board object
-        # @params: name <String>: The name of the queue to be created
-        # @returns: Queue::Board
+        # === @params: name <String>: The name of the queue to be created
+        # === @returns: Queue::Board
         def create_queue!(name)
           begin
-            Board.create!(to_camel(name))
+            Smash::CloudPowers::Queue::Board.create!(to_camel(name))
           rescue Aws::SQS::Errors::QueueDeletedRecently => e
             sleep 5
             retry
           end
         end
 
-        # This method builds a Queue::Board object for you to use but doesn't invoke the #create! method, so
-        # no API call is made to create the queue on SQS.  This can be used if the board already exists.
-        # @params: name <String>: name of the queue you want to interact with
-        # @returns: Queue::Board
+        # This method builds a Queue::Board object for you to use but doesn't
+        # invoke the #create! method, so no API call is made to create the queue
+        # on SQS.  This can be used if the board already exists.
+        # === @params: name <String>: name of the queue you want to interact with
+        # === @returns: Queue::Board
         def build_queue(name)
-          Board.build(to_camel(name))
+          Smash::CloudPowers::Queue::Board.build(to_camel(name))
         end
 
         # Deletes a queue message without caring about reading/interacting with the message.
         # This is usually used for progress tracking, ie; a Neuron takes a message from the Backlog, moves it to
         # WIP and deletes it from Backlog.  Then repeats these steps for the remaining States in the Workflow
-        # @params: queue <String>[, opts <Hash>]
+        # === @params: queue <String>[, opts <Hash>]
         #   queue is the name of the queue to interact with
         #   opts is a configuration hash for the SQS::QueuePoller
         def delete_queue_message(queue, opts = {})
@@ -48,8 +60,8 @@ module Smash
         end
 
         # This method is used to gain the approximate count of messages in a given queue
-        # @params: board_url <String>: The URL for the board you need to get a count from
-        # @returns: float representation of the count
+        # === @params: board_url <String>: The URL for the board you need to get a count from
+        # === @returns: float representation of the count
         def get_queue_message_count(board_url)
           sqs.get_queue_attributes(
             queue_url: board_url,
@@ -57,8 +69,8 @@ module Smash
           ).attributes['ApproximateNumberOfMessages'].to_f
         end
 
-        # @params: board<String|symbol>: The name of the board
-        # @returns a message and deletes it from its origin
+        # === @params: board<String|symbol>: The name of the board
+        # === @returns a message and deletes it from its origin
         def pluck_queue_message(board)
           poll(board) do |msg, poller|
             poller.delete_message(msg)
@@ -68,11 +80,11 @@ module Smash
 
         # Polls the given board with the given options hash and a block that interacts with
         # the message that is retrieved from the queue
-        # @params: board <String>[, opts <Hash>]
+        # === @params: board <String>[, opts <Hash>]
         #   board is the name of the queue you want to poll
         #   opts can have any AWS::SQS polling option
         #   &block is the block that is used to interact with the message that was retrieved
-        # @returns the results from the `message` and the `block` that interacts with the message(s)
+        # === @returns the results from the `message` and the `block` that interacts with the message(s)
         def poll(board, opts = {})
           this_poller = queue_poller(board)
           results = nil
@@ -87,10 +99,10 @@ module Smash
         # This method can be used to gain a SQS::QueuePoller.  It creates a Board object,
         # the Board then sends the API call to SQS to create the queue and sets an instance
         # variable, using the board's name, to the Board object itself
-        # @params: board_name <String>: name of the Queue you want to gain a QueuePoller for
-        # @returns: @<board_name:Queue::Board>
+        # === @params: board_name <String>: name of the Queue you want to gain a QueuePoller for
+        # === @returns: @<board_name:Queue::Board>
         def queue_poller(board_name)
-          board = Board.create!(board_name)
+          board = Smash::CloudPowers::Queue::Board.create!(board_name)
 
           unless instance_variable_defined?(board.i_var)
             instance_variable_set(
@@ -107,15 +119,15 @@ module Smash
         end
 
         # Searches for a queue based on the name
-        # @params: name <String>
-        # @returns: queue_urls <Array>
+        # === @params: name <String>
+        # === @returns: queue_urls <Array>
         def queue_search(name)
           sqs.list_queues(queue_name_prefix: name).queue_urls
         end
 
         # Sends a given message to a given queue
-        # @params: address <String>: address of the queue you want to interact with
-        # @returns: queue_urls <Array<String>>
+        # === @params: address <String>: address of the queue you want to interact with
+        # === @returns: queue_urls <Array<String>> # TODO: verify this.  maybe it was late...
         def send_queue_message(address, message)
           sqs.send_message(
             queue_url: address,

data/lib/cloud_powers/version.rb

@@ -1,3 +1,3 @@
 module CloudPowers
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/lib/cloud_powers/workflow.rb

@@ -1,32 +1,34 @@
 module Smash
-  class Workflow
-    attr_accessor :all_states, :first, :last, :previous, :states
+  module CloudPowers
+    class Workflow
+      attr_accessor :all_states, :first, :last, :previous, :states
 
-    def initialize(statez = nil)
-      # TODO: figure out wtf here with the i-vars changing each other
-      @all_states = statez || [:backlog, :wip, :done]
-      @states = statez || [:backlog, :wip, :done]
-      @first = (statez || [:backlog, :wip, :done]).first
-      @last = (statez || [:backlog, :wip, :done]).last
-      @previous = [(statez || [:backlog, :wip, :done]).first]
-    end
+      def initialize(statez = nil)
+        # TODO: figure out wtf here with the i-vars changing each other
+        @all_states = statez || [:backlog, :wip, :done]
+        @states = statez || [:backlog, :wip, :done]
+        @first = (statez || [:backlog, :wip, :done]).first
+        @last = (statez || [:backlog, :wip, :done]).last
+        @previous = [(statez || [:backlog, :wip, :done]).first]
+      end
 
-    def current
-      @states.first
-    end
+      def current
+        @states.first
+      end
 
-    def finished?
-      @states.first == @states.last
-    end
+      def finished?
+        @states.first == @states.last
+      end
 
-    def next
-      finished ? @states.first : @states[1]
-    end
+      def next
+        finished ? @states.first : @states[1]
+      end
 
-    def next!
-      return if finished?
-      @previous << @states.shift
-      @states.first
+      def next!
+        return if finished?
+        @previous << @states.shift
+        @states.first
+      end
     end
   end
 end

data/lib/cloud_powers.rb

@@ -1,5 +1,6 @@
 require 'cloud_powers/auth'
 require 'cloud_powers/aws_resources'
+require 'cloud_powers/context'
 require 'cloud_powers/delegator'
 require 'cloud_powers/helper'
 require 'cloud_powers/self_awareness'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cloud_powers
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Adam Phillipps
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-30 00:00:00.000000000 Z
+date: 2016-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport-core-ext
@@ -151,13 +151,14 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 description: |2
-      CloudPowers is a wrapper around AWS and other cloud services.
-      It was developed specifically for the Brain project
-      but hopefully can be used in any other ruby project that needs to use cloud
-      service providers' resources.  Version 0.2.3 has a little EC2, S3, SQS, SNS
-      and Kinesis.  V-0.2.4 should be out in a day or so and it will include IoT
-      basics and specs too.  This project is actively being developed, so more
-      additions, specs and docs will be updated frequently.  I always welcome input.
+      CloudPowers is a wrapper around AWS and in the future, other cloud service Providers.
+      It was developed specifically for the Brain project but hopefully can be used
+      in any other ruby project that needs to use cloud service providers' resources.
+      Version 0.2.3 has a little EC2, S3, SQS, SNS and Kinesis.  V 0.2.4 includes
+      a Context a Workflow revamp.  Websockets will be next.
+      This project is actively being developed, so more additions, specs and docs
+      will be updated frequently with new funcionality but the gem will follow good
+      practices for versioning.  I always welcome input.
       Enjoy!
 email: adam.phillipps@gmail.com
 executables: []
@@ -181,6 +182,7 @@ files:
 - lib/cloud_powers/.DS_Store
 - lib/cloud_powers/auth.rb
 - lib/cloud_powers/aws_resources.rb
+- lib/cloud_powers/context.rb
 - lib/cloud_powers/delegator.rb
 - lib/cloud_powers/helper.rb
 - lib/cloud_powers/self_awareness.rb