blufin-lib 1.7.6 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8895eedbca233a947357cfc7ee7ca2fcea304563
-  data.tar.gz: 95f7c83226ab47eadea54c08af12a892287b9acc
+  metadata.gz: 951694bcd607959a657e046002654767755b74d6
+  data.tar.gz: def507a9855268d197362bad03e915720ef2c26f
 SHA512:
-  metadata.gz: 49103398cdf8a6469fa599302dcc0c00568ca6014a6f7a7a15c13b9cd8d7768a149ae84626d6399ba51a596294d3077f75ed358cc3476c86059570ac135de255
-  data.tar.gz: 302868314496ef6b238cae5da06b0516d5d3189629b8ce34071261597b05716f0b06374a3f57b39a4d252a78412d810c40e8ed9c8b4bb8aca809d78e129217ac
+  metadata.gz: 0bedc142caf1e81f3aa0dcff437217451f8db5560f6d4ef4f58e3fa6540148ad913e781f28873a20a647e21877c21b0d0397a5877576a1f489d554a82ba6ca54
+  data.tar.gz: 6326f21a88d05ce9abf5296e14d5ccd1cf55a9cd57efd9a43628afd82b1afe095fb4ce9562f2f14618ca3562ff4df1f8989036b178fc9d1a2d95a746494cdf6e

data/lib/blufin-lib.rb

@@ -6,6 +6,9 @@ module Blufin
     autoload :Config, 'core/config'
     autoload :DateTimeUtils, 'core/datetime_utils'
     autoload :Files, 'core/files'
+    autoload :GenerateBase, 'generate/generate_base'
+    autoload :GenerateUiRoutes, 'generate/generate_ui_routes'
+    autoload :Git, 'core/git'
     autoload :Image, 'core/image'
     autoload :Network, 'core/network'
     autoload :Numbers, 'core/numbers'
@@ -14,7 +17,9 @@ module Blufin
     autoload :Strings, 'core/strings'
     autoload :Terminal, 'core/terminal'
     autoload :Tools, 'core/tools'
+    autoload :Update, 'core/update'
     autoload :Validate, 'core/validate'
     autoload :Versioning, 'core/versioning'
+    autoload :Yml, 'core/yml'
 
 end

data/lib/core/arrays.rb

@@ -13,6 +13,27 @@ module Blufin
             !(array.uniq.length == array.length)
         end
 
+        # Converts an Array of lines to a string (for easier gsub replacement).
+        # @return String
+        def self.convert_line_array_to_string(array_of_lines)
+            raise RuntimeError, "Expected Array of lines, instead got: #{array_of_lines.class}" unless array_of_lines.is_a?(Array)
+            string = ''
+            array_of_lines.each_with_index do |line, idx|
+                newline_or_not = (idx == (array_of_lines.length - 1)) ? '' : "\n"
+                string         += "#{line}#{newline_or_not}"
+            end
+            string
+        end
+
+        # Converts a string to an Array of lines to a string.
+        # @return String
+        def self.convert_string_to_line_array(string)
+            raise RuntimeError, "Expected String, instead got: #{string.class}" unless string.is_a?(String)
+            array_of_lines = []
+            string.split("\n").each { |line| array_of_lines << line.gsub("\n", '') }
+            array_of_lines
+        end
+
     end
 
 end

data/lib/core/aws.rb

@@ -4,6 +4,15 @@ module Blufin
 
         S3_EXCLUDE = "--exclude '.DS_Store' --exclude '*/.DS_Store' --exclude '*.icloud' --exclude '*/*.icloud'"
 
+        # Checks if script is running on an EC2 instance.
+        # Not sure if this is 100% reliable, but it's about as good as it gets I think.
+        # @return bool
+        def self.is_ec2
+            res = `#{Blufin::Base::get_base_path}#{Blufin::Base::OPT_PATH}/shell/ec2-check`.to_s
+            res = Blufin::Strings::strip_newline(res)
+            res.downcase.strip == 'yes'
+        end
+
         # Uploads a file (or path) to S3. If path, will upload recursively (which is mandatory with s3 sync command).
         # @return string (S3 URL).
         def self.upload_s3_data(bucket_name, bucket_path, file_or_path, profile: nil, region: nil, is_file: false, dryrun: false)
@@ -25,7 +34,7 @@ module Blufin
                     Blufin::Terminal::info('Performing Dry Run:', Blufin::Terminal::format_command(cmd))
                     system("#{cmd} #{S3_EXCLUDE} --exclude '*.blank*'")
                 else
-                    raise RuntimeError unless Blufin::Terminal::execute("#{cmd} #{S3_EXCLUDE} --exclude '*.blank*'", verbose: true, text: cmd)
+                    raise RuntimeError unless Blufin::Terminal::execute("#{cmd} #{S3_EXCLUDE} --exclude '*.blank*'", verbose: true, text: cmd)[0]
                 end
                 s3_url
             rescue
@@ -49,7 +58,7 @@ module Blufin
             tmp_location = "/tmp/awx-s3-cache-#{bucket_name}#{bucket_path_tmp}"
             # If path/file exists and we're using cached values, simply return.
             if file.nil?
-                return tmp_location if Blufin::Files::path_exists(tmp_location) && use_cache
+                return tmp_location if Blufin::Files::path_exists(tmp_location) && use_cache && Blufin::Files::get_files_in_dir(tmp_location).any?
             else
                 return tmp_location if Blufin::Files::file_exists(tmp_location) && use_cache
             end
@@ -60,7 +69,7 @@ module Blufin
                     system("rm #{tmp_location}") unless file.nil?
                     Blufin::Files::create_directory(tmp_location)
                 }, verbose: true)
-                raise RuntimeError unless Blufin::Terminal::execute("aws s3 cp s3://#{bucket_name}#{bucket_path_s3} #{tmp_location} --recursive --region #{region}#{App::AWS::get_profile_for_cli}", verbose: true)
+                raise RuntimeError unless Blufin::Terminal::execute("aws s3 cp s3://#{bucket_name}#{bucket_path_s3} #{tmp_location} --recursive --region #{region}#{App::AWS::get_profile_for_cli}", verbose: true)[0]
                 tmp_location
             rescue
                 system("rm -rf #{tmp_location}") if file.nil?

data/lib/core/config.rb

@@ -56,7 +56,7 @@ module Blufin
             begin
                 schema_file_parsed = YAML.load_file(schema_file)
             rescue => e
-                Blufin::Terminal::error("Failed to parse config file: #{Blufin::Terminal::format_directory(config_file)}", e.message)
+                Blufin::Terminal::error("Failed to schema config file: #{Blufin::Terminal::format_directory(schema_file)}", e.message)
             end
             validator = Kwalify::Validator.new(schema_file_parsed)
             begin

data/lib/core/git.rb

@@ -0,0 +1,274 @@
+module Blufin
+
+    class Git
+
+        HISTORY_TYPES       = %w(branch tag commit)
+        DETACHED_HEAD_REGEX = /\(HEAD\s*detached\s*at\s*/
+
+        @@branch_current_cache    = {}
+        @@btc_exists_cache        = {}
+        @@commit_cache            = {}
+        @@uncommitted_files_cache = {}
+
+        # Tag a branch:
+        # $ git tag -a "v0.1.0-beta" -m "Version: v0.1.0-beta"
+
+        # Show all commits between 2 tags...
+        # $ git log v0.1.0-beta..v0.1.1-beta | grep "^commit [a-z0-9]\{40\}$" | awk '{print $2}'
+
+        # Get commit message for commit hash... (must .strip string)
+        # $ git show d29f2870c59ffab4abb565c3e3c06430cd62515c | grep "^commit [a-z0-9]\{40\}$" -A4 | tail -n 1
+
+        # Easy, clean way to squash all commits on a branch into 1.
+        # $ git reset --soft dev/master
+        # $ git add .
+        # $ git commit -m 'All changes from my branch squashed'
+
+        # Merge that single commit into dev (WITHOUT A MERGE COMMIT!).
+        # [feature] $ git rebase dev
+        # [feature] $ git checkout dev
+        # [dev]     $ git merge --ff-only feature
+
+        # Checks out a project and returns the path to it.
+        # branch_tag_or_commit can be a branch, commit or tag.
+        # Returns current branch/tag/commit (if local) -- in case you want to revert after.
+        # @return string |
+        def self.checkout(project_id, branch: nil, tag: nil, commit: nil, is_ec2: false)
+            begin
+                project      = Blufin::Projects::get_project_by_id(project_id, true)
+                repo_path    = Blufin::Projects::get_project_path(project_id, is_ec2: is_ec2)
+                repo_data    = project[Blufin::Projects::REPOSITORY]
+                type, btc    = resolve_type_btc(branch, tag, commit)
+                errors       = nil
+                current_head = nil
+                if repo_data.has_key?(Blufin::Projects::LOCAL) && !is_ec2
+                    # Make sure branch/tag/commit exists.
+                    raise "#{Blufin::Terminal::format_highlight(type.capitalize)} not found: #{Blufin::Terminal::format_invalid(btc)}" unless Blufin::Git::exists(repo_path, btc, type, false)
+                    # Get current branch (need to reset to this locally after script has run).
+                    current_head = Blufin::Git::get_current_branch(repo_path)
+                else
+                    # If path already exists, do some checks...
+                    if Blufin::Files::path_exists(repo_path)
+                        res  = Blufin::Terminal::execute("git remote -v | tail -n 1 | awk '{print $2}'", repo_path, capture: true, verbose: false, display_error: false)
+                        wipe = false
+                        res  = res[0]
+                        if res.nil? || Blufin::Strings::strip_newline(res) == ''
+                            wipe = true
+                        else
+                            repo_expected = Blufin::Projects::get_project_repo_name(project_id)
+                            repo_actual   = extract_repo_name(res)
+                            wipe          = true if repo_expected != repo_actual
+                        end
+                        # Wipe /tmp folder ONLY if something weird is going on... I put the /tmp regex just in case :)
+                        `rm -rf #{repo_path}/` if wipe && repo_path =~ /^\/tmp\/[A-Za-z0-9\.]+/
+                    end
+                    # Checkout repo (if not exists).
+                    unless Blufin::Files::path_exists(repo_path)
+                        clone_cmd = "git clone #{project[Blufin::Projects::REPOSITORY][Blufin::Projects::REMOTE]} #{repo_path}"
+                        unless Blufin::Terminal::execute_proc(clone_cmd, Proc.new {
+                            res    = Blufin::Terminal::execute("#{clone_cmd} &>/dev/null", '/tmp', capture: true, verbose: false, display_error: false)
+                            errors = res[1].split("\n")
+                            res[1] =~ /^Cloning\s*into\s*('|").+/
+                        })
+                            raise RuntimeError, "Failed to checkout #{type}: #{Blufin::Terminal::format_invalid(btc)}"
+                        end
+                    end
+                    # At this point we should have the repo checked out. Throw an error if we don't.
+                    raise RuntimeError, "Path not found: #{repo_path}" unless Blufin::Files::path_exists(repo_path)
+                end
+                # Checkout branch/tag/commit.
+                unless Blufin::Terminal::execute_proc("git checkout #{btc}", Proc.new {
+                    res       = Blufin::Terminal::execute("git checkout #{btc} &>/dev/null", repo_path, capture: true, verbose: false, display_error: false)
+                    errors    = res[1].split("\n")
+                    last_line = errors[errors.length - 1].strip
+                    last_line =~ /^HEAD\s*is\s*now\s*at\s*.+/i || last_line =~ /^Already\s*on\s*('|")#{btc}('|")$/ || last_line =~ /^Switched\s*to(\s*a\s*new)?\s*branch\s*('|")#{btc}('|")$/
+                })
+                    raise RuntimeError, "Failed to checkout #{type}: #{Blufin::Terminal::format_invalid(btc)}"
+                end
+                current_head
+            rescue => e
+                if is_ec2
+                    err_output = nil
+                    err_output = " - #{errors.is_a?(Array) ? errors.join(', ') : errors.to_s}" unless errors.nil? || errors.strip == ''
+                    raise RuntimeError, Blufin::Strings::strip_ansi_colors("#{e.message}#{err_output}")
+                else
+                    Blufin::Terminal::error(e.message, errors)
+                end
+            end
+        end
+
+        # Gets current branch for a repository.
+        # @return String -> (IE: "master")
+        def self.get_current_branch(path = nil, verbose: false)
+            raise RuntimeError, "Path not found: #{path}" unless path.nil? || Blufin::Files::path_exists(path)
+            path = Blufin::Strings::strip_newline(`pwd`) if path.nil?
+            key  = File.expand_path(path)
+            return @@branch_current_cache[key] if @@branch_current_cache.has_key?(key)
+            res                         = run("git branch | grep \\*", path, text: 'Getting Branch', verbose: verbose)
+            branch                      = Blufin::Strings::strip_newline(res).gsub(/^\*\s?/, '')
+            branch                      = branch.strip.gsub(DETACHED_HEAD_REGEX, '').gsub(/\)$/, '') if branch =~ DETACHED_HEAD_REGEX
+            @@branch_current_cache[key] = branch
+            @@branch_current_cache[key]
+        end
+
+        # Gets latest commit hash for a repository.
+        # @return String -> (IE: "5b7559e5952eacb5251a9baf81dd964fe1ef57f5")
+        def self.get_latest_commit_hash(path, verbose: false)
+            raise RuntimeError, "Path not found: #{path}" unless Blufin::Files::path_exists(path)
+            key = File.expand_path(path)
+            return @@commit_cache[key] if @@commit_cache.has_key?(key)
+            res                 = run('git rev-parse HEAD', path, text: 'Getting HEAD Commit', verbose: verbose)
+            @@commit_cache[key] = Blufin::Strings::strip_newline(res)
+            @@commit_cache[key]
+        end
+
+        # Gets a list of uncommitted files for a repository.
+        # Returns an empty Array if branch is clean.
+        # @return Array -> (IE: ["file-1.txt","file-2.txt"] or [])
+        def self.get_uncommitted_files(path, run_git_add: true, verbose: false, formatted: false, spacer: nil)
+            raise RuntimeError, "Path not found: #{path}" unless Blufin::Files::path_exists(path)
+            raise RuntimeError, "Expected String, instead got: #{spacer.class}" unless spacer.is_a?(String) || spacer.nil?
+            raise RuntimeError, 'Cannot pass spacer if formatted: is false.' if !formatted && !spacer.nil?
+            key = "#{File.expand_path(path)}-#{formatted}-#{spacer}"
+            return @@uncommitted_files_cache[key] if @@uncommitted_files_cache.has_key?(key)
+            renamed  = []
+            modified = []
+            deleted  = []
+            moved    = []
+            new      = []
+            run('git add .', path, verbose: verbose) if run_git_add
+            git_status = run('git status', path, verbose: verbose)
+            git_status = git_status.split("\n")
+            git_status.each do |line|
+                renamed << line.split('renamed:')[1].strip if line =~ /renamed:/i
+                modified << line.split('modified:')[1].strip if line =~ /modified:/i
+                deleted << line.split('deleted:')[1].strip if line =~ /deleted:/i
+                moved << line.split('moved:')[1].strip if line =~ /moved:/i
+                new << line.split('new file:')[1].strip if line =~ /new file:/i
+            end
+            if formatted
+                files  = []
+                spacer = '' if spacer.nil?
+                new.each { |file| files << "#{spacer}\x1B[38;5;246m#{'New: '.rjust(10, ' ')}\x1B[38;5;48m#{file}\x1B[0m" } if new.any?
+                modified.each { |file| files << "#{spacer}\x1B[38;5;246m#{'Modified: '.rjust(10, ' ')}\x1B[38;5;34m#{file}\x1B[0m" } if modified.any?
+                renamed.each { |file| files << "#{spacer}\x1B[38;5;246m#{'Renamed: '.rjust(10, ' ')}\x1B[38;5;34m#{file}\x1B[0m" } if renamed.any?
+                deleted.each { |file| files << "#{spacer}\x1B[38;5;246m#{'Deleted: '.rjust(10, ' ')}\x1B[38;5;124m#{file}\x1B[0m" } if deleted.any?
+                moved.each { |file| files << "#{spacer}\x1B[38;5;246m#{'Moved: '.rjust(10, ' ')}\x1B[38;5;238m#{file}\x1B[0m" } if moved.any?
+            else
+                files = renamed + modified + deleted + moved + new
+                files.sort!
+            end
+            files.uniq!
+            @@uncommitted_files_cache[key] = files
+            @@uncommitted_files_cache[key]
+        end
+
+        # Checks if current branch exists.
+        # @return bool
+        def self.branch_exists(path, branch, run_git_fetch: false)
+            exists(path, branch, 'branch', run_git_fetch)
+        end
+
+        # Checks if tag exists.
+        # @return bool
+        def self.tag_exists(path, tag, run_git_fetch: false)
+            exists(path, tag, 'tag', run_git_fetch)
+        end
+
+        # Checks if commit exists.
+        # @return bool
+        def self.commit_exists(path, commit, run_git_fetch: false)
+            exists(path, commit, 'commit', run_git_fetch)
+        end
+
+        # Runs $ git add .
+        # @return void
+        def self.add(path, add = '.', verbose: true)
+            raise RuntimeError, "Path not found: #{path}" unless path.nil? || Blufin::Files::path_exists(path)
+            path = Blufin::Strings::strip_newline(`pwd`) if path.nil?
+            run("git add #{add}", path, verbose: verbose)
+        end
+
+        # Attempts to convert something like git@github.com:alb3rtuk/blufin-archetypes.git into -> blufin-archetypes.
+        # @return string
+        def self.extract_repo_name(string)
+            raise RuntimeError, "Expected String, instead got: #{string.class}" unless string.is_a?(String)
+            repo_name = Blufin::Strings::strip_newline(string).split('/')
+            repo_name[repo_name.length - 1].gsub(/\.git$/i, '')
+        end
+
+        private
+
+        # Convenience method to run commands. Throws error if anything fails.
+        # Returns only the output, not the error. Does not strip new lines! This must be done 1 level up.
+        # @return string
+        def self.run(cmd, path, text: nil, verbose: true)
+            res = Blufin::Terminal::execute(cmd, path, capture: true, text: text, verbose: verbose)
+            Blufin::Terminal::error("Something went wrong: #{Blufin::Terminal::format_invalid(res[1])}") unless res[1].nil?
+            res[0]
+        end
+
+        # Common code for 'exists' method(s).
+        # @return bool
+        def self.exists(path, btc, type, run_git_fetch)
+            raise RuntimeError, "Path not found: #{path}" unless path.nil? || Blufin::Files::path_exists(path)
+            raise RuntimeError, "Invalid type: #{type}" unless HISTORY_TYPES.include?(type)
+            key = "#{File.expand_path(path)}|#{btc}|#{type}|#{run_git_fetch}"
+            return @@btc_exists_cache[key] if @@btc_exists_cache.has_key?(key)
+            exists = false
+            Blufin::Terminal::execute_proc("Checking #{type} exists: #{Blufin::Terminal::format_highlight(btc)} \x1B[38;5;246m\xe2\x86\x92 \x1B[38;5;240m#{File.expand_path(path)}\x1B[0m", Proc.new {
+                run('git fetch -p', path, verbose: false) if run_git_fetch
+                cmd = %w(branch tag).include?(type) ? "git #{type} | grep #{btc}" : "git log | grep \"commit #{btc}\""
+                res = Blufin::Terminal::execute(cmd, path, capture: true, verbose: false)
+                res.each do |line|
+                    next if line.nil? || line.strip == ''
+                    case type
+                        when 'branch'
+                            line = line.gsub(/^\*\s?/, '')
+                        when 'commit'
+                            line = line.gsub(/^commit\s?/, '')
+                        when 'tag'
+                        else
+                            raise RuntimeError, "Unrecognized type: #{type}"
+                    end
+                    line = Blufin::Strings::strip_newline(line)
+                    if line =~ /^#{btc}$/
+                        exists = true
+                        break
+                    end
+                end
+                exists
+            })
+            @@btc_exists_cache[key] = exists
+            @@btc_exists_cache[key]
+        end
+
+        # Convenience method to resolve type and branch/tag/commit name.
+        # @return Array
+        def self.resolve_type_btc(branch, tag, commit)
+            set = 0
+            set =+1 unless branch.nil?
+            set =+1 unless tag.nil?
+            set =+1 unless commit.nil?
+            raise RuntimeError, "Must set atleast one of: #{HISTORY_TYPES.join(', ')}" if set == 0
+            raise RuntimeError, "Can only set one of: #{HISTORY_TYPES.join(', ')}" if set > 1
+            type = 'branch' unless branch.nil?
+            type = 'tag' unless tag.nil?
+            type = 'commit' unless commit.nil?
+            case type
+                when 'branch'
+                    btc = branch
+                when 'tag'
+                    btc = tag
+                when 'commit'
+                    btc = commit
+                else
+                    raise RuntimeError, "Unrecognized type: #{type}"
+            end
+            raise RuntimeError, "#{type.capitalize} cannot be nil." if btc.nil? || btc.strip == ''
+            [type, btc]
+        end
+
+    end
+
+end

data/lib/core/projects.rb

@@ -16,7 +16,10 @@ module Blufin
         PROJECT_ROOT             = 'ProjectRoot'
         TYPE                     = 'Type'
         REPOSITORY               = 'Repository'
+        UPSTREAM                 = 'Upstream'
+        DOWNSTREAM               = 'Downstream'
         LOCAL                    = 'Local'
+        REMOTE                   = 'Remote'
         FILE                     = 'File'
         DEPLOYMENT               = 'Deployment'
         DEPLOYMENT_BUCKET        = 'Bucket'
@@ -29,6 +32,8 @@ module Blufin
         CRON                     = 'Cron'
         WORKER                   = 'Worker'
         LAMBDA                   = 'Lambda'
+        UI                       = 'UI'
+        ROUTES_FILE              = 'RoutesFile'
         TITLE                    = 'Title'
         ALIAS                    = 'Alias'
         DOMAIN                   = 'Domain'
@@ -40,25 +45,40 @@ module Blufin
         TYPE_ALEXA               = 'alexa'
         TYPE_API                 = 'api'
         TYPE_LAMBDA              = 'lambda'
+        TYPE_MVN_LIB             = 'mvn-lib'
+        TYPE_NPM_LIB             = 'npm-lib'
         TYPE_UI                  = 'ui'
+        TYPE_MOBILE              = 'mobile'
         VALID_TYPES              = [
             TYPE_ALEXA,
             TYPE_API,
             TYPE_LAMBDA,
+            TYPE_MVN_LIB,
+            TYPE_NPM_LIB,
             TYPE_UI,
+            TYPE_MOBILE,
         ]
 
-        @@projects      = nil
-        @@project_names = []
-        @@scripts       = nil
-        @@apis          = nil
-        @@lambdas       = nil
+        @@projects                 = nil
+        @@projects_arr             = []
+        @@projects_cache           = {}
+        @@project_names            = []
+        @@project_ids              = []
+        @@scripts                  = nil
+        @@apis                     = nil
+        @@api_data                 = {}
+        @@lambdas                  = nil
+        @@libs                     = {}
+        @@uis                      = nil
+        @@dependant_projects_cache = {}
+        @@dependant_repos_cache    = {}
+        @@project_path_cache       = {}
 
         # Takes a Hash that needs to have a 'Projects' key.
         # This can come from both .awx.yml['Profiles'] or .blufin.yml (root).
         # @return void
-        def self.init(projects)
-            raise RuntimeError, 'Cannot run Blufin::Projects::init() more than once.' unless @@projects.nil? && @@scripts.nil?
+        def initialize(projects)
+            raise RuntimeError, 'Cannot run Blufin::Projects.new() more than once.' if !@@projects.nil? || !@@scripts.nil?
             raise RuntimeError, "Need either a Local or S3Bucket key, found neither: #{projects.keys}" unless projects.has_key?(LOCAL) || projects.has_key?('S3Bucket')
             @@projects = {}
             @@scripts  = {}
@@ -77,20 +97,40 @@ module Blufin
                 raise RuntimeError, 'Reading projects.yml from S3 is not yet implemented!'
 
             end
+
         end
 
-        # Gets Project(s).
+        # Gets Project(s) -- as a nested hash with -> [PROJECT][PROJECT_ID] as the keys.
         # @return Hash
         def self.get_projects
             @@projects
         end
 
+        # Gets Project(s) -- but in a single array.
+        # @return Array
+        def self.get_projects_as_array(type: nil)
+            projects_arr = []
+            if type.nil?
+                validate_type(project_type, project_id)
+                projects_arr = @@projects_arr
+            else
+                @@projects_arr.each { |project| projects_arr << project if project[TYPE] == type }
+            end
+            projects_arr
+        end
+
         # Gets Project Name(s).
         # @return Array
         def self.get_project_names
             @@project_names
         end
 
+        # Gets Project ID(s).
+        # @return Array
+        def self.get_project_ids
+            @@project_ids
+        end
+
         # Gets Script(s).
         # @return Hash
         def self.get_scripts
@@ -109,25 +149,147 @@ module Blufin
             @@lambdas
         end
 
-        # Maps root-level property to enum.
+        # Attempts to get a project's data by ID, displays error if not exists.
         # @return string
-        def self.script_key_mapper(script_type)
-            if [RUN_SCRIPTS, RUN].include?(script_type)
-                return SCRIPT_RUN
-            elsif [TEST_SCRIPTS, TEST].include?(script_type)
-                return TEST_SCRIPTS
-            elsif [BUILD_SCRIPTS, BUILD].include?(script_type)
-                return BUILD_SCRIPTS
+        def self.get_project_by_id(project_id, runtime_error = false)
+            raise RuntimeError, "Expected String, instead got: #{project_id.class}" unless project_id.is_a?(String)
+            return @@projects_cache[project_id] if @@projects_cache.has_key?(project_id)
+            project_data = nil
+            if @@projects_arr.is_a?(Array)
+                @@projects_arr.each do |project|
+                    raise RuntimeError, 'Missing Project ID.' unless project.has_key?(PROJECT_ID)
+                    if project[PROJECT_ID].strip.downcase == project_id.strip.downcase
+                        project_data = project
+                        break
+                    end
+                end
+            end
+            raise RuntimeError, "Unrecognized Project ID: #{project_id}" if project_data.nil? && runtime_error
+            Blufin::Terminal::error("Unrecognized Project ID: #{Blufin::Terminal::format_invalid(project_id)} . Available Projects IDs are:", get_project_ids) if project_data.nil? && !runtime_error
+            @@projects_cache[project_id] = project_data
+            @@projects_cache[project_id]
+        end
+
+        # Gets an array of project(s) from current path.
+        # @return Array
+        def self.get_projects_by_path
+            projects     = {}
+            current_path = Blufin::Strings::strip_newline(`pwd`)
+            get_projects_as_array.each do |project|
+                if project.has_key?(REPOSITORY)
+                    if project[REPOSITORY].has_key?(LOCAL)
+                        project_path = File.expand_path(project[REPOSITORY][LOCAL])
+                        if current_path =~ /^#{project_path}/
+                            raise RuntimeError, 'Missing Project ID.' unless project.has_key?(PROJECT_ID)
+                            projects[project[PROJECT_ID]] = project
+                        end
+                    end
+                end
+            end
+            projects
+        end
+
+        # Gets the path to a project. By default, gets the root (IE: doesn't take into account 'Repository.ProjectRoot' key).
+        # If you want the full path to the inner project, to_inner_project must be set to TRUE.
+        # If local, simply returns path in projects.yml.
+        # If not local (IE: on EC2), returns a standardized /tmp path.
+        # @return string
+        def self.get_project_path(project_id, to_inner_project = false, is_ec2: false, project: nil)
+            key = "#{project_id}|#{to_inner_project}|#{is_ec2}"
+            return @@project_path_cache[key] if @@project_path_cache.has_key?(key)
+            project      = project.nil? ? get_project_by_id(project_id, true) : project
+            repo_data    = project[REPOSITORY]
+            inner_path   = repo_data.has_key?(PROJECT_ROOT) ? Blufin::Strings::remove_surrounding_slashes(repo_data[PROJECT_ROOT]) : ''
+            project_path = nil
+            if repo_data.has_key?(LOCAL) && !is_ec2
+                root_path    = Blufin::Strings::remove_surrounding_slashes(File.expand_path(repo_data[LOCAL]))
+                project_path = "/#{root_path}" unless to_inner_project
+                project_path = "/#{root_path}#{inner_path.length > 0 ? '/' : ''}#{inner_path}" if to_inner_project
             else
-                raise RuntimeError, "Unhandled script type: #{script_type}"
+                rs           = repo_data[REMOTE].split('/')
+                tmp_path     = "/tmp/repo-#{rs[rs.length - 1].gsub(/\.git$/i, '')}"
+                project_path = tmp_path unless to_inner_project
+                project_path = "#{tmp_path}#{inner_path.length > 0 ? '/' : ''}#{inner_path}" if to_inner_project
+            end
+            raise RuntimeError, "Project Path should never be nil or an empty string: #{key}" if project_path.nil? || project_path.strip == ''
+            @@project_path_cache[key] = project_path
+            @@project_path_cache[key]
+        end
+
+        # Gets a hash of dependant projects (with the Project IDs as keys).
+        # processed_projects Array prevents cyclic-dependency stack overflow.
+        # @return Hash
+        def self.get_dependant_projects(project_id, streams: [UPSTREAM, DOWNSTREAM], processed_projects: [])
+            valid_streams = [UPSTREAM, DOWNSTREAM]
+            raise RuntimeError, "Expected Array, instead got: #{streams.class}" unless streams.is_a?(Array)
+            streams.each { |s| raise RuntimeError, "Invalid stream: #{s}" unless valid_streams.include?(s) }
+            key = "#{project_id}-#{streams.join('-')}"
+            return @@dependant_projects_cache[key] if @@dependant_projects_cache.has_key?(key)
+            dependant_projects = {}
+            project            = get_project_by_id(project_id, true)
+            streams.each do |stream|
+                if project.has_key?(stream)
+                    project[stream].each do |dependant_project_id|
+                        unless processed_projects.include?(dependant_project_id)
+                            processed_projects << dependant_project_id
+                            dependant_projects[dependant_project_id] = get_project_by_id(dependant_project_id, true) unless dependant_projects.has_key?(dependant_project_id)
+                            dependant_projects_inner                 = Blufin::Projects::get_dependant_projects(dependant_project_id, streams: streams, processed_projects: processed_projects)
+                            # Add nested dependant projects (if any).
+                            dependant_projects_inner.each { |k, v| dependant_projects[k] = v unless dependant_projects.has_key?(k) } if dependant_projects_inner.any?
+                        end
+                    end
+                end
             end
+            # Don't include project itself in dependant projects.
+            dependant_projects.delete(project_id) if dependant_projects.has_key?(project_id)
+            @@dependant_projects_cache[key] = dependant_projects
+            @@dependant_projects_cache[key]
+        end
+
+        # Same as above, but only gets the repositories.
+        # Sometimes multiple dependant_project IDs may have the same repository.
+        # @return Hash
+        def self.get_dependant_repos(project_id, streams: [UPSTREAM, DOWNSTREAM])
+            key = "#{project_id}-#{streams.join('-')}"
+            return @@dependant_repos_cache[key] if @@dependant_repos_cache.has_key?(key)
+            dependant_repos = {}
+            get_dependant_projects(project_id, streams: streams).each do |k, v|
+                next if k == project_id
+                repo                         = v[REPOSITORY][REMOTE]
+                dependant_repos[repo]        = {
+                    :projects => []
+                } unless dependant_repos.include?(repo)
+                dependant_repos[repo][:path] = v[REPOSITORY][LOCAL] if v[REPOSITORY].has_key?(LOCAL)
+                dependant_repos[repo][:projects] << k unless dependant_repos[repo][:projects].include?(k)
+            end
+            @@dependant_repos_cache[key] = dependant_repos
+            @@dependant_repos_cache[key]
+        end
+
+        # Gets repo-name from project_id.
+        # @return string
+        def self.get_project_repo_name(project_id)
+            project = get_project_by_id(project_id, true)
+            Blufin::Git::extract_repo_name(project[REPOSITORY][REMOTE])
+        end
+
+        # Shows a prompt and returns project Hash once selected.
+        # If only one project exists, prompt not displayed.
+        # @return Hash
+        def self.show_project_prompt(array_of_projects)
+            raise RuntimeError, "Expected Array, instead got: #{array_of_projects.class}" unless array_of_projects.is_a?(Array)
+            Blufin::Terminal::error('No projects found.') unless array_of_projects.any?
+            return array_of_projects[0] if array_of_projects.length == 1
+            projects = []
+            array_of_projects.each { |project| projects << { :text => project[PROJECT_ID], :value => project } }
+            Blufin::Terminal::prompt_select('Select project:', projects)
         end
 
         private
 
         # Validate the Project YML.
         # @return void
-        def self.process_source_file(source_file)
+        def process_source_file(source_file)
             # Skip empty file.
             return if Blufin::Files::is_empty(source_file)
             # Otherwise, validate file.
@@ -170,8 +332,31 @@ module Blufin
                     end
                 end
 
+                # Buffer/validate project(s) stuff.
+                file_parsed['Projects'].each do |project|
+                    project_id   = project[PROJECT_ID]
+                    project_type = project[TYPE]
+                    if project_type == TYPE_MVN_LIB || TYPE_NPM_LIB
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Duplicate Library Project.", "A library with this ID (#{Blufin::Terminal::format_invalid(project_id)}) has already been registered.") if @@libs.keys.include?(project_id)
+                        @@libs[project_id] = project
+                    elsif project_type == TYPE_API
+                        [ALIAS, PROJECT_NAME, PROJECT_NAME_PASCAL_CASE, TITLE].each do |x|
+                            @@api_data[x]  = [] unless @@api_data.has_key?(x) && @@api_data[x].is_a?(Array)
+                            property_value = project[API][x].strip.downcase
+                            Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Duplicate #{x} API Property.", "An API Property with this value (#{Blufin::Terminal::format_invalid(property_value)}) has already been registered.") if @@api_data[x].include?(property_value)
+                            @@api_data[x] << property_value
+                        end
+                    end
+                end
+
                 used_ports = {}
 
+                # Run through once quickly to populate critical objects (required for validation).
+                file_parsed['Projects'].each do |project|
+                    @@project_names << project[PROJECT]
+                    @@project_ids << project[PROJECT_ID]
+                end
+
                 # Loop (and validate) projects.
                 file_parsed['Projects'].each do |project|
                     # Validate keys are in specific order.
@@ -180,25 +365,26 @@ module Blufin
                         PROJECT    => true,
                         TYPE       => true,
                         REPOSITORY => true,
+                        UPSTREAM   => false,
+                        DOWNSTREAM => false,
                         RUN        => false,
                         TEST       => false,
                         BUILD      => false,
                         API        => false,
                         LAMBDA     => false,
-                        DEPLOYMENT => false
+                        UI         => false,
+                        DEPLOYMENT => false,
                     }
                     Blufin::Validate::assert_valid_keys(expected, project.keys, source_file)
                     project_id   = project[PROJECT_ID]
                     project_name = project[PROJECT]
                     project_type = project[TYPE]
-                    @@project_names << project_name
-                    # Validate Type.
-                    Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Invalid Project Type: #{Blufin::Terminal::format_invalid(project_type)}. Valid types are:", VALID_TYPES, true) unless VALID_TYPES.include?(project_type)
+                    validate_type(project_type, project_id)
                     # Validate Script(s).
                     [RUN, TEST, BUILD].each do |script_type|
                         if project.has_key?(script_type)
                             # Validate the LAMBDA functions don't need build scripts.
-                            Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Project type: #{Blufin::Terminal::format_highlight(TYPE_LAMBDA)} does not require #{Blufin::Terminal::format_invalid(script_type)} script(s).", 'This type of project does not support this.', true) if [BUILD].include?(script_type) && project_type == TYPE_LAMBDA
+                            Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Project type: #{Blufin::Terminal::format_highlight(TYPE_LAMBDA)} does not require #{Blufin::Terminal::format_invalid(script_type)} script(s).", 'This type of project does not support this.', true) if [BUILD].include?(script_type) && project_type == TYPE_LAMBDA
                             if project[script_type].is_a?(Hash)
                                 script_key    = script_key_mapper(script_type)
                                 valid_scripts = []
@@ -207,12 +393,21 @@ module Blufin
                                 script_name   = script['Script']
                                 unless valid_scripts.include?(script_name)
                                     error = valid_scripts.any? ? 'Valid values are:' : "There currently are no #{script_key} script(s) defined."
-                                    Blufin::Terminal::error("#{project_id} \xe2\x80\x94 #{Blufin::Terminal::format_highlight(script_type)} \xe2\x80\x94 Invalid script reference: #{Blufin::Terminal::format_invalid(script_name)}. #{error}", valid_scripts)
+                                    Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 #{Blufin::Terminal::format_highlight(script_type)} \xe2\x80\x94 Invalid script reference: #{Blufin::Terminal::format_invalid(script_name)}. #{error}", valid_scripts)
                                 end
                             end
                         end
                     end
 
+                    # Validate Repository property.
+                    if project.has_key?(REPOSITORY)
+                        if project[REPOSITORY].has_key?(LOCAL)
+                            repo_path = project[REPOSITORY][LOCAL]
+                            Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Repository path not found: #{Blufin::Terminal::format_invalid(repo_path)}") unless Blufin::Files::path_exists(repo_path)
+
+                        end
+                    end
+
                     # Validate Deployment property.
                     if project.has_key?(DEPLOYMENT)
                         expected = {
@@ -225,7 +420,7 @@ module Blufin
                     # Validate API property.
                     if project_type == TYPE_API
                         # Make sure we have the API property.
-                        Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Missing property: #{Blufin::Terminal::format_highlight(API)}", "This property is required for project(s) with type: #{API}", true) unless project.has_key?(API)
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Missing property: #{Blufin::Terminal::format_highlight(API)}", "This property is required for project(s) with type: #{API}", true) unless project.has_key?(API)
                         # Validate keys are in specific order.
                         expected = {
                             TITLE                    => true,
@@ -248,16 +443,16 @@ module Blufin
                         used_ports[project[API][PORTS][CRON]]   = project_id
                         used_ports[project[API][PORTS][WORKER]] = project_id
                         @@apis                                  = {} if @@apis.nil?
-                        @@apis[project[PROJECT_ID]]             = project[API]
+                        @@apis[project[PROJECT_ID]]             = project
                     else
                         # Make sure we DON'T have the API key.
-                        Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Property not supported: #{Blufin::Terminal::format_invalid(API)}", "This property is only allowed for project(s) with type: #{API}", true) if project.has_key?(API)
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Property not supported: #{Blufin::Terminal::format_invalid(API)}", "This property is only allowed for project(s) with type: #{API}", true) if project.has_key?(API)
                     end
 
                     # Validate Lambda property.
                     if project_type == TYPE_LAMBDA
-                        # Make sure we have the Lambda
-                        Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Missing property: #{Blufin::Terminal::format_highlight(LAMBDA)}", "This property is required for project(s) with type: #{LAMBDA}", true) unless project.has_key?(LAMBDA)
+                        # Make sure we have the Lambda property.
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Missing property: #{Blufin::Terminal::format_highlight(LAMBDA)}", "This property is required for project(s) with type: #{TYPE_LAMBDA}", true) unless project.has_key?(LAMBDA)
                         # Validate keys are in specific order.
                         expected = {
                             TITLE  => true,
@@ -274,12 +469,49 @@ module Blufin
                         @@lambdas[project[PROJECT_ID]] = project
                     else
                         # Make sure we DON'T have the Lambda key.
-                        Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Property not supported: #{Blufin::Terminal::format_invalid(LAMBDA)}", "This property is only allowed for project(s) with type: #{LAMBDA}", true) if project.has_key?(LAMBDA)
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Property not supported: #{Blufin::Terminal::format_invalid(LAMBDA)}", "This property is only allowed for project(s) with type: #{TYPE_LAMBDA}", true) if project.has_key?(LAMBDA)
+                    end
+
+                    # Validate UI property.
+                    if project_type == TYPE_UI
+                        # Make sure we have the UI property.
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Missing property: #{Blufin::Terminal::format_highlight(UI)}", "This property is required for project(s) with type: #{TYPE_UI}", true) unless project.has_key?(UI)
+                        # Validate keys are in specific order.
+                        expected = {
+                            ROUTES_FILE => true
+                        }
+                        Blufin::Validate::assert_valid_keys(expected, project[UI].keys, source_file)
+                        # Validate RoutesFile exists.
+                        routes_file = "#{Blufin::Projects::get_project_path(project_id, true, project: project)}/#{project[UI][ROUTES_FILE]}"
+                        Blufin::Terminal::error("Cannot find #{Blufin::Terminal::format_highlight(ROUTES_FILE)}: #{Blufin::Terminal::format_directory(routes_file)}") unless Blufin::Files::file_exists(routes_file)
+                        @@uis = {} if @@uis.nil?
+                        Blufin::Terminal::error("Duplicate UI project: #{Blufin::Terminal::format_invalid(project[PROJECT_ID])}") if @@uis.has_key?(project[PROJECT_ID])
+                        @@uis[project[PROJECT_ID]] = project
+                    else
+                        # Make sure we DON'T have the UI key.
+                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Property not supported: #{Blufin::Terminal::format_invalid(UI)}", "This property is only allowed for project(s) with type: #{TYPE_UI}", true) if project.has_key?(UI)
+                    end
+
+                    # Validate upstream/downstream Libs(s).
+                    [UPSTREAM, DOWNSTREAM].each do |stream|
+                        if project.has_key?(stream)
+                            project[stream].each do |library|
+                                case stream
+                                    when UPSTREAM
+                                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Unrecognized #{Blufin::Terminal::format_action(UPSTREAM)} library: #{Blufin::Terminal::format_invalid(library)}") unless @@libs.keys.include?(library)
+                                    when DOWNSTREAM
+                                        Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Unrecognized #{Blufin::Terminal::format_action(DOWNSTREAM)} library: #{Blufin::Terminal::format_invalid(library)}") unless @@project_ids.include?(library)
+                                    else
+                                        raise RuntimeError, "Unrecognized stream: #{stream}"
+                                end
+                            end
+                        end
                     end
 
                     @@projects[project_name] = {} unless @@projects.has_key?(project_name)
                     Blufin::Terminal::error("Duplicate project ID: #{Blufin::Terminal::format_invalid(project_id)}") if @@projects[project_name].has_key?(project_id)
                     @@projects[project_name][project_id] = project
+                    @@projects_arr << project
 
                 end
                 @@project_names.uniq!
@@ -287,12 +519,33 @@ module Blufin
             end
         end
 
+        # Validate project type.
+        # @return void
+        def validate_type(project_type, project_id = nil)
+            project_id = project_id.nil? ? nil : "#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 "
+            Blufin::Terminal::error("#{project_id}Invalid Project Type: #{Blufin::Terminal::format_invalid(project_type)}. Valid types are:", VALID_TYPES, true) unless VALID_TYPES.include?(project_type)
+        end
+
+        # Maps root-level property to enum.
+        # @return string
+        def script_key_mapper(script_type)
+            if [RUN_SCRIPTS, RUN].include?(script_type)
+                return SCRIPT_RUN
+            elsif [TEST_SCRIPTS, TEST].include?(script_type)
+                return TEST_SCRIPTS
+            elsif [BUILD_SCRIPTS, BUILD].include?(script_type)
+                return BUILD_SCRIPTS
+            else
+                raise RuntimeError, "Unhandled script type: #{script_type}"
+            end
+        end
+
         # Validate the ports. Make sure none of the ports conflict with other projects.
         # @return void
-        def self.validate_ports(ports, project_id, used_ports)
+        def validate_ports(ports, project_id, used_ports)
             ports.each do |port|
                 if used_ports.has_key?(port)
-                    Blufin::Terminal::error("#{project_id} \xe2\x80\x94 Duplicate port detected: #{Blufin::Terminal::format_invalid(port)} ", ["The conflicting project is: #{Blufin::Terminal::format_highlight(used_ports[port])}"])
+                    Blufin::Terminal::error("#{Blufin::Terminal::format_highlight(project_id)} \xe2\x80\x94 Duplicate port detected: #{Blufin::Terminal::format_invalid(port)} ", ["The conflicting project is: #{Blufin::Terminal::format_highlight(used_ports[port])}"])
                 end
 
             end