escli 1.0.0

data/lib/canzea/commands/ecosystem/resources.rb

@@ -0,0 +1,82 @@
+
+=begin
+
+curl -v -X GET -H "Content-Type: application/json" https://canzea.com/console-app/api/api/v2/saasexpress/ecosystem
+
+Canzea::config[:canzea_platform_uri] + "/api/v2/saasexpress/ecosystem"
+
+escli ecosystem resource test.yaml intg-0
+
+escli resource plus test.yaml prod-1
+
+escli resource apply f67c70b0-2706-48b5-ac4b-c76eeb72effe
+
+=end
+
+require 'net/http'
+require 'json'
+require 'canzea/commands/login'
+
+class Resources
+    def plus(manifest, segment)
+        token = Login.new.get()
+
+        esFile = Canzea::config[:config_location] + '/.scope'
+        es = JSON.parse(File.read(esFile))
+
+        puts "Using #{es['id']}"
+
+        uri = URI(Canzea::config[:canzea_platform_uri] + "/api/v2/saasexpress/buildingblocks/#{es['id']}/buildingblocks/configure")
+
+        config = File.read(manifest)
+
+        req = Net::HTTP::Post.new(uri, 'Authorization' => "Bearer #{token}", 'Content-Type' => 'application/json')
+        req.body = {config: config, segment: segment, resources: []}.to_json
+
+        https = Net::HTTP.new(uri.hostname,uri.port)
+        https.use_ssl = uri.instance_of? URI::HTTPS
+
+        res = https.request(req)
+
+        case res
+            when Net::HTTPSuccess, Net::HTTPRedirection
+                es = JSON.parse(res.body)
+                puts JSON.pretty_generate(es)
+                puts "Run 'escli resource apply #{es['id']}'"
+            else
+                puts "Error #{res}"
+                puts res.body
+        end
+
+    end
+
+    def apply(resourceID)
+        token = Login.new.get()
+
+        esFile = Canzea::config[:config_location] + '/.scope'
+        es = JSON.parse(File.read(esFile))
+
+        uri = URI(Canzea::config[:canzea_platform_uri] + "/api/v2/saasexpress/resources/plus/#{es['id']}/#{resourceID}")
+
+        puts "Calling #{uri}"
+
+        req = Net::HTTP::Post.new(uri, 'Authorization' => "Bearer #{token}", 'Content-Type' => 'application/json')
+        req.body = {}.to_json
+
+        https = Net::HTTP.new(uri.hostname,uri.port)
+        https.use_ssl = uri.instance_of? URI::HTTPS
+
+        res = https.request(req)
+
+        case res
+            when Net::HTTPSuccess, Net::HTTPRedirection
+                es = JSON.parse(res.body)
+                puts JSON.pretty_generate(es)
+                puts "Successfully scheduled.  Batch reference # #{es['ref']}."
+            else
+                puts "Error #{res}"
+                puts res.body
+        end
+
+    end
+end

data/lib/canzea/commands/gen-user.rb

@@ -0,0 +1,22 @@
+require "git"
+require "fileutils"
+require "pathname"
+require "canzea/helper-run-class"
+
+class GenUser
+    def do(name)
+        puts "Generating #{name}"
+
+        home = "/home/#{name}"
+        key = "general"
+
+        plans = [
+            {:solution => "users", :action => "add-user", :parameters => { "name" => name }},
+            {:solution => "users", :action => "new-key", :parameters => { "name" => name, "home" => home, "key" => key }},
+        ]
+
+        helper = HelperRun.new(false)
+        helper.runPlan(plans)
+
+    end
+end

data/lib/canzea/commands/get-catalog.rb

@@ -0,0 +1,46 @@
+require "git"
+require "fileutils"
+require "logger"
+require "pathname"
+
+
+class GetCatalog
+    def initialize ()
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+    def do(tag = nil)
+        catalogLocation = Canzea::config[:catalog_location]
+        FileUtils.rm_rf "#{catalogLocation}"
+        FileUtils.mkdir_p "#{catalogLocation}"
+        catalogLocation = Pathname.new(catalogLocation).parent().realpath
+        g = Git.clone(Canzea::config[:catalog_git], "catalog", :path => catalogLocation)
+        if (tag != nil)
+            puts "-- (RESET) For tag #{tag}"
+            g.checkout(tag)
+        else
+            g.checkout(g.branch(Canzea::config[:catalog_branch]))
+        end
+        branch = g.current_branch
+        puts "-- (RESET) Branch '#{branch}' Commit #{g.log[0]}"
+        puts "-- (RESET) Source #{catalogLocation}/catalog"
+    end
+
+    def state()
+        g = Git.open(Canzea::config[:catalog_location])
+
+        branch = g.current_branch
+        commit = g.log[0]
+        g.tags.each do | c |
+            # Doesn't seem to link tag to the branch so excluding for now
+            # ENV.store('CATALOG_TAG', c.name)
+            # puts "-- Tag #{c.name}"
+        end
+
+        ENV.store('CATALOG_BRANCH', branch)
+        ENV.store('CATALOG_COMMIT', "#{g.log[0]}")
+
+        # puts "-- Branch '#{ENV['CATALOG_BRANCH']}' Commit #{ENV['CATALOG_COMMIT']}"
+
+    end
+
+end

data/lib/canzea/commands/login.rb

@@ -0,0 +1,50 @@
+
+=begin
+Login should use an ecosystem.
+
+curl -v -X POST -H "Content-Type: application/json" -d '{"name":"","password":""}' https://canzea.com/console-app/api/x/user/login
+
+Canzea::config[:canzea_platform_uri] + "/api/x/user/login"
+=end
+
+require 'net/http'
+require 'json'
+
+class Login
+    def do(name, password)
+        credFile = "#{Dir.home}/.canzearc"
+
+        uri = URI(Canzea::config[:canzea_platform_uri] + "/api/x/user/login")
+
+        req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+        req.body = {name: name, password: password}.to_json
+
+        https = Net::HTTP.new(uri.hostname,uri.port)
+        https.use_ssl = uri.instance_of? URI::HTTPS
+
+        res = https.request(req)
+
+        case res
+            when Net::HTTPSuccess, Net::HTTPRedirection
+                token = JSON.parse(res.body)
+
+                File.open(credFile, 'w') { |file| file.write(token['token']) }
+                puts "Login successful.  Authorization cached."
+            else
+              puts res.body
+        end
+
+    end
+
+    def logout()
+        credFile = "#{Dir.home}/.canzearc"
+        File.delete(credFile)
+        puts "Authorization cache cleared."
+    end
+
+    def get()
+        credFile = "#{Dir.home}/.canzearc"
+        token = File.read(credFile)
+        return token
+    end
+end

data/lib/canzea/commands/prepare-plan.rb

@@ -0,0 +1,82 @@
+require 'json'
+require 'base64'
+require 'yaml'
+require 'canzea/config'
+require 'canzea/plan-step-class'
+require 'canzea/commands/remote-run'
+require 'canzea/commands/add-env'
+
+class PreparePlan
+    def initialize ()
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+        @basePath = "#{Pathname.new(Canzea::config[:catalog_location]).realpath}"
+    end
+
+    def doPatch (paramsString, test, privateKey, serverBase, serverNumber)
+
+        publicIp = File.read("#{Canzea::config[:pwd]}/vps-#{serverBase}-#{serverNumber}.json")
+        publicIp.strip!
+
+        params = JSON.parse(paramsString)
+
+        patches = Base64.decode64(params["patches"])
+        params['patches'] = JSON.parse(patches)
+
+        params['patches'].each do | patch |
+            RemoteRun.new.doCommand publicIp, privateKey, patch["command"]
+        end
+    end
+
+    # Read the blueprint instructions and prepare plan for a particular segment
+    def do (blueprint, segment, step, task, test, privateKey, serverBase, serverNumber)
+        planStep = PlanStep.new
+
+        log "Processing configure.json for #{segment} in #{blueprint} from #{@basePath}"
+
+        instructions = YAML.load_file("#{@basePath}/blueprints/#{blueprint}/instruction.yml")
+        segment = instructions['instructions']['segments'][segment]
+
+        log segment['abbreviation']
+
+        first = true
+        index = 1
+        segment['image'].each { |item|
+            if item.start_with?("step:")
+                parts = item.split(':')
+
+                if (index < Integer(step))
+                    log "[#{index.to_s.rjust(2, "0")}] #{item} SKIPPING"
+                    msg = { "message" => { "task" => "skip", "context" => { "step" => index } } }
+                    puts msg.to_json
+                else
+
+                    log "[#{index.to_s.rjust(2, "0")}] #{item}"
+                    publicIp = File.read("#{Canzea::config[:pwd]}/vps-#{serverBase}-#{serverNumber}.json")
+                    publicIp.strip!
+                    if (test == false)
+                        if (task == nil)
+                            RemoteRun.new.do publicIp, privateKey, parts[1], parts[2], index.to_s.rjust(2, "0")
+                        else
+                            RemoteRun.new.doTask publicIp, privateKey, parts[1], parts[2], task, index.to_s.rjust(2, "0")
+                        end
+                        # Keep track of what we have done; parsing the response and looking at the JSON
+                    else
+                        RemoteRun.new.test publicIp, privateKey, parts[1], parts[2], index.to_s.rjust(2, "0")
+                    end
+
+                    if first == true
+                        # task is only relevant for the first invocation
+                        task = nil
+                        first = false
+                    end
+                end
+                index = index + 1
+            end
+        }
+    end
+
+    def log (msg)
+        puts "-- #{msg}"
+        @log.info(msg)
+    end
+end

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

@@ -0,0 +1,283 @@
+
+require 'git'
+require 'json'
+require 'fileutils'
+require 'logger'
+require 'canzea/config'
+
+# canzea --lifecycle=wire --solution=gogs --action=push-content --args='{"file":"metadata.json","path":"test/a/metadata.json", "comment":"V1.0"}'
+# canzea --util=push-config git@165.227.87.135:root/ecosystem.git "Latest Input" --args='{"files":[{"file":"metadata.json","path":"test/a/metadata.json"}]}'
+
+# PushConfig.new.write "Test", "nr-global.flow", "new content and more and more"
+
+# PushConfig.new.cp "Another bit of file", "nr-global.flow", "node-red/nr-global.flow"
+
+
+class PushConfig
+    def initialize (_relPath = "instances/#{ENV['HOSTNAME']}/")
+        @relPath = _relPath
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+
+    def cat(filePath)
+        write filePath, File.read(filePath)
+    end
+
+    def cp(filePath, destPath)
+        if File.directory?(filePath)
+            Dir.foreach(filePath) { |x|
+                if x == '.' or x == '..' or x.start_with?('.')
+                else
+                    if File.directory?("#{filePath}/#{x}")
+                        cp "#{filePath}/#{x}", "#{destPath}/#{x}"
+                    else
+                        write "#{destPath}/#{x}", File.read("#{filePath}/#{x}")
+                    end
+                end
+            }
+        else
+            write destPath, File.read(filePath)
+        end
+    end
+
+    def backupAndRemove(filePath)
+        backup(filePath)
+        rm(filePath)
+    end
+
+    def backup(filePath)
+        path = "ecosystems/#{ENV['ECOSYSTEM']}/#{@relPath}#{filePath}"
+
+        folder = "sc"
+        if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+          folder = "_working"
+        end
+
+        if File.exists? folder
+            g = Git.init(folder)
+        else
+            if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+                g = Git.clone(ENV['ECOSYSTEM_CONFIG_GIT'], folder, :path => '.')
+            else
+                g = Git.init(folder)
+            end
+        end
+
+        puts "Exists? #{folder}/#{path}"
+        if File.exists? "#{folder}/#{path}"
+            numb = 1
+            bkup = "#{folder}/#{path}.archived"
+            while File.exists? "#{bkup}#{numb}"
+                numb = numb + 1
+            end
+            puts "Backed up to #{bkup}#{numb}"
+            File.write "#{bkup}#{numb}", File.read("#{folder}/#{path}");
+
+            g.add("#{path}.archived#{numb}")
+        end
+    end
+
+    def write(filePath, contents)
+
+        path = "ecosystems/#{ENV['ECOSYSTEM']}/#{@relPath}#{filePath}"
+
+        begin
+            folder = "sc"
+            if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+              folder = "_working"
+            end
+
+
+            if File.exists? folder
+                g = Git.init(folder)
+            else
+                if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+                    g = Git.clone(ENV['ECOSYSTEM_CONFIG_GIT'], folder, :path => '.')
+                else
+                    g = Git.init(folder)
+                end
+            end
+            FileUtils.mkdir_p File.dirname("#{folder}/#{path}")
+
+            pth = File.expand_path "#{folder}/#{path}"
+
+            @log.info "Writing to: #{pth}"
+
+            open("#{folder}/#{path}", 'w') { |f|
+              f.puts contents
+            }
+
+            g.add("#{path}")
+
+        rescue => exception
+            @log.error("PushConfig Failed")
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+
+    end
+
+    def rm(filePath)
+        path = "ecosystems/#{ENV['ECOSYSTEM']}/#{@relPath}#{filePath}"
+
+        begin
+            folder = "sc"
+            if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+              folder = "_working"
+            end
+
+            if File.exists? folder
+                g = Git.init(folder)
+            else
+                g = Git.clone(ENV['ECOSYSTEM_CONFIG_GIT'], folder, :path => '.')
+            end
+
+            if File.directory? "#{folder}/#{path}"
+                puts "DELETE DIRECTORY: #{folder}/#{path}"
+                FileUtils.rmdir_p File.dirname("#{folder}/#{path}")
+
+                g.add("#{path}")
+
+            else
+                if File.exists? "#{folder}/#{path}"
+                    puts "DELETE FILE: #{folder}/#{path}"
+                    FileUtils.rm_f "#{folder}/#{path}"
+                    g.remove("#{path}")
+                end
+            end
+        rescue => exception
+            @log.error("PushConfig Failed")
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+
+    end
+
+    def commit(comment)
+        folder = "sc"
+        if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+          folder = "_working"
+        else
+          return
+        end
+
+        begin
+            count = 0
+
+
+            g = Git.init(folder)
+
+            begin
+                g.chdir do
+                  g.status.changed.each do |file|
+                        count = count +1
+                  end
+                  g.status.added.each do |file|
+                        count = count +1
+                  end
+                  g.status.deleted.each do |file|
+                        count = count +1
+                  end
+                end
+            rescue => exception_ignore
+                count = 1
+            end
+
+            if count == 0
+              log "No changes"
+            else
+              log "#{count} changes committed."
+              g.commit(comment)
+
+              if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+                  log "Pushing changes to SCM."
+                  g.push
+              end
+            end
+
+            begin
+                if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+                  log "Removing #{folder}"
+                  FileUtils.rm_rf(folder)
+                end
+            rescue => exception
+                @log.error("PushConfig Failed")
+                @log.error(exception.backtrace)
+                @log.error(exception.to_s)
+            end
+
+        rescue => exception
+            @log.error("PushConfig Failed")
+            @log.error(exception.backtrace)
+            @log.error(exception.to_s)
+            abort()
+        end
+    end
+
+    def do(url, comment, params)
+        begin
+
+            # "git@#{ENV["GOGS_ADDRESS"]}:root/ecosystem.git"
+
+            folder = "sc"
+            if ENV.has_key? 'ECOSYSTEM_CONFIG_GIT'
+              folder = "_working"
+            end
+
+            FileUtils.rm_rf(folder)
+
+            g = Git.clone(url, folder, :path => '.')
+
+            params['files'].each { | f |
+                file = f['file']
+
+                path = f['path']
+
+                FileUtils.mkdir_p File.dirname("#{folder}/#{path}")
+
+                open("#{folder}/#{path}", 'w') { |f|
+                  f.puts File.read(file)
+                }
+                g.add("#{path}")
+            }
+
+
+            count = 0
+            g.chdir do
+              g.status.changed.each do |file|
+                    count = count +1
+              end
+              g.status.added.each do |file|
+                    count = count +1
+              end
+              g.status.deleted.each do |file|
+                    count = count +1
+              end
+            end
+
+
+            if count == 0
+              log "No changes"
+            else
+              log "#{count} changes committed."
+              g.commit(comment)
+
+              log "Pushing changes to SCM."
+              g.push
+              log "Changes pushed"
+            end
+        rescue => exception
+            @log.error("PushConfig Failed")
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
+        end
+    end
+
+    def log (msg)
+        puts msg
+        @log.info(msg)
+    end
+end