escli 1.0.0

data/lib/canzea/commands/register-metadata.rb

@@ -0,0 +1,79 @@
+require 'json'
+require 'logger'
+require 'pathname'
+require 'canzea/helper-run-class'
+require 'canzea/core/trace-component'
+require 'canzea/core/prepare-environment'
+
+class RegisterMetadata
+    def initialize ()
+        @basePath = "#{Pathname.new(Canzea::config[:catalog_location]).realpath}/"
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+
+    def do (role, solution, test)
+
+        plan = JSON.parse("{ \"plan\": [ { \"role\": \"#{role}\", \"solution\": \"#{solution}\" } ] }")
+
+        n = Worker.new
+        n.test ( test )
+
+        lines = 1
+
+        cmd = "undefined"
+
+        begin
+
+            plan['plan'].each do |item|
+
+                root = "#{@basePath}/roles/#{item['role']}/#{item['solution']}"
+                if File.exist?(root) == false
+                    log "-- ERROR #{root} does not exist!"
+                    raise "#{root} does not exist!"
+                end
+
+                # Register the service with Consul, if consul is ready
+                # If metadata.json exists, then use the information to register
+                cmd = "#{@basePath}/roles/#{item['role']}/#{item['solution']}/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']
+                        }
+
+                        if (svc.has_key? "checks")
+                            adef[:check] = svc['checks'][0]
+                        end
+                        log "-- Registering Service: #{svc['name']}"
+                        log "--    #{adef.to_json}"
+                        h = HelperRun.new
+                        if test
+                            log "--  TEST ONLY"
+                        else
+                            h.run "consul", "register_service", JSON.generate(adef)
+                        end
+                    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/commands/remote-bootstrap.rb

@@ -0,0 +1,38 @@
+require "git"
+require "fileutils"
+require "pathname"
+require "canzea/core/ssh-base-cmd-class"
+
+class RemoteInit
+    def initialize ()
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+
+    def do (publicIp, privateKey)
+        cmd1 = "yum -y install git"
+
+        cmd2 = "(rm -rf ecosystem-catalog && git clone https://gitlab.com/canzea/ecosystem-catalog.git)"
+
+        cmd3 = 'find /root/ecosystem-catalog -name "*.sh" -exec chmod +x {} +'
+
+        cmd4 = '(cd /root/ecosystem-catalog && ./roles/workarounds/ruby/install.sh)'
+        cmd5 = '(cd /root/ecosystem-catalog && ./roles/workarounds/ruby-gems/install.sh)'
+        cmd6 = '(cd /root/ecosystem-catalog && ./roles/workarounds/sshd/configure.sh)'
+        cmd7 = '(cd /root/ecosystem-catalog && ./roles/workarounds/sshd/enable.sh)'
+        cmd8 = '(cd /root/ecosystem-catalog && ./roles/workarounds/root/install.sh)'
+        cmd9 = '(cd /root/ecosystem-catalog && ./roles/workarounds/image-bootstrap/install.sh)'
+
+        remote = RemoteCall.new
+
+        remote.exec publicIp, privateKey, cmd1, "1-9"
+        remote.exec publicIp, privateKey, cmd2, "2-9"
+        remote.exec publicIp, privateKey, cmd3, "3-9"
+        remote.exec publicIp, privateKey, cmd4, "4-9"
+        remote.exec publicIp, privateKey, cmd5, "5-9"
+        remote.exec publicIp, privateKey, cmd6, "6-9"
+        remote.exec publicIp, privateKey, cmd7, "7-9"
+        remote.exec publicIp, privateKey, cmd8, "8-9"
+        remote.exec publicIp, privateKey, cmd9, "9-9"
+    end
+
+end

data/lib/canzea/commands/remote-run.rb

@@ -0,0 +1,37 @@
+require "json"
+require "git"
+require "fileutils"
+require "pathname"
+require "canzea/core/ssh-base-cmd-class"
+
+class RemoteRun
+    def doWire(publicIp, privateKey, solution, action, args, ref="")
+      remote = RemoteCall.new
+      remote.exec publicIp, privateKey, "canzea --lifecycle=wire --raw --solution=#{solution} --action=#{action} --args='#{args}'", ref
+    end
+
+    def doTask(publicIp, privateKey, role, solution, task, ref="")
+      remote = RemoteCall.new
+      remote.exec publicIp, privateKey, "canzea --lifecycle=install --role=#{role} --task=#{task} --solution=#{solution}", ref
+    end
+
+    def do(publicIp, privateKey, role, solution, ref="")
+      remote = RemoteCall.new
+      remote.exec publicIp, privateKey, "canzea --lifecycle=install --role=#{role} --solution=#{solution}", ref
+    end
+
+    def doConfigure(publicIp, privateKey, role, solution, ref="")
+      remote = RemoteCall.new
+      remote.exec publicIp, privateKey, "canzea --lifecycle=configure --role=#{role} --solution=#{solution}", ref
+    end
+
+    def doCommand(publicIp, privateKey, command, ref="")
+      remote = RemoteCall.new
+      remote.exec publicIp, privateKey, command, ref
+    end
+
+    def test(publicIp, privateKey, role, solution, ref="")
+      remote = RemoteCall.new
+      remote.exec publicIp, privateKey, "canzea --lifecycle=install --role=#{role} --solution=#{solution} --test", ref
+    end
+end

data/lib/canzea/commands/update-config.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+class UpdateConfig
+
+    def do (role, solution, gitRoot)
+
+        steps = {}
+
+        if File.directory? "#{gitRoot}"
+            # write to configure the registration of the service
+            if (File.exists?("#{gitRoot}/configure.json"))
+                steps = JSON.parse(File.read("#{gitRoot}/configure.json"))
+            else
+                steps["steps"] = []
+            end
+
+            conf = {
+                :role => role,
+                :solution => solution
+            }
+            steps["steps"].push(conf)
+
+            File.open("#{gitRoot}/configure.json", 'w') { |file| file.puts(JSON.generate(steps)) }
+        end
+    end
+end

data/lib/canzea/config.rb

@@ -0,0 +1,35 @@
+require 'pathname'
+
+module Canzea
+
+  # Configuration defaults
+  @config = {
+              :log_level => "verbose",
+              :config_location => "#{Dir.home}/.ecosystem-catalog",
+              :catalog_location => "#{Dir.home}/.ecosystem-catalog/catalog",
+              :catalog_git => "https://gitlab.com/canzea/ecosystem-catalog.git",
+              :catalog_branch => "develop",
+              :git_repo => "/opt/cloud-profile",
+              :logging_root => Dir.home,
+              :pwd => Dir.pwd,
+              :consul_tls => false,
+              :consul_tls_ca_file => "/etc/consul.d/ssl/ca.cert",
+              :consul_tls_cert_file => "/etc/consul.d/ssl/consul.cert",
+              :consul_tls_key_file => "/etc/consul.d/ssl/consul.key",
+              :vault_tls_cert_file => "/etc/consul.d/ssl/vault.cert",
+              :vault_tls_key_file => "/etc/consul.d/ssl/vault.key",
+              :track_changes_in_git => false,
+              :canzea_platform_uri => "https://canzea.com/console-app"
+            }
+  @valid_config_keys = @config.keys
+
+  # Configure through hash
+  def self.configure(opts = {})
+    opts.each {|k,v| @config[k.to_sym] = v if @valid_config_keys.include? k.to_sym}
+  end
+
+  def self.config
+    @config
+  end
+
+end

data/lib/canzea/core/audit.rb

@@ -0,0 +1,86 @@
+require 'json'
+require 'open3'
+require 'stringio'
+require 'logger'
+
+
+class Audit
+    def initialize (_raw)
+        @raw = _raw;
+    end
+
+    def start (id, cmd)
+        self.log( id, cmd, "start", "", 0, "")
+    end
+
+    def complete (id, cmd, status, msecs, result)
+	    self.log( id, cmd, "complete", status, msecs, result)
+    end
+
+    def status (id, cmd, status, msecs, result)
+        data = {
+            "message" => {
+                "id" => id,
+                "cmd" => cmd,
+                "task" => "status",
+                "status" => status,
+                "elapsed" => msecs,
+                "result" => result
+            }
+        }
+        context = {
+            "step" => ENV['ES_STEP'],
+            "ref" => ENV['ES_REF'],
+            "role" => ENV['ES_ROLE'],
+            "solution" => ENV['ES_SOLUTION'],
+            "action" => ENV['ES_ACTION']
+        }
+        data['message'][:context] = context
+
+        pputs data.to_json
+        File.open(Canzea::config[:logging_root] + '/audit.log', 'a') { |file| file.puts(data.to_json) }
+    end
+
+    def log (id, cmd, task, status, msecs, result)
+
+        data = {
+            "message" => {
+                "id" => id,
+                "cmd" => cmd,
+                "task" => task,
+                "status" => status,
+                "elapsed" => msecs,
+                "result" => result
+            }
+        }
+        summary = {
+            "message" => {
+                "id" => id,
+                "cmd" => cmd,
+                "task" => task,
+                "status" => status,
+                "elapsed" => msecs
+            }
+        }
+        context = {
+            "step" => ENV['ES_STEP'],
+            "ref" => ENV['ES_REF'],
+            "role" => ENV['ES_ROLE'],
+            "solution" => ENV['ES_SOLUTION'],
+            "action" => ENV['ES_ACTION']
+        }
+        data['message'][:context] = context
+        summary['message'][:context] = context
+
+        pputs summary.to_json
+
+        File.open(Canzea::config[:logging_root] + '/audit.log', 'a') { |file| file.puts(data.to_json) }
+    end
+
+    def pputs (s)
+        if (@raw == false)
+            puts "#{s}"
+        end
+    end
+
+end

data/lib/canzea/core/prepare-environment.rb

@@ -0,0 +1,194 @@
+require 'json'
+require 'logger'
+require 'net/http'
+require "canzea/core/trace-runner"
+require "canzea/core/registry"
+
+
+class PrepareEnvironment
+    def initialize (_raw = false)
+        @raw = _raw;
+    end
+
+    def addToEnv (envFile)
+        log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+
+        r = Registry.new
+
+        file = File.read(envFile)
+
+        serviceLookups = JSON.parse(file)
+
+        if (serviceLookups.has_key?('environment'))
+            serviceLookups['environment'].each do |svc|
+
+              pputs "-- Setting...#{svc['name']}"
+              log.info("Setting: " + svc['name'])
+              ENV.store(svc['name'], svc['value'])
+            end
+        end
+
+        serviceLookups['keyvalues'].each do |svc|
+
+          pputs("-- Looking up...#{svc['name']}")
+
+          uri = URI.parse(ENV["CONSUL_URL"] + '/v1/kv/' + svc['name'])
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          if (Canzea::config[:consul_tls])
+              pemCert = File.read(Canzea::config[:consul_tls_cert_file])
+              pemKey = File.read(Canzea::config[:consul_tls_key_file])
+
+              http.use_ssl = true
+              http.ca_file = Canzea::config[:consul_tls_ca_file]
+              http.cert = OpenSSL::X509::Certificate.new(pemCert)
+              http.key = OpenSSL::PKey::RSA.new(pemKey)
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              # http.set_debug_output($stdout)
+              http.ssl_version = :SSLv23
+          end
+          request = Net::HTTP::Get.new(uri.request_uri)
+          resp = http.request(request)
+
+          if Integer(resp.code) != 200
+            log.warn("KEY VALUE NOT FOUND! " + svc['name'])
+            puts "-- KEY VALUE NOT FOUND! " + svc['name']
+            abort("Problem, response code #{resp.code}")
+          end
+
+          result = JSON.parse(resp.body)
+          s = Base64.decode64(result[0]["Value"])
+
+          if (s.nil? == false)
+            # puts s
+
+            key = "" + svc['name'].upcase
+            key = key.gsub(/\./, '').gsub(/-/, '_').gsub(/\//, '_')
+            log.info("Setting: " + key + " : " + s)
+            ENV.store(key, s)
+          else
+            log.warn("KEY VALUE NOT FOUND! " + svc['name'])
+            pputs "-- KEY VALUE NOT FOUND! " + svc['name']
+            abort()
+          end
+        end
+
+
+        serviceLookups['services'].each do |svc|
+
+          pputs "-- Looking up...#{svc['name']}"
+
+          uri = URI.parse(ENV["CONSUL_URL"] + '/v1/catalog/service/' + svc['name'])
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          if (Canzea::config[:consul_tls])
+              pemCert = File.read(Canzea::config[:consul_tls_cert_file])
+              pemKey = File.read(Canzea::config[:consul_tls_key_file])
+
+              http.use_ssl = true
+              http.ca_file = Canzea::config[:consul_tls_ca_file]
+              http.cert = OpenSSL::X509::Certificate.new(pemCert)
+              http.key = OpenSSL::PKey::RSA.new(pemKey)
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              # http.set_debug_output($stdout)
+              http.ssl_version = :SSLv23
+          end
+          request = Net::HTTP::Get.new(uri.request_uri)
+          resp = http.request(request)
+
+          services = JSON.parse(resp.body)
+
+          if (services.nil? == false)
+
+            services.each { | s |
+
+                key = "" + svc['name'].upcase + "_ADDRESS"
+                key = key.gsub(/\./, '')
+                log.info("Setting: " + key + " : " + s["ServiceAddress"])
+                ENV.store(key, s["ServiceAddress"])
+
+                key = "" + svc['name'].upcase + "_PORT"
+                key = key.gsub(/\./, '')
+                log.info("Setting: " + key + " : " + String(s["ServicePort"]))
+                ENV.store(key, String(s["ServicePort"]))
+
+                key = "" + svc['name'].upcase + "_URL"
+                key = key.gsub(/\./, '')
+                val = "http://" + s["ServiceAddress"] + ":" + String(s["ServicePort"])
+                log.info("Setting: " + key + " : " + val)
+                ENV.store(key, val)
+            }
+          else
+            log.warn("SERVICE NOT FOUND! " + svc['name'])
+            pputs "-- SERVICE NOT FOUND! " + svc['name']
+            abort()
+          end
+        end
+
+        serviceLookups['secrets'].each do |svc|
+
+          pputs "-- Looking up secret...#{svc['name']}"
+
+          uri = URI.parse(ENV["VAULT_URL"] + '/v1/secret/' + svc['name'])
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          if (Canzea::config[:consul_tls])
+
+              pemCert = File.read(Canzea::config[:vault_tls_cert_file])
+              pemKey = File.read(Canzea::config[:vault_tls_key_file])
+
+              http.use_ssl = true
+              http.ca_file = Canzea::config[:consul_tls_ca_file]
+              http.cert = OpenSSL::X509::Certificate.new(pemCert)
+              http.key = OpenSSL::PKey::RSA.new(pemKey)
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              # http.set_debug_output($stdout)
+              http.ssl_version = :SSLv23
+          end
+
+          request = Net::HTTP::Get.new(uri.request_uri)
+
+          request['X-Vault-Token'] = ENV["VAULT_TOKEN"]
+          request['Content-type'] = 'application/json'
+
+          resp = http.request(request)
+
+          # puts resp.body
+
+          if (Integer(resp.code) == 200)
+
+            data = JSON.parse(resp.body)
+
+            s = data['data']
+            s.each do |k|
+              key = "" + svc['name'].upcase + "_" + k[0].upcase
+              key = key.gsub(/\./, '').gsub(/-/, '_').gsub(/\//, '_')
+
+              log.info("Setting: " + key)
+              if k[1].is_a? String
+                  ENV.store(key, k[1])
+              end
+            end
+          else
+            log.warn( "SECRET NOT FOUND! " + svc['name'])
+            log.warn( "ERROR FROM VAULT " + resp.body)
+            pputs "-- SECRET NOT FOUND! " + svc['name']
+            pputs "-- ERROR FROM VAULT " + resp.body
+            abort()
+          end
+        end
+    end
+
+    def print ()
+        ENV.each_pair { |name,value|
+            puts name + " = " + value
+        }
+    end
+
+    def pputs (s)
+        if (@raw == false)
+            puts "-- #{s}"
+        end
+    end
+
+end