canzea 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32384af40f3f70d48d4f7451d24cd64e2ca486c5
-  data.tar.gz: c9120b3f254d19c1a491daf429d91aa732a7927d
+  metadata.gz: ca413ebf200c03d1699b7314804caebf821be9d3
+  data.tar.gz: ef0fba6fa00baf55a7b2bcb500349110869f46ed
 SHA512:
-  metadata.gz: 275eda09c0ee6e6641acc19f3a3d9b1f83ae4a3bd40150d19ffa6a7bc58e6d659a4a136cf513f1a0a2698c3a40a8f912f8f8b9501bd9ae2b1312a02a1f6da203
-  data.tar.gz: a0e477cad99c94acd9e2d10bbd98fef55e49c2bc77ae654b563674100de7d67816ecc4c98b130cb780876b31749199d37b5da11a78ceb0bf152e4f2997074185
+  metadata.gz: be137bad5ef7a3c27f97c78e9405108baa1a1b08ee9c9c3b03032ae6399ad492e891238c2f93e35519cdf90f4a5c3ebf913c3fd576d02286fcc8b3dffebe3d66
+  data.tar.gz: 68ddfe35cebc1ed98672398b53e725454482f3c00ab0fd7eeee76864fda01631969ceab3b503d5d61ecc33c5de274d6d773c6c60f8d1cf1ac31a2556a75c9170

data/lib/audit.rb

@@ -0,0 +1,54 @@
+require 'json'
+require 'open3'
+require 'stringio'
+require 'logger'
+
+
+class Audit
+    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
+            }
+        }
+        puts 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
+            }
+        }
+        puts summary.to_json
+        File.open(Canzea::config[:logging_root] + '/audit.log', 'a') { |file| file.puts(data.to_json) }
+    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/version.rb

@@ -1,3 +1,3 @@
 module Canzea
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/canzea.rb

@@ -4,6 +4,7 @@ require 'pathname'
 require 'git'
 require "canzea/config"
 require "canzea/version"
+require "canzea/environment"
 require "helper-run-class"
 require "plan-step-class"
 require "ssh-base-cmd-class"
@@ -11,6 +12,7 @@ require "template-runner"
 require "commands/config-git-commit"
 require "commands/get-catalog"
 require "commands/remote-run"
+require "commands/gen-user"
 
 module Canzea
 
@@ -28,24 +30,24 @@ module Canzea
 
       flag nil, :pwd, 'PWD'
 
-      flag nil, :run, 'Run a step'
-      flag nil, :helper, 'Execute a helper'
+#      flag nil, :run, 'Run a step'
+#      flag nil, :helper, 'Execute a helper'
       flag nil, :remote, 'Remote execution'
       flag nil, :init, 'Remote init execution'
-      flag nil, :enable, 'Enable the service'
+#      flag nil, :enable, 'Enable the service'
+      flag nil, :test, 'Run as a test'
+      flag nil, :reset, 'Refresh catalog to latest'
       flag nil, :config_git_commit, 'Manage configuration files in git'
 
-      option :s,  :stuff, 'specify stuff to do', argument: :required
-
       option nil, :config, 'Config', argument: :required
 
       option nil, :lifecycle, 'Lifecycle action [install, configure, upgrade, uninstall]', argument: :required
 
+      option nil, :util, "Utility action [gen-user, gen-cert]", argument: :required
       option nil, :catalogTag, 'Specific tag of the catalog', argument: :required
       option nil, :gitRoot, 'Git root', argument: :required
       option nil, :role, 'Role', argument: :required
       option nil, :solution, 'Solution', argument: :required
-      option nil, :test, 'Test', argument: :required
       option nil, :task, 'Task', argument: :required
       option nil, :serverBase, 'Server Base', argument: :required
       option nil, :serverNumber, 'Server Number', argument: :required
@@ -67,30 +69,42 @@ module Canzea
             GetCatalog.new.do(opts.fetch(:catalogTag, nil));
         end
 
+        if (opts[:util])
+            util = opts[:util]
+
+            if (util == "gen-user")
+                GenUser.new.do(args[0])
+            end
+        end
+
         if (opts[:lifecycle])
-            GetCatalog.new.do(opts.fetch(:catalogTag, nil));
+            if (opts[:reset])
+                GetCatalog.new.do(opts.fetch(:catalogTag, nil));
+            end
 
             lifecycle = opts[:lifecycle]
 
             if lifecycle == 'install'
               puts "Running install step #{opts[:role]} #{opts[:solution]}"
               ps = PlanStep.new
-              ps.runPhaseInstall opts[:role], opts[:solution], opts.fetch(:test,"false") == "true", Integer(opts.fetch(:task, 1))
+              ps.runPhaseInstall opts[:role], opts[:solution], opts[:test], Integer(opts.fetch(:task, 1))
 
-              gitRoot = opts.fetch(:gitRoot, "/opt/cloud-profile")
+              if (opts[:test] == false)
+                  gitRoot = opts.fetch(:gitRoot, "/opt/cloud-profile")
 
-              # write to configure the registration of the service
-              if (File.exists?("#{gitRoot}/configure.sh") == false)
-                  File.open("#{gitRoot}/configure.sh", 'a') { |file| file.puts("#!/bin/bash") }
-              end
+                  # write to configure the registration of the service
+                  if (File.exists?("#{gitRoot}/configure.sh") == false)
+                      File.open("#{gitRoot}/configure.sh", 'a') { |file| file.puts("#!/bin/bash") }
+                  end
 
-              File.open("#{gitRoot}/configure.sh", 'a') { |file| file.puts("canzea --enable #{ARGV.join(' ')}") }
+                  File.open("#{gitRoot}/configure.sh", 'a') { |file| file.puts("canzea --enable #{ARGV.join(' ')}") }
+              end
             end
 
             if lifecycle == 'configure'
               puts "Running configure step #{opts[:role]} #{opts[:solution]}"
               ps = PlanStep.new
-              ps.runPhaseConfigure opts[:role], opts[:solution], opts.fetch(:test,"false") == "true", Integer(opts.fetch(:task, 1))
+              ps.runPhaseConfigure opts[:role], opts[:solution], opts[:test], Integer(opts.fetch(:task, 1))
             end
 
             if lifecycle == 'wire'

data/lib/commands/gen-user.rb

@@ -0,0 +1,21 @@
+require "git"
+require "fileutils"
+require "pathname"
+require "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 }},
+        ]
+
+        HelperRun.new.runPlan(plans)
+
+    end
+end

data/lib/commands/get-catalog.rb

@@ -5,8 +5,11 @@ require "pathname"
 
 class GetCatalog
     def do(tag = nil)
-        FileUtils.rm_rf Canzea::config[:catalog_location]
-        g = Git.clone(Canzea::config[:catalog_git], "", :path => Canzea::config[:catalog_location])
+        catalogLocation = Canzea::config[:catalog_location]
+        FileUtils.rm_rf catalogLocation
+        FileUtils.mkdir_p catalogLocation
+        catalogLocation = Pathname.new(catalogLocation).realpath
+        g = Git.clone(Canzea::config[:catalog_git], "", :path => catalogLocation)
         g.branch Canzea::config[:catalog_branch]
         if (tag != nil)
             puts "For tag #{tag}"

data/lib/helper-run-class.rb

@@ -6,30 +6,30 @@ require "prepare-environment"
 require "trace-runner"
 
 class HelperRun
-    def run (solution, action, parameters)
+    def initialize ()
+        @basePath = Pathname.new(Canzea::config[:catalog_location]).realpath
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
 
-        log = Logger.new(Canzea::config[:logging_root] + '/helpers.log')
+    def runPlan (plan)
+        plan.each { | plan |
+            puts "Running #{plan[:action]}"
+            self.run (plan[:solution], plan[:action], plan[:parameters])
+        }
+    end
+
+    def run (solution, action, parameters)
 
-        # Type can be either: ruby or shell
-        # type = ARGV[0]
         type = "ruby"
 
         params = JSON.parse(parameters);
-        # 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"))
-            context.keys.each do |key|
-               params[key] = context[key]
-            end
-        end
 
-        # Make sure the parameters are valid JSON
         parameters = JSON.generate(params)
 
         envPush = PrepareEnvironment.new
 
         begin
-            envScript = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/helpers/#{solution}/environment.json"
+            envScript = "#{@basePath}/helpers/#{solution}/environment.json"
             if File.exist?(envScript)
                 log.info("Adding environment variables...")
                 envPush.addToEnv "#{envScript}"
@@ -38,16 +38,17 @@ class HelperRun
             r = RunnerWorker.new
 
             if (type == "ruby")
-                cmd = "ruby #{ENV['CANZEA_PLUGINS']}ike-environments/environment/production/helpers/#{solution}/#{action}.rb '#{parameters}'"
+                cmd = "ruby #{@basePath}/helpers/#{solution}/#{action}.rb '#{parameters}'"
             else
-                cmd = "#{ENV['CANZEA_PLUGINS']}ike-environments/environment/production/helpers/#{solution}/#{action}.sh \"#{parameters}\""
+                cmd = "#{@basePath}/helpers/#{solution}/#{action}.sh \"#{parameters}\""
             end
             r.run cmd, 1, 1, false
 
-        rescue => error
-            log.error(error.backtrace)
-            log.error("Error processing #{error.message}")
-            abort("Problem running plan #{error.message}")
+        rescue => exception
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
         end
     end
 end

data/lib/plan-step-class.rb

@@ -1,82 +1,70 @@
 require 'json'
 require 'logger'
 require 'trace-component'
+require 'pathname'
 require 'helper-run-class'
+require 'prepare-environment'
 
 class PlanStep
-    def runPhaseInstall (role, solution, test, task)
-
-        log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    def initialize ()
+        @basePath = Pathname.new(Canzea::config[:catalog_location]).realpath
+        @log = Logger.new(Canzea::config[:logging_root] + '/plans.log')
+    end
 
-        # ruby plan.rb <plan description> <test run> <start>
+    def runPhaseInstall (role, solution, test, task)
 
         plan = JSON.parse("{ \"plan\": [ { \"role\": \"#{role}\", \"solution\": \"#{solution}\" } ] }")
 
         n = Worker.new
-
-
         n.test ( test )
 
         start = Integer(task)
         lines = 1
 
-        cmd = "TBD"
-
-
         begin
 
             plan['plan'].each do |item|
-                log.info(item['solution'])
+                @log.info(item['solution'])
 
-                root = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}"
+                root = "#{@basePath}/roles/#{item['role']}/#{item['solution']}"
                 if File.exist?(root) == false
                     puts "-- ERROR #{root} does not exist!"
                     raise "#{root} does not exist!"
                 end
 
-                cmd = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}/install.sh"
-
+                cmd = "#{@basePath}/roles/#{item['role']}/#{item['solution']}/install.sh"
                 if File.exist?(cmd)
                     lines = n.run cmd, start, lines - 1
 
-                    log.info "#{ lines } lines read"
+                    @log.info "#{ lines } lines read"
                 end
-
-
             end
         rescue => exception
-          log.error(cmd)
-          log.error(exception.to_s)
-          log.error(exception.backtrace)
-          abort()
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
         end
     end
 
     def runPhaseConfigure (role, solution, test, task)
 
-        log = Logger.new(Dir.home() + '/plans.log')
-
-        # ruby plan.rb <plan description> <test run> <start>
-
         plan = JSON.parse("{ \"plan\": [ { \"role\": \"#{role}\", \"solution\": \"#{solution}\" } ] }")
 
         n = Worker.new
-
-
         n.test ( test )
 
         start = Integer(task)
         lines = 1
 
-        cmd = "TBD"
-
+        cmd = "undefined"
 
         begin
 
             plan['plan'].each do |item|
-                log.info(item['solution'])
+                @log.info(item['solution'])
 
-                root = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}"
+                root = "#{@basePath}/roles/#{item['role']}/#{item['solution']}"
                 if File.exist?(root) == false
                     puts "-- ERROR #{root} does not exist!"
                     raise "#{root} does not exist!"
@@ -84,53 +72,54 @@ class PlanStep
 
                 # Register the service with Consul, if consul is ready
                 # If metadata.json exists, then use the information to register
-                cmd = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}/metadata.json"
+                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'], "serviceName"=>svc['name'], "tags"=>{}, "port"=>svc['port']}
-                        h = HelperRun.new
-                        h.run "consul", "add_service", JSON.generate(adef)
+                        puts "-- Registering"
+                        if (test == false)
+                            h = HelperRun.new
+                            h.run "consul", "add_service", JSON.generate(adef)
+                        end
                     end
                 end
 
-                envScript = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}/environment.json"
+                envScript = "#{@basePath}/roles/#{item['role']}/#{item['solution']}/environment.json"
                 if File.exist?(envScript)
-                    require_relative '../init/prepare_environment'
-
                     envPush = PrepareEnvironment.new
                     envPush.addToEnv "#{envScript}"
                 end
 
-                cmd = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}/configure.sh"
+                cmd = "#{@basePath}/roles/#{item['role']}/#{item['solution']}/configure.sh"
                 if File.exist?(cmd)
                   lines = n.run cmd, start, lines - 1
 
-                  log.info("#{ lines } lines read")
+                  @log.info("#{ lines } lines read")
                 end
 
-                cmd = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}/enable.sh"
+                cmd = "#{@basePath}/roles/#{item['role']}/#{item['solution']}/enable.sh"
                 if File.exist?(cmd)
                   lines = n.run cmd, start, lines - 1
 
-                  log.info("#{ lines } lines read")
+                  @log.info("#{ lines } lines read")
                 end
 
-                cmd = ENV['CANZEA_PLUGINS'] + "ike-environments/environment/production/roles/#{item['role']}/#{item['solution']}/status.sh"
+                cmd = "#{@basePath}/roles/#{item['role']}/#{item['solution']}/status.sh"
                 if File.exist?(cmd)
                   lines = n.run cmd, start, lines - 1, true
 
-                  log.info("#{ lines } lines read")
+                  @log.info("#{ lines } lines read")
                 end
 
             end
         rescue => exception
-          log.error(cmd)
-          log.error(exception.to_s)
-          log.error(exception.backtrace)
-          abort()
+            @log.error(cmd)
+            @log.error(exception.to_s)
+            @log.error(exception.backtrace)
+            abort()
         end
     end
 end

data/lib/prepare-environment.rb

@@ -12,7 +12,6 @@ class PrepareEnvironment
 
         r = Registry.new
 
-        # ENV["ENV_CONFIG"] instead of a file
         file = File.read(envFile)
 
         serviceLookups = JSON.parse(file)

data/lib/template-runner.rb

@@ -29,9 +29,3 @@ class Template < Mustache
      return self.render
   end
 end
-
-# t = Template.new
-
-# t.process ARGV[0], ARGV[1], JSON.parse(ARGV[2])
-
-# puts "Wrote to #{ARGV[1]}"

data/lib/trace-component.rb

@@ -2,10 +2,9 @@ require 'json'
 require 'open3'
 require 'stringio'
 require 'logger'
+require 'audit'
+
 
-# Optionally can specify the command to continue from
-# Exit on first failure
-#
 def time_diff_milli(start, finish)
    (finish - start) * 1000.0
 end
@@ -20,56 +19,6 @@ def handleIO(stillOpen, ioArray, io, log)
   end
 end
 
-
-class Audit
-    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
-            }
-        }
-        puts 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
-            }
-        }
-        puts summary.to_json
-        File.open(Canzea::config[:logging_root] + '/audit.log', 'a') { |file| file.puts(data.to_json) }
-    end
-end
-
 class ManagedError < StandardError
 end
 

data/lib/trace-runner.rb

@@ -2,10 +2,9 @@ require 'json'
 require 'open3'
 require 'stringio'
 require 'logger'
+require 'audit'
+
 
-# Optionally can specify the command to continue from
-# Exit on first failure
-#
 def time_diff_milli(start, finish)
    (finish - start) * 1000.0
 end
@@ -20,56 +19,6 @@ def handleIO(stillOpen, ioArray, io, log)
   end
 end
 
-
-class Audit
-    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
-            }
-        }
-        puts 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
-            }
-        }
-        puts summary.to_json
-        File.open(Canzea::config[:logging_root] + '/audit.log', 'a') { |file| file.puts(data.to_json) }
-    end
-end
-
 class RunnerWorker
 
     def run(command, start, lines, statusIndicator = false )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canzea
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Canzea Technologies
@@ -160,10 +160,13 @@ files:
 - bin/setup
 - canzea.gemspec
 - cli.iml
+- lib/audit.rb
 - lib/canzea.rb
 - lib/canzea/config.rb
+- lib/canzea/environment.rb
 - lib/canzea/version.rb
 - lib/commands/config-git-commit.rb
+- lib/commands/gen-user.rb
 - lib/commands/get-catalog.rb
 - lib/commands/remote-run.rb
 - lib/helper-run-class.rb