MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/commands/postgresql.rb

@@ -1,20 +1,30 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+require 'MrMurano/ReCommander'
 require 'MrMurano/Solution-ServiceConfig'
 
 module MrMurano
   class Postgresql < ServiceConfig
-    def initialize
+    def initialize(sid=nil)
+      # FIXME/2017-07-03: What soln types have PSQLs?
+      @solntype = 'application.id'
       super
-      @serviceName = 'postgresql'
+      @service_name = 'postgresql'
     end
 
     def query(query, params=nil)
-      aqr = {:sql=>query}
+      aqr = { sql: query }
       aqr[:parameters] = params unless params.nil?
       call(:query, :post, aqr)
     end
 
     def queries(query, params=nil)
-      aqr = {:sql=>query}
+      aqr = { sql: query }
       aqr[:parameters] = params unless params.nil?
       call(:queries, :post, aqr)
     end
@@ -22,163 +32,186 @@ module MrMurano
 end
 
 command :postgresql do |c|
-  c.syntax = %{murano postgresql <SQL Commands>}
-  c.summary = %{Query the relational database}
-  c.description = %{Query the relational database
-
-  Queries can include $# escapes that are filled from the --param option.
-  }
-
-  c.option '--param LIST',Array,  %{Values to fill $# with}
-  c.option '-f', '--file FILE', %{File of SQL commands}
-  c.option '-o', '--output FILE', %{Download to file instead of STDOUT}
+  c.syntax = %(murano postgresql <SQL Commands>)
+  c.summary = %(Query the relational database)
+  c.description = %(
+Query the relational database.
+
+Queries can include $# escapes that are filled from the --param option.
+  ).strip
+
+  c.option '--param LIST', Array, %(Values to fill $# with)
+  c.option '-f', '--file FILE', %(File of SQL commands)
+  c.option '-o', '--output FILE', %(Download to file instead of STDOUT)
+
+  c.example %(murano postgresql 'select * from bob'), %(Run a SQL command)
+  c.example(
+    %(murano postgresql 'select * from prices' -c outformat=csv -o prices.csv),
+    %(Download all values in prices to a CSV file.)
+  )
+  c.example(
+    %(murano postgresql 'INSERT INTO prices (price, item) VALUES ($1,$2)' --param 1.24,Food),
+    %(Insert using parameters.)
+  )
+  c.example %(murano postgresql -f cmds.sql), %(Run multiple commands from a file)
+
+  c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
 
-  c.example %{murano postgresql 'select * from bob'}, %{Run a SQL command}
-  c.example %{murano postgresql 'select * from prices' -c outformat=csv -o prices.csv}, %{Download all values in prices to a CSV file.}
-  c.example %{murano postgresql 'INSERT INTO prices (price, item) VALUES ($1,$2)' --param 1.24,Food}, %{Insert using parameters.}
-  c.example %{murano postgresql -f cmds.sql}, %{Run multiple commands from a file}
-
-  c.action do |args,options|
     pg = MrMurano::Postgresql.new
-    if options.file then
+    if options.file
       sqls = File.read(options.file)
-
       ret = pg.queries(sqls, options.param)
     else
       ret = pg.query(args.join(' '), options.param)
     end
 
-    unless ret[:error].nil? then
+    exit 1 if ret.nil?
+    unless ret[:error].nil?
       pg.error "Returned error: #{ret[:error]}"
       exit 1
     end
 
-    io=nil
-    if options.output then
-      io = File.open(options.output, 'w')
-    end
+    io = nil
+    io = File.open(options.output, 'w') if options.output
 
     pg.outf(ret, io) do |dd, ios|
       dd = dd[:result]
-      pg.tabularize({
-        :headers=>dd[:columns],
-        :rows=>dd[:rows]
-      }, ios)
+      # Look for date cells and pretty them. (a Hash with specific fields)
+      # All others, call to_s
+      rows = dd[:rows].map do |row|
+        row.map do |cell|
+          if cell.is_a?(Hash) && cell.keys.sort == %i[day hour min month sec usec year]
+            t = Time.gm(
+              cell[:year], cell[:month], cell[:day], cell[:hour], cell[:min], cell[:sec], cell[:usec]
+            )
+            t.getlocal.strftime('%F %T.%6N %z')
+          else
+            cell.to_s
+          end
+        end
+      end
+      pg.tabularize(
+        {
+          headers: dd[:columns],
+          rows: rows,
+        },
+        ios
+      )
     end
     io.close unless io.nil?
-
   end
 end
 
 command 'postgresql migrate' do |c|
-  c.syntax = %{murano postgresql migrate (up|down) <level>}
-  c.summary = %{Run database migration scripts.}
-  c.description = %{Run database migration scripts.
+  c.syntax = %(murano postgresql migrate (up|down) [<level>])
+  c.summary = %(Run database migration scripts.)
+  c.description = %(
+Run database migration scripts.
 
-  The names of the script files must be in the "<level>-<name>-<up|down>.sql"
-  format.  Each file is a series of Postgres SQL commands.
+The names of the script files must be in the "<level>-<name>-<up|down>.sql"
+format. Each file is a series of Postgres SQL commands.
 
-  The current version of the migrations (last <level> ran) will be stored in an
-  extra table in your database.  (__murano_cli__.migrate_version)
+The current version of the migrations (last <level> ran) will be stored in an
+extra table in your database. (__murano_cli__.migrate_version)
+  ).strip
 
-  }
+  c.option '--dir DIR', %(Directory where migrations live)
 
-  c.option '--dir DIR', %{Directory where migrations live}
+  c.example %(murano postgresql migrate up), %(Run migrations up to largest version.)
+  c.example %(murano postgresql migrate up 2), %(Run migrations up to version 2.)
+  c.example %(murano postgresql migrate down 1), %(Run migrations down to version 1.)
+  c.example %(murano postgresql migrate down 0), %(Run migrations down to version 0.)
 
-  c.example %{murano postgresql migrate up}, %{Run migrations up to largest version.}
-  c.example %{murano postgresql migrate up 2}, %{Run migrations up to version 2.}
-  c.example %{murano postgresql migrate down 1}, %{Run migrations down to version 1.}
-  c.example %{murano postgresql migrate down 0}, %{Run migrations down to version 0.}
+  c.action do |args, options|
+    c.verify_arg_count!(args, 2, ['Missing direction'])
+    options.default(dir: File.join($cfg['location.base'], ($cfg['postgresql.migrations_dir'] || '')))
 
-  c.action do |args,options|
-    options.default :dir => File.join($cfg['location.base'], $cfg['postgresql.migrations_dir'])
+    pg = MrMurano::Postgresql.new
 
     direction = args.shift
-    if direction =~ /down/i then
+    if direction =~ /down/i
       direction = 'down'
-    else
+    elsif direction =~ /up/i
       direction = 'up'
+    else
+      pg.error "Unrecogized direction: ‘#{direction}’"
+      exit 1
     end
 
     want_version = args.first
 
-    pg = MrMurano::Postgresql.new
-
     # get current version of DB.
-    ret = pg.queries %{
-    CREATE SCHEMA IF NOT EXISTS __murano_cli__;
-    CREATE TABLE IF NOT EXISTS __murano_cli__.migrate_version (version integer);
-    SELECT version FROM __murano_cli__.migrate_version ORDER BY version DESC;
-    }.gsub(/^\s+/,'')
-    unless ret[:error].nil? then
+    ret = pg.queries %(
+      CREATE SCHEMA IF NOT EXISTS __murano_cli__;
+      CREATE TABLE IF NOT EXISTS __murano_cli__.migrate_version (version integer);
+      SELECT version FROM __murano_cli__.migrate_version ORDER BY version DESC;
+    ).gsub(/^\s+/, '')
+    unless ret[:error].nil?
       pp ret
       exit 1
     end
     pg.debug "create/select: #{ret}"
-    current_version = (((((ret[:result] or []).last or {})[:rows] or []).first or []).first or 0).to_i
+    current_version = (((((ret[:result] || []).last || {})[:rows] || []).first || []).first || 0).to_i
 
     # Get migrations
     migrations = Dir[File.join(options.dir, "*-#{direction}.sql")].sort
-    if migrations.empty? then
-      pg.error "No migrations to run."
+    if migrations.empty?
+      pg.error 'No migrations to run.'
       exit 1
     end
     migrations.reverse! if direction == 'down'
 
-    if want_version.nil? then
-      want_version, _ = File.basename(migrations.last).split('-')
-    end
+    want_version, = File.basename(migrations.last).split('-') if want_version.nil?
     want_version = want_version.to_i
     pg.verbose "Will migrate from version #{current_version} to #{want_version}"
-    if direction == 'down' then
-      if want_version >= current_version then
-        say "Nothing to do."
-        exit 0
-      end
-    else
-      if want_version <= current_version then
-        say "Nothing to do."
+    if direction == 'down'
+      if want_version >= current_version
+        say 'Nothing to do.'
         exit 0
       end
+    elsif want_version <= current_version
+      say 'Nothing to do.'
+      exit 0
     end
 
     pg.debug "Migrations before: #{migrations}"
     # Select migrations between current and desired
     migrations.select! do |m|
-      mvrs, _ = File.basename(m).split('-')
+      mvrs, = File.basename(m).split('-')
       mvrs = mvrs.to_i
-      if direction == 'down' then
-        mvrs <= current_version and mvrs > want_version
+      if direction == 'down'
+        mvrs <= current_version && mvrs > want_version
       else
-        mvrs > current_version and mvrs <= want_version
+        mvrs > current_version && mvrs <= want_version
       end
     end
     pg.debug "Migrations after: #{migrations}"
 
     # Run migrations.
     migrations.each do |m|
-      mvrs, _ = File.basename(m).split('-')
+      mvrs, = File.basename(m).split('-')
       pg.verbose "Running migration: #{File.basename(m)}"
-      unless $cfg['tool.dry'] then
-        pg.query 'BEGIN;'
-        ret = pg.queries File.read(m)
-        unless ret[:error].nil? then
-          pg.query 'ROLLBACK;'
-          pg.error "Migrations failed at level #{mvrs}"
-          pg.error "Because: #{ret[:error]}"
-          exit 5
-        else
-          if direction == 'down' then
-            pg.queries %{DELETE FROM __murano_cli__.migrate_version WHERE version = #{mvrs};
-              COMMIT;}.gsub(/^\s+/,'')
-          else
-            pg.queries %{INSERT INTO __murano_cli__.migrate_version values (#{mvrs});
-              COMMIT;}.gsub(/^\s+/,'')
-          end
-        end
+      next if $cfg['tool.dry']
+      pg.query 'BEGIN;'
+      ret = pg.queries File.read(m)
+      if !ret[:error].nil?
+        pg.query 'ROLLBACK;'
+        pg.error "Migrations failed at level #{mvrs}"
+        pg.error "Because: #{ret[:error]}"
+        exit 5
+      elsif direction == 'down'
+        pg.queries %(
+          DELETE FROM __murano_cli__.migrate_version WHERE version = #{mvrs};
+          COMMIT;
+        ).gsub(/^\s+/, '')
+      else
+        pg.queries %(
+          INSERT INTO __murano_cli__.migrate_version values (#{mvrs});
+          COMMIT;
+        ).gsub(/^\s+/, '')
       end
     end
   end
 end
 
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/commands/settings.rb

@@ -0,0 +1,203 @@
+require 'vine'
+require 'yaml'
+require 'MrMurano/hash'
+require 'MrMurano/ReCommander'
+require 'MrMurano/Setting'
+
+command 'setting list' do |c|
+  c.syntax = %{murano setting list}
+  c.summary = %{List which services and settings are avalible.}
+  c.description = %{
+List which services and settings are avalible.
+  }.strip
+  c.project_not_required = true
+
+  c.action do |args, options|
+    c.verify_arg_count!(args)
+
+    setting = MrMurano::Setting.new
+
+    ret = setting.list
+
+    dd = []
+    ret.each_pair { |k,v| v.each { |s| dd << "#{k}.#{s}" } }
+
+    setting.outf dd
+  end
+end
+alias_command 'settings list', 'setting list'
+
+command 'setting read' do |c|
+  c.syntax = %{murano setting read <service>.<setting> [<sub-key>]}
+  c.summary = %{Read a setting on a Service}
+  c.description = %{
+Read a setting on a Service.
+  }.strip
+
+  c.option '-o', '--output FILE', String, %{File to save output to}
+
+  c.action do |args, options|
+    c.verify_arg_count!(args, 2, ['Missing <service>.<setting>'])
+
+    setting = MrMurano::Setting.new
+
+    service, pref = args[0].split('.')
+    subkey = args[1]
+
+    ret = setting.read(service, pref)
+
+    ret = ret.access(subkey) unless subkey.nil?
+
+    io = nil
+    if options.output then
+      io = File.open(options.output, 'w')
+    end
+    setting.outf(ret, io)
+    io.close unless io.nil?
+  end
+end
+
+command 'setting write' do |c|
+  c.syntax = %{murano setting write <service>.<setting> <sub-key> [<value>...]}
+  c.summary = %{Write a setting on a Service}
+  c.description = %{
+Write a setting on a Service, or just part of a setting.
+
+if <value> is omitted on command line, then it is read from STDIN.
+
+This always does a read-modify-write.
+
+If a sub-key doesn't exist, that entire path will be created as dicts.
+  }.strip
+
+  c.option '--bool', %{Set Value type to boolean}
+  c.option '--num', %{Set Value type to number}
+  c.option '--string', %{Set Value type to string (this is default)}
+  c.option '--json', %{Value is parsed as JSON}
+  c.option '--array', %{Set Value type to array of strings}
+  c.option '--dict', %{Set Value type to a dictionary of strings}
+
+  c.option '--append', %{When sub-key is an array, append values instead of replacing}
+  c.option '--merge', %{When sub-key is a dict, merge values instead of replacing (child dicts are also merged)}
+
+  c.example %{murano setting write Gateway.protocol devmode --bool yes}, %{}
+  c.example %{murano setting write Gateway.identity_format options.length --int 24}, %{}
+
+  c.example %{murano setting write Webservice.cors methods --array HEAD GET POST}, %{}
+  c.example %{murano setting write Webservice.cors headers --append --array X-My-Token}, %{}
+
+  c.example %{murano setting write Webservice.cors --type=json - < }, %{}
+
+  c.action do |args, options|
+    c.verify_arg_count!(args, nil, ['Missing <service>.<setting>', 'Missing <sub-key>'])
+    options.default(
+      bool: false,
+      num: false,
+      string: true,
+      json: false,
+      array: false,
+      dict: false,
+      append: false,
+      merge: false,
+    )
+
+    service, pref = args.shift.split('.')
+    subkey = args.shift
+    value = args.first
+
+    setting = MrMurano::Setting.new
+
+    # If value is '-', pull from $stdin
+    if value.nil? and args.count == 0 then
+      value = $stdin.read
+    end
+
+    # Set value to correct type.
+    if options.bool then
+      if value =~ /(yes|y|true|t|1|on)/i then
+        value = true
+      elsif value =~ /(no|n|false|f|0|off)/i then
+        value = false
+      else
+        setting.error %{Value "#{value}" is not a bool type!}
+        exit 2
+      end
+    elsif options.num then
+      begin
+        value = Integer(value)
+      rescue Exception => e
+        setting.debug e.to_s
+        begin
+          value = Float(value)
+        rescue Exception => e
+          setting.error %{Value "#{value}" is not a number}
+          setting.debug e.to_s
+          exit 2
+        end
+      end
+    elsif options.json then
+      # We use the YAML parser since it will handle most common typos in json and
+      # product the intended output.
+      begin
+        value = YAML.load(value)
+      rescue Exception => e
+        setting.error %{Value not valid JSON (or YAML)}
+        setting.debug e.to_s
+        exit 2
+      end
+
+    elsif options.array then
+      # take remaining args as an array
+      value = args
+
+    elsif options.dict then
+      # take remaining args and convert to hash
+      begin
+        value = Hash.transform_keys_to_symbols(Hash[*args])
+      rescue ArgumentError => e
+        setting.error %{Odd number of arguments to dictionary}
+        setting.debug e.to_s
+        exit 2
+      rescue Exception => e
+        setting.error %{Cannot make dictionary from args}
+        setting.debug e.to_s
+        exit 2
+      end
+
+    elsif options.string then
+      value = value.to_s
+    else
+      # is a string.
+      value = value.to_s
+    end
+
+    ret = setting.read(service, pref)
+    setting.verbose %{Read value: #{ret}}
+
+    # modify and merge.
+    if options.append then
+      g = ret.access(subkey)
+      unless g.kind_of? Array then
+        setting.error %{Cannot append; "#{subkey}" is not an array.}
+        exit 3
+      end
+      g.push(*value)
+
+    elsif options.merge then
+      g = ret.access(subkey)
+      unless g.kind_of? Hash then
+        setting.error %{Cannot append; "#{subkey}" is not a dictionary.}
+        exit 3
+      end
+      g.deep_merge!(value)
+    else
+      ret.set(subkey, value)
+    end
+    setting.verbose %{Going to write composed value: #{ret}}
+
+    setting.write(service, pref, ret)
+  end
+end
+
+#  vim: set ai et sw=2 ts=2 :
+