escli 1.0.0

data/lib/canzea/cli/escli.rb

@@ -0,0 +1,207 @@
+require 'cri'
+require 'fileutils'
+require 'pathname'
+require 'git'
+require 'io/console'
+require "canzea/config"
+require "canzea/version"
+require "canzea/environment"
+require "canzea/helper-run-class"
+require "canzea/plan-step-class"
+require "canzea/core/trace-component"
+require "canzea/core/ssh-base-cmd-class"
+require "canzea/core/template-runner"
+require "canzea/commands/login"
+require "canzea/commands/ecosystem/ecosystem"
+require "canzea/commands/ecosystem/resources"
+
+
+=begin
+
+escli login
+escli logout
+escli ecosystem list
+escli ecosystem set 23432894382932
+escli resource plus test.yaml prod-1
+escli resource apply f67c70b0-2706-48b5-ac4b-c76eeb72effe
+
+
+escli workspace list
+
+
+escli ecosystem create/destroy
+escli workspace build
+escli block install
+escli block configure
+escli project add
+
+escli resource get block gocd/docker
+
+escli resource list
+escli resource check
+escli resource plus
+escli resource minus
+
+escli job submit
+
+escli ecosystem set 23432894382932
+escli ecosystem get 23432894382932
+
+All “helpers” have a GET and LIST
+
+=end
+
+module Canzea
+
+  root_cmd = Cri::Command.define do
+
+      name        'escli'
+      usage       'escli [options]'
+      summary     'escli cli'
+      description 'Canzea Ecosystem command line interface.'
+
+      flag   :h,  :help,  'show help for this command' do |value, cmd|
+        puts cmd.help
+        exit 0
+      end
+
+      flag :v, :version, 'Version' do |value, cmd|
+        puts "ES CLI: v#{Canzea::VERSION}"
+      end
+
+      flag nil, :reset, 'Refresh catalog to latest'
+      flag nil, :fv, 'Show version and the catalog version'
+
+      option nil, :config, 'Config', argument: :required
+      option nil, :catalogTag, 'Specific tag of the catalog', argument: :required
+
+      run do |opts, args, cmd|
+
+        test = opts.fetch(:test, false)
+
+        if opts[:config]
+            file = File.read(opts[:config])
+            Canzea::configure JSON.parse(file)
+        end
+
+        extraConfig = Canzea::config[:config_location] + "/config.json"
+        if File.exists?(extraConfig)
+            if (opts[:verbose])
+                puts "-- Reading #{extraConfig}"
+            end
+            file = File.read(extraConfig)
+            Canzea::configure JSON.parse(file)
+        end
+
+        if File.exists?(Canzea::config[:catalog_location]) == false
+            GetCatalog.new.do(opts.fetch(:catalogTag, nil));
+        end
+
+        if (opts[:reset])
+            GetCatalog.new.do(opts.fetch(:catalogTag, nil));
+        end
+
+        GetCatalog.new.state
+
+        if (opts[:fv])
+            puts "ES CLI: v#{Canzea::VERSION}"
+
+            puts "Catalog: #{ENV['CATALOG_BRANCH']} ( #{ENV['CATALOG_COMMIT']} )"
+        end
+
+
+        args.each do |arg|
+          puts "Publishing #{arg}…"
+        end
+      end
+
+  end
+
+  root_cmd.define_command do
+    name        'logout'
+    usage       'logout [options]'
+    summary     'Clears credentials'
+    description 'This command clears credentials.'
+
+    run do |opts, args, cmd|
+        Login.new.logout
+    end
+  end
+
+
+  root_cmd.define_command('login') do
+    name        'login'
+    usage       'login'
+    summary     'Authenticates and stores token.'
+
+    run do |opts, args, cmd|
+
+        print "Enter your username: "
+        username = STDIN.gets.chomp
+
+        print "Enter your password: "
+        password = STDIN.noecho(&:gets).chomp
+        puts ""
+        Login.new.do username, password
+    end
+  end
+
+  escmd = root_cmd.define_command('ecosystem') do
+    name        'ecosystem'
+    usage       'ecosystem [options]'
+    summary     'Manage an ecosystem (create, destroy, list, set)'
+
+    run do |opts, args, cmd|
+    end
+  end
+
+  escmd.define_command('set') do
+    usage       'set [id]'
+    summary     'Sets the ecosystem ID.'
+
+    run do |opts, args, cmd|
+        Ecosystem.new.set args[0]
+    end
+  end
+
+  escmd.define_command('list') do
+    usage       'list'
+    summary     'List all ecosystems for account'
+    run do |opts, args, cmd|
+        Ecosystem.new.list
+    end
+  end
+
+  escmd.define_command('create') do
+    usage       'create [options]'
+    summary     'Create an ecosystem'
+  end
+
+  escmd.define_command('destroy') do
+    usage       'destroy [options]'
+    summary     'Destroy an ecosystem'
+  end
+
+  escmd.define_command('info') do
+    usage       'info [options]'
+    summary     'Info about currently set ecosystem'
+  end
+
+  root_cmd.define_command('resource') do
+    name        'resource'
+    usage       'resource plus [manifest File] [segment]'
+    summary     'Apply resources to the environment'
+
+    run do |opts, args, cmd|
+        if args[0] == 'plus'
+            Resources.new.plus args[1], args[2]
+        end
+        if args[0] == 'apply'
+            Resources.new.apply args[1]
+        end
+    end
+  end
+
+  root_cmd.run(ARGV)
+
+end

data/lib/canzea/commands/add-env.rb

@@ -0,0 +1,64 @@
+require 'json'
+require 'logger'
+require 'canzea/plan-step-class'
+
+class AddEnv
+    def initialize (_raw = false)
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+        @raw = _raw
+    end
+
+    def add (key, value)
+        extraConfig = Canzea::config[:config_location] + "/env.json"
+        envs = loadFile()
+        envs["vars"][key] = value
+        File.write(extraConfig, JSON.generate(envs))
+    end
+
+    def addSecret (key, value)
+        extraConfig = Canzea::config[:config_location] + "/env.json"
+        envs = loadFile()
+        envs['secrets'][key] = value
+        File.write(extraConfig, JSON.generate(envs))
+    end
+
+    def loadFile()
+        extraConfig = Canzea::config[:config_location] + "/env.json"
+        if File.exists?(extraConfig)
+            file = File.read(extraConfig)
+            envs = JSON.parse(file)
+        else
+            envs = {"vars"=>{}, "secrets"=>{}}
+        end
+        return envs
+    end
+
+    def injectEnvironmentVariables()
+        extraConfig = Canzea::config[:config_location] + "/env.json"
+        @log.info "Looking at for env vars: #{extraConfig}"
+        if File.exists?(extraConfig)
+            pputs "-- Reading #{extraConfig}"
+            file = File.read(extraConfig)
+            envs = JSON.parse(file)
+            envs['vars'].keys.each { | key |
+                val = envs['vars'][key]
+                pputs "--    #{key} == #{val}"
+                @log.info "Setting: #{key} == #{val}"
+                ENV.store(key, val)
+            }
+            envs['secrets'].keys.each { | key |
+                val = envs['secrets'][key]
+                pputs "--    #{key} == XXXXXX"
+                @log.info "Setting: #{key} == XXXXXXX"
+                ENV.store(key, val)
+            }
+        end
+    end
+
+    def pputs (s)
+        if (@raw == false)
+            puts "#{s}"
+        end
+    end
+
+end

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

@@ -0,0 +1,50 @@
+require 'json'
+require 'logger'
+require 'canzea/commands/add-env'
+require 'canzea/plan-step-class'
+
+class ApplyConfig
+    def initialize ()
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+
+    def do (gitRoot, test = false, stepNum = nil, task = nil)
+        ps = PlanStep.new
+
+        # Read the configuration file and make calls out to run
+
+        log "Processing #{gitRoot}/configure.json"
+
+        steps = JSON.parse(File.read("#{gitRoot}/configure.json"))
+
+
+        index = 1
+        steps["steps"].each { | step |
+
+            # Needs to be after each step because new env vars could be set (i.e./ CONSUL_URL)
+            AddEnv.new.injectEnvironmentVariables()
+
+            ref = "Step #{index.to_s.rjust(2, "0")} / #{steps['steps'].length}"
+
+            role = step['role']
+            solution = step['solution']
+
+            ENV['ES_STEP'] = "#{index}";
+
+            if (stepNum == nil or index >= Integer(stepNum))
+                log "  [#{ref}] Configure for #{role} and #{solution}"
+                ps.runPhaseConfigure role, solution, test, (task == nil ? 1:task), ref
+                task = 1
+            else
+                log "  [#{ref}] Configure for #{role} and #{solution} SKIP"
+            end
+            index = index + 1
+        }
+    end
+
+    def log (msg)
+        puts msg
+        @log.info(msg)
+    end
+
+end

data/lib/canzea/commands/config-git-commit.rb

@@ -0,0 +1,78 @@
+require "git"
+require "fileutils"
+require "pathname"
+
+class ConfigGitCommit
+    def initialize ()
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
+
+    def do(gitRoot, gitUri, sourcePath, template, basePath, parameters)
+        begin
+            log "Using basePath #{basePath}"
+
+            if (File.exists?(gitRoot) == false)
+                log "Cloning git repository #{gitUri}"
+                Git.config do |config|
+                  config.ssh_key = "#{Dir.home}/.ssh/id_rsa"
+                end
+                g = Git.clone(gitUri, "", :path => gitRoot)
+            end
+
+            # if file exists on file system and does not exist in gitRoot, then commit the "oem" file
+
+            if (File.exists?(sourcePath))
+                dest = "#{gitRoot}/#{basePath}#{Pathname.new(sourcePath).realpath}"
+            else
+                dest = "#{gitRoot}/#{basePath}#{sourcePath}"
+            end
+            log "Writing to #{dest}"
+
+            if (File.exist?(dest) == false and File.exist?(sourcePath))
+                FileUtils.mkdir_p Pathname.new(dest).dirname
+                FileUtils.cp sourcePath, dest
+
+                log "Recording in repo the default file first: #{sourcePath}"
+                if (Canzea::config[:track_changes_in_git])
+                    g = Git.init(gitRoot)
+                    g.add(:all=>true)
+                    g.commit("Original default #{sourcePath}")
+                end
+            end
+
+            if template
+                log "Processing template #{template}"
+                FileUtils.mkdir_p Pathname.new(sourcePath).dirname
+                t = Template.new
+                t.processAndWriteToFile template, sourcePath, parameters
+            end
+            FileUtils.mkdir_p Pathname.new(dest).dirname
+            FileUtils.cp sourcePath, dest, :verbose => true
+
+            if (Canzea::config[:track_changes_in_git])
+                g = Git.init(gitRoot)
+                g.add(:all=>true)
+                log "#{g.status.changed.size() + g.status.added.size()}"
+                if (g.status.changed.size() > 0 or g.status.added.size() > 0)
+                    g.commit("Config update #{sourcePath}")
+                end
+            end
+
+            if (Canzea::config[:track_changes_in_git])
+                g = Git.init(gitRoot)
+                g.push
+            end
+        rescue => exception
+            @log.error("ConfigGitCommit Failed")
+            @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/ecosystem/ecosystem.rb

@@ -0,0 +1,66 @@
+
+=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 set 5b9c602fe4b02b1389591ecc
+
+=end
+
+require 'net/http'
+require 'json'
+require 'canzea/commands/login'
+
+class Ecosystem
+    def set(id)
+        token = Login.new.get()
+
+        uri = URI(Canzea::config[:canzea_platform_uri] + "/api/v2/saasexpress/ecosystem/#{id}")
+
+        req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{token}")
+
+        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
+                puts JSON.pretty_generate(JSON.parse(res.body))
+                es = JSON.parse(res.body)
+
+                scope = Canzea::config[:config_location] + '/.scope'
+                File.open(scope, 'w') { |file| file.write({id:id}.to_json) }
+                puts "Ecosystem set to #{es['ecosystemRefId']} with domain #{es['fqdomainName']}"
+            else
+                puts res.body
+        end
+
+    end
+
+    def list()
+        token = Login.new.get()
+
+        uri = URI(Canzea::config[:canzea_platform_uri] + "/api/v2/saasexpress/ecosystem/summary")
+
+        req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{token}")
+
+        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
+                list = JSON.parse(res.body)
+                list.each { | es |
+                    printf "Ecosystem: %-25s %-15s %-15s %-8s %s\n", es['_id'], es['status'], es['fqdomainName'], es['ecosystemRefId'], es['name']
+                }
+            else
+                puts res.body
+        end
+
+    end
+end