cts-mpx-aci 2.0.0

data/lib/cts/mpx/aci/tasks/deploy.rb

@@ -0,0 +1,117 @@
+module Cts
+  module Mpx
+    module Aci
+      module Tasks
+        # Responsible for deploying an image to an account.
+        # @!attribute [rw] user
+        #   @return [User] user to make data service calls with
+        # @!attribute [rw] account
+        #   @return [String] relative account or nil when untransformed
+        # @!attribute [rw] image
+        #   @return [Cts::Mpx::Aci::Tasks::Image]Image containing entries to deploy
+        class Deploy
+          include Creatable
+
+          attribute name: 'account', kind_of: String
+          attribute name: 'image', kind_of: Tasks::Image
+          attribute name: 'user', kind_of: User
+          attribute name: 'pre_block', kind_of: Proc
+          attribute name: 'post_block', kind_of: Proc
+
+          # Any dependencies the image may contain
+          # @return [Hash] dependency hash keyed by entry
+          def dependencies
+            hash = {}
+            image.entries.each do |e|
+              deps = e.dependencies
+              hash.store e.id, deps if deps.any?
+            end
+            hash
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # reason: these classes is as thin as it can get.  not splitting it up to satisify rubocop.
+          # deploy a transformed image to an account
+          # @param [String] target_account to deploy to
+          # @raise [RuntimeError] when image is not deployable
+          def deploy(target_account, *args)
+            raise "not a deployable image" unless Validators.image_deployable? image
+            raise "not a deployable image" unless deploy_order
+
+            deploy_order.each do |ref|
+              entry = image.entries.find { |e| e.id == ref }
+              entry = block_update_entry entry, *args, &pre_block if pre_block
+
+              query = Query.create service: entry.service, endpoint: entry.endpoint, fields: 'id,guid'
+              query.query['byOwnerId'] = target_account
+
+              if entry.id.include? 'Field/'
+                query.query['byQualifiedFieldName'] = "#{entry.fields['namespace']}$#{entry.fields['fieldName']}"
+              else
+                query.query['byGuid'] = entry.fields['guid']
+              end
+
+              if entry.exists_by? user, query
+                method = 'PUT'
+                response = query.run(user: user)
+                entry.id = response.page.entries.first["id"]
+              else
+                entry.id = nil
+                entry.service = query.service
+                entry.endpoint = query.endpoint
+                method = 'POST'
+              end
+
+              entry.fields['ownerId'] = target_account
+              entry.save user: user
+              block_update_entry entry, *args, &post_block if post_block
+
+              logger.info "deployed #{entry.fields['guid']} to #{target_account} as #{entry.id || 'new_id'} with #{user.username} via a #{method} call"
+            end
+
+            true
+          end
+
+          # @return [Array] order to deploy objects in
+          # @return [nil] if image state is transformed.
+          # @return [nil] if a deploy order could not be generated.
+          def deploy_order
+            return nil unless image.state == :untransformed
+
+            hash = dependencies
+            list = image.entries.map(&:id) - dependencies.keys
+
+            100.times do |_i|
+              break unless hash.any?
+
+              hash.delete_if { |k, _v| list.include? k }
+
+              new_hash = hash.select { |_k, v| (v - list).empty? }
+              list += new_hash.keys if new_hash.any?
+            end
+
+            return list.uniq if image.entries.map(&:id).count == list.count
+
+            nil
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def block_update_entry(entry, *args, &block)
+            raise ArgumentError, 'block must be provided' unless block
+            raise ArgumentError, 'argument must be an entry' unless entry.is_a? Entry
+
+            e = entry.dup
+            block.yield e, args
+            e
+          end
+
+          private
+
+          def logger
+            Aci.logger
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/aci/tasks/image.rb

@@ -0,0 +1,161 @@
+module Cts
+  module Mpx
+    module Aci
+      module Tasks
+        # Image class for gathering a set of service data as a single collection.
+        #
+        # @!attribute [rw] entries
+        #   @return [Hash] set of entries to generate the image from
+        # @!attribute [rw] schema
+        #   @return [String] schema of the image
+        # @!attribute [rw] user
+        #   @return [User] user to make data service calls with
+        # @!attribute [r] account_id
+        #   @return [String] relative account_id or nil when untransformed
+        # @!attribute [r] date_taken
+        #   @return [DateTime] Date the image was instantiated
+        # @!attribute [r] state
+        #   @return [String] :transformed or :untransformed
+        class Image
+          include Creatable
+
+          attribute  name: 'entries', kind_of: Entries
+          attribute  name: 'schema', kind_of: Integer
+          attribute  name: 'user', kind_of: User
+          attribute  name: 'account_id', kind_of: String
+          attribute  name: 'date_taken', kind_of: Time
+          attribute  name: 'state', kind_of: String
+
+          # load an image from directory
+          #
+          # @param  user [String] user to set the image and entries to
+          # @return [Cts::Mpx::aciTasks::Image] image with entries loaded and info set.
+          def self.load_from_directory(directory, user = nil)
+            i = new
+            i.load_from_directory directory, user
+            i
+          end
+
+          # All entries in the entries, including the md5 hash of the data.
+          #
+          # @return [Hash] filepath is key, value is md5
+          def files
+            entries.map(&:filepath)
+          end
+
+          # Generate information report for the image.
+          #
+          # @return [Hash] contains the information about the image.
+          def info
+            {
+              account_id: @account_id,
+              date_taken: @date_taken.iso8601,
+              username:   @user.nil? ? "" : @user.username,
+              schema:     @schema,
+              state:      @state,
+              files:      files
+            }
+          end
+
+          def initialize
+            @account_id = ""
+            @entries = Entries.new
+            @date_taken = Time.now
+            @files = {}
+            @state = :untransformed
+            @schema = 1
+            @user = nil
+          end
+
+          # save an image to a directory
+          #
+          # @param directory [String] the name of the directory to save to
+          def save_to_directory(directory)
+            entries.each do |entry|
+              FileUtils.mkdir_p "#{directory}/#{entry.directory}"
+              File.write "#{directory}/#{entry.filepath}", entry.to_s
+            end
+
+            File.write "#{directory}/info.json", Oj.dump(info, indent: 2)
+            true
+          end
+
+          # load an image from directory
+          #
+          # @param  user [String] user to set the image and entries to
+          # @return [Cts::Mpx::Aci::Tasks::Image] image with entries loaded and info set.
+          def load_from_directory(directory, user = nil)
+            raise "#{directory} does not contain a valid image." unless Validators.image_directory? directory
+
+            info = load_json_or_error "#{directory}/info.json"
+
+            ["date_taken", "account_id", "schema", "username", "state"].each do |param|
+              instance_variable_set "@#{param}", info[param]
+            end
+
+            entries = Entries.new
+
+            info["files"].each do |file|
+              begin
+                h = load_json_or_error("#{directory}/#{file}")
+              rescue Oj::ParseError
+                raise "#{directory}/#{file} is readable, but not parsable.   Please run the json through a linter."
+              end
+
+              entries.add Entry.create(fields: Fields.create_from_data(data: h[:entry], xmlns: h[:xmlns]))
+            end
+
+            @user = user
+
+            true
+          end
+
+          # merge two images together
+          #
+          # @param other_image [Image] Image to merge from
+          # @return [Cts::Mpx::Aci::Tasks::Image] new image containg merged results.
+          def merge(other_image)
+            raise 'an image class must be supplied' unless other_image.is_a? Image
+            raise 'cannot merge if the user is different' unless other_image.user == user
+            raise 'cannot merge if the account_id is different' unless other_image.account_id == account_id
+            raise 'cannot merge if the state is different' unless other_image.state == state
+
+            new_image = Image.new
+            new_image.user = @user
+            new_image.entries = entries + other_image.entries
+            new_image
+          end
+
+          # transform an image to an abstract state
+          def transform
+            entries.each { |entry| entry.transform user }
+            @state = :transformed
+            @account_id = nil
+            true
+          end
+
+          # untransform an image from an abstract state
+          # @param target_account [String] account_id to transform to
+          def untransform(target_account)
+            entries.each do |entry|
+              entry.fields['ownerId'] = target_account
+              entry.untransform user, target_account
+            end
+
+            @state = :untransformed
+            @account_id = target_account
+            true
+          end
+
+          private
+
+          def load_json_or_error(file)
+            Oj.load File.read file
+          rescue Oj::ParseError => exception
+            raise "#{exception.message.split(' [').first}: #{file}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/aci/transformations.rb

@@ -0,0 +1,144 @@
+module Cts
+  module Mpx
+    module Aci
+      # contains the logic to transform/untransform an entry.
+      module Transformations
+        module_function
+
+        # Transform a reference into a transformed_reference
+        # @param [User] user that will make the service calls.
+        # @param [String] original_account to do the transformation from
+        # @param [String] reference to transform to a transformed reference
+        # @return [String] transformed_reference
+        def transform_reference(reference: nil, user: nil, original_account: nil)
+          return "urn:cts:aci:target-account" if reference == original_account
+          return reference unless Validators.reference? reference
+
+          service_info = Services.from_url reference
+          endpoint = service_info[:endpoint]
+          service = service_info[:service]
+          return reference if service.start_with? "User Data Service"
+
+          response = Services::Data.get user: user, service: service, endpoint: endpoint, ids: reference.split('/').last
+
+          return "urn:cts:aci:no-id-found" unless (entry = response.data["entries"].first)
+
+          return "urn:cts:aci:no-guid-found" unless (guid = entry["guid"])
+
+          "urn:cts:aci:#{URI.encode_www_form_component(service)}:#{endpoint}:#{entry['ownerId'].split('/').last}:#{guid}"
+        end
+
+        # Transform a field reference into a transformed_field_reference
+        # @param [User] user that will make the service calls.
+        # @param [String] field_reference to transform to a transformed field reference
+        # @return [String] transformed_field_reference
+        def transform_field_reference(field_reference: nil, user: nil)
+          return field_reference unless Validators.field_reference? field_reference
+
+          service_info = Services.from_url field_reference
+          endpoint = service_info[:endpoint]
+          service = service_info[:service]
+          response = Services::Data.get user: user, service: service, endpoint: endpoint, ids: field_reference.split('/').last, fields: 'ownerId,fieldName,namespace'
+          return "urn:cts:aci:no-id-found" unless (entry = response.data["entries"].first)
+          return "urn:cts:aci:no-qualified-field-name-found" unless entry["fieldName"]
+
+          namespace = response.data['namespace']
+          owner_id = entry['ownerId'].split('/').last
+          "urn:cts:aci:#{URI.encode_www_form_component(service)}:#{endpoint}:#{owner_id}:#{namespace}$#{entry['fieldName']}"
+        end
+
+        # Untransform a transformed_reference into a reference
+        # @param [User] user that will make the service calls.
+        # @param [String] target_account to do the transformation from
+        # @param [String] transformed_reference to transform to a reference
+        # @return [String] reference
+        def untransform_reference(transformed_reference: nil, user: nil, target_account: nil)
+          return target_account if transformed_reference == "urn:cts:aci:target-account"
+          return transformed_reference unless Validators.transformed_reference? transformed_reference
+
+          parts = transformed_reference.split ':'
+          endpoint = parts[4]
+          service = parts[3]
+          guid = URI.decode_www_form_component(parts[6])
+          owner_id = "http://access.auth.theplatform.com/data/Account/#{parts[5]}"
+
+          response = Services::Data.get user:     user,
+                                        service:  service,
+                                        endpoint: endpoint,
+                                        ids:      transformed_reference.split('/').last,
+                                        query:    { byGuid: guid, ownerId: owner_id }
+
+          raise "could not find an entry by guid" unless (entry = response.data["entries"].first)
+          raise "service returned too many entries on guid" if response.data["entries"].count > 1
+
+          entry['id']
+        end
+
+        # Untransform a transformed_field_reference into a field reference
+        # @param [User] user that will make the service calls.
+        # @param [String] transformed_field_reference to transform to a reference
+        # @return [String] field_reference
+        def untransform_field_reference(transformed_field_reference: nil, user: nil, target_account: nil)
+          return transformed_field_reference unless Validators.transformed_field_reference? transformed_field_reference
+
+          parts = transformed_field_reference.split ':'
+          endpoint = parts[4]
+          service = parts[3]
+          qualified_field_name = URI.decode_www_form_component(parts[6])
+          owner_id = "http://access.auth.theplatform.com/data/Account/#{parts[5]}"
+
+          response = Services::Data.get user:     user,
+                                        service:  service,
+                                        endpoint: endpoint,
+                                        query:    { byQualifiedFieldName: qualified_field_name, ownerId: owner_id }
+
+          raise "could not find an entry by qualified field name" unless (entry = response.data["entries"].first)
+          raise "service returned too many entries on qualified field name" if response.data["entries"].count > 1
+
+          entry['id']
+        end
+
+        def traverse_for(hash, direction, &block)
+          id = hash['id']
+          output = hash.reject { |k, _v| k == 'id' }
+          output = Transformations.send :traverse_hash, Oj.load(Oj.dump(output)), direction, &block
+          { "id" => id }.merge(output)
+        end
+
+        # private module method, not explicitly covered
+        def traverse_hash(entry, direction, &block)
+          entry.each do |field, value|
+            case value
+            when String
+              entry[field] = block.yield field, value if direction == :transform &&
+                                                         Validators.reference?(value)
+              entry[field] = block.yield field, value if direction == :untransform &&
+                                                         Validators.transformed_reference?(value)
+            when Array
+              entry[field] = traverse_array field, value, direction, &block
+            when Hash
+              entry[field] = traverse_hash value, direction, &block
+            end
+          end
+        end
+
+        # private module method, not explicitly covered
+        def traverse_array(field, value, direction, &block)
+          if value.map(&:class).uniq.first == String
+            value.map do |v|
+              if Validators.reference?(v) || Validators.transformed_reference?(v)
+                block.yield field, v
+              else
+                v
+              end
+            end
+          elsif value.map(&:class).uniq.first == Hash
+            value.map { |v| traverse_hash v, direction, &block }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/aci/validators.rb

@@ -0,0 +1,114 @@
+module Cts
+  module Mpx
+    module Aci
+      # Wireline Validators
+      module Validators
+        module_function
+
+        # Test if a string is a reference or not
+        # @param [String] uri to test if it is a reference or not
+        # @return [Boolean]
+        def reference?(uri)
+          Cts::Mpx::Validators.reference?(uri)
+        end
+
+        def field_reference?(uri)
+          begin
+            ref = URI.parse uri
+          rescue URI::InvalidURIError
+            return false
+          end
+
+          return false if ref.host == 'web.theplatform.com'
+          return false unless ref.scheme == "http" || ref.scheme == "https"
+          return false unless ref.host.end_with? ".theplatform.com"
+          return false unless ref.path =~ /Field\/\d+/
+          return false if ref.path =~ /\/\D+$/
+
+          true
+        end
+
+        # Test if a string is a transformed_reference or not
+        # @param [String] string to check if it is a transformed_reference
+        # @return [Boolean]
+        def transformed_reference?(string)
+          return true if [
+            'urn:cts:aci:target-account',
+            'urn:cts:aci:no-id-found',
+            'urn:cts:aci:no-guid-found',
+            'urn:cts:aci:no-custom-field-found'
+          ].include? string
+
+          urn_regex = /^(?i:urn:(?!urn:)([cC][tT][sS]):(?<nss>(?:[a-z0-9()\/+,-.:=@;$_!*']|%[0-9a-f]{2})+))$/
+
+          return false unless urn_regex =~ string
+
+          nss = urn_regex.match(string)["nss"]
+          segments = nss.split(":")
+
+          return false unless /^([aA][cC][iI])$/ =~ segments[0]
+
+          begin
+            service = Services[URI.decode_www_form_component(segments[1])]
+          rescue RuntimeError
+            return false
+          end
+
+          return false unless service.endpoints.include? segments[2].gsub('Field', '/Field')
+          return false unless /\A\d+\z/ =~ segments[3]
+
+          true
+        end
+
+        # Test if a string is a transformed_field_reference or not
+        # @param [String] string to check if it is a transformed_field_reference
+        # @return [Boolean]
+        def transformed_field_reference?(string)
+          return false unless transformed_reference? string
+          return false unless /Field:\d*:.*$/.match? string
+
+          true
+        end
+
+        # test if a directory is an image_directory
+        # @param [String] image_directory to check if it is a transformed_reference
+        # @return [Boolean]
+        def image_directory?(image_directory)
+          return false unless File.exist? "#{image_directory}/info.json"
+
+          true
+        end
+
+        # test if a image will depoly
+        # @param [Tasks::Image] image to check if it is a transformed_reference
+        # @return [Boolean]
+        def image_deployable?(image)
+          return false if image.state == :transformed || image.state == 'transformed'
+          return false if image.entries.collection.empty?
+
+          image.entries.each do |entry|
+            Transformations.traverse_for(entry.to_h, :untransform) do |_k, v|
+              return false if v =~ /^urn:cts:aci:no-(gu)?id-found$/
+            end
+          end
+          true
+        end
+
+        # Test if a string is a transformed_reference or not
+        # @param [String] filename to check if it is a valid info.json or not
+        # @return [Boolean]
+        def info_file?(filename)
+          raise "could not find an info.json" unless File.exist? filename
+
+          begin
+            Oj.load(File.read(filename))
+          rescue Oj::ParseError
+            return false
+          end
+
+          true
+        end
+      end
+    end
+  end
+end