escli 1.0.0

data/lib/canzea/core/trace-runner.rb

@@ -0,0 +1,108 @@
+require 'json'
+require 'open3'
+require 'stringio'
+require 'logger'
+require 'canzea/core/audit'
+require 'canzea/config'
+
+def time_diff_milli(start, finish)
+   (finish - start) * 1000.0
+end
+
+def handleIO(stillOpen, ioArray, io, log)
+  if ioArray.include?(io)
+    begin
+      log.write(io.readpartial(4096))
+    rescue EOFError
+      stillOpen.delete_if{|s| s == io}
+    end
+  end
+end
+
+class RunnerWorker
+    def initialize (_raw)
+        @raw = _raw;
+    end
+
+    def run(command, start, lines, statusIndicator = false)
+        audit = Audit.new @raw
+
+	    log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+
+        log.info("HANDLING: " + command)
+
+        l = command
+
+        audit.start( "#{lines + 1 }", l.chomp)
+
+        t1 = Time.now
+
+        workingDir = Canzea::config[:pwd]
+
+        pputs "Executing [#{workingDir}] #{l}"
+        Dir.chdir(workingDir){
+
+            Open3.popen3(ENV, l) {|stdin, stdout, stderr, wait_thr|
+              pid = wait_thr.pid # pid of the started process.
+
+              log_w = StringIO.new
+
+              stillOpen = [stdout, stderr]
+              while !stillOpen.empty?
+                fhs = select(stillOpen, nil, nil, nil)
+                handleIO(stillOpen, fhs[0], stdout, log_w)
+                handleIO(stillOpen, fhs[0], stderr, log_w)
+              end
+
+              exit_status = wait_thr.value # wait for it to finish
+
+              log_w.close_write
+
+              t2 = Time.now
+              msecs = time_diff_milli t1, t2
+
+              output = log_w.string
+
+              output.scan(/.{1,80}/).each do | line |
+                  log.info("STDOUT: #{line}")
+              end
+
+              log.info("Exit Status = #{exit_status}")
+              log.info("Completed in (ms) : #{msecs}")
+
+              pputs "Exit Status = #{exit_status}"
+              output.split(/\n/).each do | line |
+                  pputs "#{line}"
+              end
+
+
+              # if exit status is failure then exit right away
+
+              audit.complete("#{lines + 1}", l.chomp, exit_status.exitstatus, msecs, output)
+
+              if (statusIndicator)
+                  audit.status("#{lines + 1}", l.chomp, exit_status.exitstatus, msecs, output)
+              end
+
+              if (@raw)
+                  puts output
+              end
+
+              if exit_status.exitstatus != 0
+                abort()
+              end
+            }
+        }
+
+        lines += 1
+
+        return lines
+
+    end
+
+    def pputs (s)
+        if (@raw == false)
+            puts "-- #{s}"
+        end
+    end
+end

data/lib/canzea/environment.rb

@@ -0,0 +1,6 @@
+module Canzea
+
+#    if ENV.has_key?('CONSUL_URL') == false
+#        raise("CONSUL_URL environment variable is required to be set!")
+#    end
+end

data/lib/canzea/helper-run-class.rb

@@ -0,0 +1,89 @@
+require 'json'
+require 'logger'
+require "base64"
+
+require "canzea/core/prepare-environment"
+require "canzea/core/trace-runner"
+
+class HelperRun
+    def initialize (_raw)
+        @basePath = "#{Pathname.new(Canzea::config[:catalog_location]).realpath}"
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+        @raw = _raw
+    end
+
+    def runPlan (plans)
+        plans.each { | plan |
+            puts "Running #{plan[:action]}"
+            self.run plan[:solution], plan[:action], JSON.generate(plan[:parameters])
+        }
+    end
+
+    def enrich (params)
+        # If there is context information, then merge them into the parameters before calling the helper
+        if (ENV.has_key?('WORK_DIR') and File.exists?ENV['WORK_DIR'] + "/context.json")
+            context = JSON.parse(File.read(ENV['WORK_DIR'] + "/context.json"))
+            result = JSON.parse(params).merge(context)
+            return JSON.generate(result)
+        end
+        return params
+    end
+
+    def run (solution, action, parameters, status = false)
+
+        type = "ruby"
+
+        parameters = self.enrich(parameters)
+
+        envPush = PrepareEnvironment.new @raw
+
+        begin
+            root = "#{@basePath}/helpers/#{solution}"
+            if File.exist?("#{@basePath}/blocks/#{solution}/#{action}")
+                root = "#{@basePath}/blocks/#{solution}/#{action}"
+            end
+            envScript = "#{root}/environment.json"
+            if File.exist?(envScript)
+                @log.info("Adding environment variables...")
+                envPush.addToEnv "#{envScript}"
+            end
+
+            if File.exist?("#{root}/#{action}.sh")
+                type = "shell"
+            elsif File.exist?("#{root}/#{action}.py")
+                type = "python"
+            end
+
+            r = RunnerWorker.new @raw
+
+            ENV['CATALOG_LOCATION'] = "#{@basePath}";
+
+            ENV['ES_SOLUTION'] = solution;
+            ENV['ES_ACTION'] = action;
+
+            parameters = Template.new.processString(parameters, {})
+
+            if (type == "ruby")
+                cmd = "ruby #{root}/#{action}.rb '#{parameters}'"
+            elsif (type == "python")
+                cmd = "python #{root}/#{action}.py '#{parameters}'"
+            else
+                argList = []
+                args = JSON.parse(parameters)
+                args.each do | k |
+                    argList.push('--' + k[0])
+                    argList.push('"' + k[1] + '"')
+                end
+
+                cmd = "#{root}/#{action}.sh #{argList.join(' ')}"
+            end
+            r.run cmd, 1, 1, status
+
+        rescue => exception
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+    end
+end

data/lib/canzea/plan-step-class.rb

@@ -0,0 +1,210 @@
+require 'json'
+require 'logger'
+require 'pathname'
+require 'canzea/helper-run-class'
+require 'canzea/core/prepare-environment'
+require 'canzea/core/trace-component'
+require 'canzea/commands/push-config'
+
+class PlanStep
+    def initialize ()
+        @basePath = "#{Pathname.new(Canzea::config[:catalog_location]).realpath}"
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+
+    def runPhaseInstall (role, solution, test, task)
+
+        plan = JSON.parse("{ \"plan\": [ { \"role\": \"#{role}\", \"solution\": \"#{solution}\" } ] }")
+
+        ENV['ES_ROLE'] = role;
+        ENV['ES_SOLUTION'] = solution;
+
+        n = Worker.new
+        n.test ( test )
+
+        start = Integer(task)
+        lines = 1
+
+        cmd = "undefined"
+
+        begin
+
+            plan['plan'].each do |item|
+                @log.info(item['solution'])
+
+                root = "#{@basePath}/roles/#{item['role']}/#{item['solution']}"
+                if File.exist?(root) == false
+                    root = "#{@basePath}/blocks/#{item['solution']}"
+                    if File.exist?(root) == false
+                        puts "-- ERROR #{root} does not exist!"
+                        raise "#{root} does not exist!"
+                    end
+                end
+
+                cmd = "#{root}/install.sh"
+                if File.exist?(cmd)
+                    lines = n.run cmd, start, lines - 1
+
+                    @log.info "#{ lines } lines read"
+                end
+            end
+        rescue => exception
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+    end
+
+    def runPhaseConfigure (role, solution, test, task, ref="")
+
+        plan = JSON.parse("{ \"plan\": [ { \"role\": \"#{role}\", \"solution\": \"#{solution}\" } ] }")
+
+        ENV['ES_REF'] = ref;
+        ENV['ES_ROLE'] = role;
+        ENV['ES_SOLUTION'] = solution;
+
+        n = Worker.new
+        n.test ( test )
+
+        start = Integer(task)
+        lines = 1
+
+        cmd = "undefined"
+
+        begin
+
+            plan['plan'].each do |item|
+
+                root = "#{@basePath}/roles/#{item['role']}/#{item['solution']}"
+                if File.exist?(root) == false
+                    root = "#{@basePath}/blocks/#{item['solution']}"
+                    if File.exist?(root) == false
+                        log "-- ERROR #{root} does not exist!"
+                        raise "#{root} does not exist!"
+                    end
+                end
+
+                if (test == false)
+                    # Register the service with Consul, if consul is ready
+                    # If metadata.json exists, then use the information to register
+                    cmd = "#{root}/metadata.json"
+                    if File.exist?(cmd)
+                        md = File.read(cmd)
+                        md = JSON.parse(md)
+                        if (md['services'].size() > 0)
+                            svc = md['services'][0]
+
+                            adef = {
+                                "listener"=>svc['listener'],
+                                "name" => "#{svc['name']}",
+                                "id" => "#{ENV['HOSTNAME']}-#{svc['name']}",
+                                "tags"=>[ item['role'] ],
+                                "port"=>svc['port']
+                            }
+                            log "-- Registering #{svc['name']}"
+                            h = HelperRun.new false
+                            h.run "consul", "register_service", JSON.generate(adef)
+                        end
+                    end
+
+                    envScript = "#{root}/environment.json"
+                    if File.exist?(envScript)
+                        envPush = PrepareEnvironment.new false
+                        envPush.addToEnv "#{envScript}"
+                    end
+
+                end
+
+                cmd = "#{root}/configure.sh"
+                if File.exist?(cmd)
+                  lines = n.run cmd, start, lines - 1, false, ref
+                end
+
+                cmd = "#{root}/enable.sh"
+                if File.exist?(cmd)
+                  lines = n.run cmd, start, lines - 1, false, ref
+                end
+
+                cmd = "#{root}/status.sh"
+                if File.exist?(cmd)
+                  lines = n.run cmd, start, lines - 1, true, ref
+                end
+
+                if ENV.has_key? "ECOSYSTEM_CONFIG_GIT"
+                    log "-- Writing data to ecosystem git"
+                    adef = {
+                        "ES_ROLE" => role,
+                        "ES_SOLUTION" => solution
+                    }
+                    h = HelperRun.new false
+                    h.run "ecosystem", "analyze-solution", JSON.generate(adef)
+                end
+            end
+        rescue => exception
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+    end
+
+
+    def runPhasePatch (commit, solution, test, task, ref="")
+
+        plan = JSON.parse("{ \"plan\": [ { \"commit\": \"#{commit}\", \"solution\": \"#{solution}\" } ] }")
+
+        ENV['ES_REF'] = ref;
+        ENV['ES_ROLE'] = 'patch';
+        ENV['ES_SOLUTION'] = solution;
+
+        n = Worker.new
+        n.test ( test )
+
+        start = Integer(task)
+        lines = 1
+
+        cmd = "undefined"
+
+        # patches/<commit>/<solution>
+        begin
+
+            plan['plan'].each do |item|
+
+                root = "#{@basePath}/patches/#{item['commit']}/#{item['solution']}"
+                if File.exist?(root) == false
+                    log "-- WARNING #{root} does not exist"
+                else
+
+                    if (test == false)
+
+                        envScript = "#{root}/environment.json"
+                        if File.exist?(envScript)
+                            envPush = PrepareEnvironment.new false
+                            envPush.addToEnv "#{envScript}"
+                        end
+
+                    end
+
+                    ENV.store('SCRIPT_PATH', root)
+
+                    cmd = "#{root}/patch.sh"
+                    if File.exist?(cmd)
+                      lines = n.run cmd, start, lines - 1, false, ref
+                    end
+                end
+            end
+        rescue => exception
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+    end
+
+    def log (msg)
+        puts msg
+        @log.info(msg)
+    end
+
+end

data/lib/canzea/registry.rb

@@ -0,0 +1,12 @@
+require 'json'
+require_relative 'config'
+require_relative 'canzea/core/registry'
+
+module Canzea
+
+    extraConfig = Canzea::config[:config_location] + "/config.json"
+    if File.exists?(extraConfig)
+        file = File.read(extraConfig)
+        Canzea::configure JSON.parse(file)
+    end
+end

data/lib/canzea/version.rb

@@ -0,0 +1,3 @@
+module Canzea
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: escli
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Canzea Technologies
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: net-sftp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: cri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Orchestrate the building of images based on defined ecosystem blueprints.
+email:
+- ikethecoder@canzea.com
+executables:
+- escli
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/compiler.xml"
+- ".idea/copyright/profiles_settings.xml"
+- ".idea/misc.xml"
+- ".idea/modules.xml"
+- ".idea/vcs.xml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/escli
+- bin/setup
+- escli.gemspec
+- lib/canzea/cli/canzea.rb
+- lib/canzea/cli/escli.rb
+- lib/canzea/commands/add-env.rb
+- lib/canzea/commands/apply-config.rb
+- lib/canzea/commands/config-git-commit.rb
+- lib/canzea/commands/ecosystem/ecosystem.rb
+- lib/canzea/commands/ecosystem/resources.rb
+- lib/canzea/commands/gen-user.rb
+- lib/canzea/commands/get-catalog.rb
+- lib/canzea/commands/login.rb
+- lib/canzea/commands/prepare-plan.rb
+- lib/canzea/commands/push-config.rb
+- lib/canzea/commands/register-metadata.rb
+- lib/canzea/commands/remote-bootstrap.rb
+- lib/canzea/commands/remote-run.rb
+- lib/canzea/commands/update-config.rb
+- lib/canzea/config.rb
+- lib/canzea/core/audit.rb
+- lib/canzea/core/prepare-environment.rb
+- lib/canzea/core/registry.rb
+- lib/canzea/core/ssh-base-cmd-class.rb
+- lib/canzea/core/template-runner.rb
+- lib/canzea/core/trace-component.rb
+- lib/canzea/core/trace-runner.rb
+- lib/canzea/environment.rb
+- lib/canzea/helper-run-class.rb
+- lib/canzea/plan-step-class.rb
+- lib/canzea/registry.rb
+- lib/canzea/version.rb
+homepage: http://www.canzea.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Canzea command line interface for orchestrating builds.
+test_files: []