awx 0.5.1 → 0.6.0

data/lib/core/replacer.rb

@@ -0,0 +1,282 @@
+module App
+
+    class Replacer
+
+        REGEXP_MATCHER   = /\$\{\{[^}]+\}\}/
+        REGEXP_MULTILINE = /^[A-Za-z0-9]+:\s*\|$/
+        REGEXP_MODIFIER  = /^\$\{\{awx-(for|end).*\}\}$/
+        TYPE_YML         = 'yml'
+        VALID_MODIFIERS  = %w(base64encode)
+        OP_SCAN          = 'scan'
+        OP_REPLACE       = 'replace'
+        SSH_USERS        = 'SSHUsers'
+
+        # Return Array of Hashes containing all matchers.
+        # Use this for validation.
+        # @return Array
+        def self.scan_string(line)
+            matchers            = {}
+            errors              = []
+            x, matchers, errors = process_matchers(line, matchers, errors, OP_SCAN) if line =~ REGEXP_MATCHER
+            return {
+                :matchers => matchers,
+                :errors   => errors
+            }
+        end
+
+        # Return Array of Hashes containing all matchers.
+        # Use this for validation.
+        # @return Hash
+        def self.scan_file(path_and_file, operation = OP_SCAN, data: nil, new_lines: nil)
+            raise RuntimeError, "File does not exist: #{path_and_file}" unless Blufin::Files::file_exists(path_and_file)
+            raise RuntimeError, "Cannot call scan_file without new_lines being an Array when operation is #{OP_REPLACE}." if operation == OP_REPLACE && !new_lines.is_a?(Array)
+            matchers   = {}
+            errors     = []
+            multiline  = nil
+            awx_for    = nil
+            line_count = 0
+            Blufin::Files::read_file(path_and_file).each do |line|
+                next if line =~ /^\s*#/ && line !~ /^\s*#cloud-config/ # Skip comments (but not #cloud-config).
+                line       = line.gsub("\n", '')
+                line_count += 1
+                # This handles multi-line block (IE -> content: | ) which basically gets skipped.
+                # If you want to make replace work within comments, you will need to write more code (or possibly just add a flag?).
+                if line.strip =~ REGEXP_MULTILINE
+                    # Stores the number of spaces from start.
+                    multiline = line[/\A */].size
+                    awx_for[:lines] << line if awx_for.is_a?(Hash)
+                    new_lines << line if operation == OP_REPLACE && awx_for.nil?
+                    next
+                elsif !multiline.nil?
+                    whitespace_from_start = line[/\A */].size
+                    # If white-space from beginning is same or higher, we're probably still in a multi-line.
+                    if line.strip == '' || whitespace_from_start > multiline
+                        awx_for[:lines] << line if awx_for.is_a?(Hash)
+                        new_lines << line if operation == OP_REPLACE && awx_for.nil?
+                        next
+                    end
+                    # Otherwise, break-out.
+                    multiline = nil
+                end
+                # This handles ${{awx-[modifier]}} tags.
+                if line.strip =~ REGEXP_MODIFIER
+                    awx_modifier = line.strip.gsub(/^\$\{\{awx-/, '').gsub(/\}\}$/, '')
+                    # Handle end-tag first.
+                    if awx_modifier == 'end'
+                        if awx_for.is_a?(Hash)
+                            if operation == OP_SCAN
+                                # Handle matchers.
+                                if awx_for[:matchers].any?
+                                    awx_for[:matchers].each do |k, v|
+                                        if k != awx_for[:item]
+                                            matchers[k] = [] unless matchers.has_key?(k)
+                                            matchers[k].push(*v)
+                                        end
+
+                                    end
+                                end
+                                # Handle errors.
+                                errors.push(*awx_for[:errors]) if awx_for[:errors].any?
+                            else
+                                ms = awx_for[:item_source].split(':')
+                                raise RuntimeError, "Invalid key: #{ms[0]}" unless data.has_key?(ms[0])
+                                raise RuntimeError, "Invalid key: #{ms[0]}.#{ms[1]}" unless data[ms[0]].has_key?(ms[1])
+                                is           = data[ms[0]][ms[1]]
+                                awx_for_data = data
+                                if is.is_a?(Array)
+                                    if ms[1] == SSH_USERS
+                                        # SSH Users get handled differently.
+                                        is.each do |ssh_key_file|
+                                            raise RuntimeError, "File not found: #{ssh_key_file}" unless Blufin::Files::file_exists(ssh_key_file)
+                                            contents = []
+                                            Blufin::Files::read_file(ssh_key_file).each do |c|
+                                                next if c.strip == ''
+                                                contents << c
+                                            end
+                                            awx_for_data[awx_for[:item]] = {
+                                                'name'    => Blufin::Files::extract_file_name(ssh_key_file).gsub(/\.pub$/i, '').gsub(/\./, '-'),
+                                                'pub_key' => contents.join("\n")
+                                            }
+                                            new_lines                    = process_awx_for_loop(awx_for, awx_for_data, new_lines)
+                                        end
+                                    else
+
+                                        # TODO - Finish this.
+                                        raise RuntimeError, 'Not yet implemented!'
+
+                                    end
+                                else
+
+                                    # TODO - Finish this.
+                                    raise RuntimeError, 'Not yet implemented!'
+
+                                end
+                            end
+                            awx_for = nil
+                        end
+                        next
+                    end
+                    # If a tag is already open, return an error (or throw one).
+                    unless awx_for.nil?
+                        tag_open_error = "Detected #{line.strip} tag even though another one is already open (Line: #{line_count})."
+                        if operation == OP_SCAN
+                            errors << tag_open_error
+                            next
+                        else
+                            raise RuntimeError, tag_open_error
+                        end
+                    end
+                    # Hits here at the start of a for loop (IE: ${{awx-for(user in Parameters:SSHUsers)}})
+                    if awx_modifier =~ /for\([A-Za-z0-9]+\s*in\s*[A-Za-z0-9]+:[A-Za-z0-9]+\)/
+                        ams                    = awx_modifier.strip.gsub(/^for\(/, '').gsub(/\)$/, '')
+                        ams                    = ams.split(' ')
+                        awx_for                = {
+                            :lines       => [],
+                            :item        => ams[0],
+                            :item_source => ams[2],
+                            :matchers    => {},
+                            :errors      => []
+                        }
+                        line, matchers, errors = process_matchers("${{#{ams[2]}}}", matchers, errors, OP_SCAN, data: data, file: path_and_file)
+                        next
+                    else
+                        raise RuntimeError, "Unsupported awx modifier: #{awx_modifier}"
+                    end
+                end
+                # If we're in a for loop, start buffering content.
+                if awx_for.is_a?(Hash)
+                    if operation == OP_SCAN
+                        line, awx_for[:matchers], awx_for[:errors] = process_matchers(line, awx_for[:matchers], awx_for[:errors], operation, data: data, file: path_and_file)
+                    end
+                    awx_for[:lines] << line
+                    next
+                end
+                # This just processes a regular line.
+                line, matchers, errors = process_matchers(line, matchers, errors, operation, data: data, file: path_and_file) if line =~ REGEXP_MATCHER
+                new_lines << line if operation == OP_REPLACE
+            end
+            if operation == OP_SCAN
+                return {
+                    :matchers => matchers,
+                    :errors   => errors
+                }
+            else
+                return new_lines
+            end
+        end
+
+        # Takes a string, replaces all the matchers and returns string.
+        # @return string
+        def self.replace_string(line, data)
+            return nil if line.nil?
+            raise RuntimeError, "Expected String, instead got #{line.class}" unless line.is_a?(String)
+            raise RuntimeError, "Expected Hash, instead got #{data.class}" unless data.is_a?(Hash)
+            line, x, y = process_matchers(line, {}, [], OP_REPLACE, data: data)
+            return line
+        end
+
+        # Takes file path and returns array of lines (that can then be used to write same/new file).
+        # @return Array (of file lines)
+        def self.replace_yml(path_and_file, data)
+            raise RuntimeError, "Expected String, instead got #{path_and_file.class}" unless path_and_file.is_a?(String)
+            raise RuntimeError, "Expected Hash, instead got #{data.class}" unless data.is_a?(Hash)
+            extension = Blufin::Files::extract_file_name(path_and_file).split('.')
+            extension = extension[extension.length - 1].downcase
+            raise RuntimeError, "Expected YML file, instead got: #{path_and_file}" unless %w(yml yaml).include?(extension)
+            new_lines = []
+            scan_file(path_and_file, OP_REPLACE, data: data, new_lines: new_lines)
+            new_lines
+        end
+
+        private
+
+        # Process matchers. Either replaces line or populates Hash.
+        # @return multiple
+        def self.process_matchers(line, matchers, errors, operation, data: nil, file: nil)
+            matches = line.scan(REGEXP_MATCHER)
+            matches.each do |match|
+                ms = match.gsub(/^\$\{\{/, '').gsub(/\}\}$/, '')
+                ms = ms.split(':')
+                if ms.length <= 1 || ms.length >= 4
+                    if operation == OP_SCAN
+                        errors << match
+                        next
+                    else
+                        raise RuntimeError, "Invalid matcher: #{match}"
+                    end
+                end
+                matchers[ms[0]] = [] unless matchers.has_key?(ms[0])
+                if operation == OP_SCAN
+                    matchers[ms[0]] << {:key => ms[1]} if ms.length == 2
+                    if ms.length == 3
+                        unless VALID_MODIFIERS.include?(ms[2])
+                            errors << match
+                            next
+                        end
+                        matchers[ms[0]] << {:key => ms[1], :modifier => ms[2]}
+                    end
+                else
+                    if ms[0] == 'file'
+                        raise RuntimeError, "Cannot process file: #{ms[1]} because containing file path was not passed. This is an unsupported edge-case." if file.nil?
+                        file_path    = "#{Blufin::Files::extract_path_name(file)}/#{ms[1]}"
+                        file_content = replace_yml(file_path, data)
+                        if ms.length == 3
+                            case ms[2]
+                                when 'base64encode'
+                                    tmp_file = "/tmp/base64encode-#{Blufin::Strings::random_string(4)}.txt"
+                                    Blufin::Terminal::execute_proc("Base64 Encoding raw file: \x1B[38;5;240m#{tmp_file}\x1B[0m", Proc.new {
+                                        Blufin::Files::write_file(tmp_file, file_content)
+                                        b64_cmd      = Blufin::Tools::value_based_on_os(mac: "openssl base64 -in #{tmp_file} | tr -d '\n'", linux: "base64 -w0 #{tmp_file}")
+                                        result       = Blufin::Terminal::command_capture(b64_cmd, nil, nil, nil)[0]
+                                        result       = result.split("\n").join('') # Removes line breaks, just in case :)
+                                        file_content = result
+                                    })
+                                else
+                                    raise RuntimeError, "Invalid modifier: #{ms[2]}"
+                            end
+                        end
+                        file_content = file_content.join('') if file_content.is_a?(Array)
+                        line         = line.gsub(/\$\{\{#{ms[0]}:#{ms[1]}\}\}/, file_content) if ms.length == 2
+                        line         = line.gsub(/\$\{\{#{ms[0]}:#{ms[1]}:#{ms[2]}\}\}/, file_content) if ms.length == 3
+                    elsif ms[0] == AppCommand::CloudFormationCreate::STACK
+                        stack = ms[1]
+                        Blufin::Terminal::error("Found: #{Blufin::Terminal::format_invalid("${{Stack:#{stack}}}")} on a line that does support this property.", ["Expected: #{Blufin::Terminal::format_highlight("TemplateURL: ${{Stack:#{stack}}}")}", "     Got: #{Blufin::Terminal::format_invalid(line.strip)}"], true) unless line =~ /TemplateURL:\s*\$\{\{Stack:#{stack.gsub('/', '\/')}\}\}/
+                        raise RuntimeError, "data is missing key: #{AppCommand::CloudFormationCreate::STACK}" unless data.has_key?(AppCommand::CloudFormationCreate::STACK)
+                        raise RuntimeError, "data[Stack] is missing key: #{stack}" unless data[AppCommand::CloudFormationCreate::STACK].has_key?(stack)
+                        line = line.gsub( /\$\{\{Stack:#{stack.gsub('/', '\/')}\}\}/, data[AppCommand::CloudFormationCreate::STACK][stack][:s3_url])
+                    else
+                        raise RuntimeError, "Invalid key: #{ms[0]}" unless data.has_key?(ms[0])
+                        raise RuntimeError, "Invalid key: #{ms[0]}.#{ms[1]}" unless data[ms[0]].has_key?(ms[1])
+                        line = line.gsub(/\$\{\{#{ms[0]}:#{ms[1]}\}\}/, data[ms[0]][ms[1]])
+                    end
+                end
+            end
+            return line, matchers, errors
+        end
+
+        # Processes the awx-for content.
+        # @return Array
+        def self.process_awx_for_loop(awx_for, awx_for_data, new_lines)
+            ml = nil
+            awx_for[:lines].each do |line|
+                if line.strip =~ REGEXP_MULTILINE
+                    ml = line[/\A */].size
+                    new_lines << line
+                    next
+                elsif !ml.nil?
+                    whitespace_from_start = line[/\A */].size
+                    if line.strip == '' || whitespace_from_start > ml
+                        new_lines << line
+                        next
+                    end
+                    ml = nil
+                end
+                line, x, y = process_matchers(line, {}, [], OP_REPLACE, data: awx_for_data)
+                new_lines << line
+            end
+            new_lines
+        end
+
+    end
+
+end