cloud_powers 0.2.7.23 → 1.0.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloud_powers
 version: !ruby/object:Gem::Version
-  version: 0.2.7.23
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam Phillipps
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-03 00:00:00.000000000 Z
+date: 2016-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport-core-ext
@@ -199,16 +199,16 @@ description: |2
       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.8 has a some EC2, S3, SQS, SNS, Kinesis, websockets and a few other
+      Version 1.0 has a some EC2, S3, SQS, SNS, Kinesis, websockets and a few other
       features you can find in the docs.  There is also limitted support for stubbing
       AWS RESTful API calls.  That can come in handy for local testing and extra setup on
       AWS resource clients.
 
-      The next versions will have more Kinesis, Workflow integration and IoT.
-
       This project is actively being developed, so more additions, specs and docs
       will be added and updated frequently with new funcionality but the gem will
-      follow good practices for versioning.  Input is always welcome.
+      follow good practices for versioning and so the behavior won't change on
+      existing features.
+      Input is always welcome. :thumbsup:
       Enjoy!
 email:
 - adam.phillipps@gmail.com
@@ -225,6 +225,7 @@ files:
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
+- README
 - README.md
 - README.rdoc.mdown
 - Rakefile
@@ -234,24 +235,34 @@ files:
 - lib/cloud_powers.rb
 - 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/creatable.rb
+- lib/cloud_powers/helpers.rb
+- lib/cloud_powers/helpers/lang_help.rb
+- lib/cloud_powers/helpers/logic_help.rb
+- lib/cloud_powers/helpers/path_help.rb
 - lib/cloud_powers/node.rb
+- lib/cloud_powers/node/instance.rb
+- lib/cloud_powers/resource.rb
 - lib/cloud_powers/self_awareness.rb
 - lib/cloud_powers/smash_error.rb
 - lib/cloud_powers/storage.rb
+- lib/cloud_powers/stubs/aws_stubs.rb
+- lib/cloud_powers/synapse/broadcast.rb
 - lib/cloud_powers/synapse/broadcast/broadcast.rb
+- lib/cloud_powers/synapse/broadcast/channel.rb
+- lib/cloud_powers/synapse/pipe.rb
 - lib/cloud_powers/synapse/pipe/pipe.rb
+- lib/cloud_powers/synapse/pipe/stream.rb
+- lib/cloud_powers/synapse/queue.rb
 - lib/cloud_powers/synapse/queue/board.rb
+- lib/cloud_powers/synapse/queue/poller.rb
 - lib/cloud_powers/synapse/queue/queue.rb
 - lib/cloud_powers/synapse/synapse.rb
-- lib/cloud_powers/synapse/websocket/websocclient.rb
-- lib/cloud_powers/synapse/websocket/websocserver.rb
+- lib/cloud_powers/synapse/web_soc.rb
+- lib/cloud_powers/synapse/web_soc/soc_client.rb
+- lib/cloud_powers/synapse/web_soc/soc_server.rb
 - lib/cloud_powers/version.rb
-- lib/cloud_powers/workflow_factory.rb
 - lib/cloud_powers/zenv.rb
-- lib/stubs/aws_stubs.rb
 homepage: https://github.com/adam-phillipps/cloud_powers
 licenses:
 - MIT

data/lib/cloud_powers/context.rb

@@ -1,275 +0,0 @@
-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
-
-      # Attempts to create a Context out of the argument(s) you've
-      # passed.
-      #
-      # Parameters
-      # * args +Hash+|+JSON+|+Array+|+Enumerable+
-      # * * expample +Hash+:
-      # * * * 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.
-      #         { task: 'demo', queue: [:backlog, :sned], pipe: :status_stream }
-      # * * expample Array
-      # * * * each key is followed by 0..n valid configurations information
-      #         [:task, 'demo', :queue, :backlog, :sned, :pipe, :status_stream]
-      #
-      # Returns
-      # +Smash::Context+
-      def initialize(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.
-      #
-      # Notes
-      # * See +#translate_json()+
-      # * See +#translate_list()+
-      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+
-      #
-      # Example
-      #   example_context.structure
-      #   # => { task: 'demo', queue: [:backlog, :sned], pipe: [:status_stream] }
-      #   example.flatten
-      #   # => [:task, 'demo', :queue, :backlog, :sned, :pipe, :status_stream]
-      #
-      # Notes
-      # * See +#simplify()
-      # * See +#Array::flatten()+
-      def flatten
-        simplify.flatten
-      end
-
-      # Create an array version of @sructure by calling `#to_a()` on it
-      #
-      # Returns
-      # <tt>Array[Array..n]</tt>
-      #
-      # Example
-      #   example_context.structure
-      #   # => { task: 'demo', queue: [:backlog, :sned], pipe: [:status_stream] }
-      #   example.simplify
-      #   # => [:task, 'demo', :queue, [:backlog, :sned], :pipe, [:status_stream]]
-      #
-      # Notes
-      # * This uses the different Constants, like Smash, Synapse and anything it can find
-      #   to decide what should be used as a key and what its following values array should
-      #   contain.  It basically says:
-      #   1. if the nth item is a known key (from the above search), add it as an object in the Array.
-      #   2. else, add it to the last sub-Array
-      #   3. move to n+1 in the +structure Hash+
-      # * TODO: Check if this has a limit to n-layers
-      def simplify
-        @structure.to_a
-      end
-
-      # A Hash that represents the resources and some configuration for them
-      #
-      # Returns +Hash+
-      def structure
-        modify_keys_with(@structure) { |key| key.to_sym }
-      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
-      # Parameters
-      # +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
-      #
-      # Parameters
-      # +Array+|+List+|+Enumerable+
-      #
-      # Example
-      # * flat
-      #
-      #     [
-      #       object_name_1, config_1a, config_2a, ...,
-      #       object_2, config_1b, etc,
-      #       ...
-      #     ]
-      #
-      # * or grouped
-      #
-      #     [
-      #       [object_name_1, config_1a, config_2a, ...],
-      #       [object_2, config_1b, etc],
-      #       ...
-      #     ]
-      #
-      # * or structured
-      #
-      #     [
-      #       [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+
-      #
-      # Notes
-      # 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
-      # Parameters arr <Array>
-      # e.g.
-      #   [:task, ['demo'], :queue, ['name1','name2',.,.,.,.,.], {other config hash},..., :pipe, ['name1']
-      # Returns
-      # +Hash+
-      # Notes
-      # * 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
-      # Parameters 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
-      # Parameters args String
-      # Returns Boolean
-      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.
-      # Parameters 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
-      # Parameters 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/delegator.rb

@@ -1,113 +0,0 @@
-# require 'auth'
-# require 'aws_resources'
-require 'json'
-require_relative 'helper'
-require_relative 'storage'
-
-module Smash
-  module CloudPowers
-    # The Delegator module is a way to dynamically source and use
-    # Ruby source code.  You pass a message or something that can
-    # respond to +#body()+ and give back a String.  The String should
-    # be the name of the class you're trying to instantiate and use
-    module Delegator
-      extend Smash::CloudPowers::Auth
-      include Smash::CloudPowers::AwsResources
-      include Smash::CloudPowers::Helper
-      include Smash::CloudPowers::Storage
-
-      # Predicate method to return true for valid job titles and false for invalid ones
-      #
-      # Parameters
-      # * name +String+ (optional) - name of the task in snake_case
-      #
-      # Returns
-      # +Boolean+
-      #
-      # Notes
-      # * TODO: needs improvement
-      def approved_task?(name = nil)
-        ['demo', 'testinz', 'true_roas'].include? to_snake(name)
-      end
-
-      # responsible for sourcing, loading into the global namespace
-      # and use of Ruby source code, through the +#new()+ method on
-      # that class
-      #
-      # Parameters
-      # * id +String+ - the instance id of the calling node.  This gets
-      #   used in communication tools etc.
-      # * msg - Anything that responds to +#body()+ and returns a String
-      #   that can be used in the search for the file in your local and S3
-      #   bucket locations
-      #
-      # Returns
-      # +Object+ - a newly instantiated object of the class that matches
-      # the name retrieved from the +msg+ parameter
-      #
-      # Example
-      #   class Job; include Smash::CloudPowers::Delegator; end
-      #   job = Job.new
-      #   # the message responds to +#body()+ with "ExampleTask"
-      #   job.build('abc-1234', Aws::SQS::Message)
-      #   # => +ExampleTask:Object+
-      def build(id, msg)
-        body = decipher_message(msg)
-        begin
-          task = body['task']
-          if approved_task? task
-            source_task(task)
-            require_relative task_require_path(task)
-            Smash.const_get(to_pascal(task)).public_send :create, id, body
-          else
-            Smash::Task.new(id, body) # returns a default Task
-          end
-        rescue JSON::ParserError
-          message = [msg.body, format_error_message(e)].join("\n")
-          logger.info "Message in backlog is ill-formatted: #{message}"
-          pipe_to(:status_stream) { sitrep(extraInfo: { message: message }) }
-        end
-      end
-
-      # Get the body of the message out from a few different types of objects.
-      # The idea is to allow JSON, a String or some object that responds to :body
-      # through while continually attempting to decipher other types of objects
-      # finally giving up.  But wait, after it gives up, it just turns it into a
-      # Hash and assumes that the value is a Task name.
-      #
-      # Parameters
-      # * msg +String+
-      #
-      # Returns
-      # +Hash+
-      #
-      # Example
-      #   # given hash_message = { task: 'example' }
-      #   # givem json_message = "\{"task":"example"\}"
-      #   # given message_with_body = <Object @body="stuff stuff stuff">
-      #
-      #   decipher_message(hash_message)
-      #   # => { task: 'example' }
-      #   decipher_message(json_message)
-      #   # => { task: 'example' }
-      #   decipher_message(message_with_body)
-      #   # => { task: 'example' }
-      #   decipher_message('some ridiculous string')
-      #   # => { task: 'some_ridiculous_string'}
-      #
-      # Notes
-      # See +#to_snake()+
-      def decipher_message(msg)
-        begin
-          if msg.respond_to? :body
-            decipher_message(msg.body)
-          else
-            msg.kind_of?(Hash) ? msg : JSON.parse(msg)
-          end
-        rescue Exception
-          { task: to_snake(msg.to_s) }
-        end
-      end
-    end
-  end
-end