MuranoCLI 2.0.0

data/lib/MrMurano/Config-Migrate.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+require 'fileutils'
+require 'yaml'
+require 'MrMurano/verbosing'
+require 'MrMurano/Account'
+require 'MrMurano/Config'
+
+
+module MrMurano
+  class ConfigMigrate
+    include Verbose
+
+    def import_secret
+      solsecret = Pathname.new($cfg['location.base']) + '.Solutionfile.secret'
+      if solsecret.exist? then
+        # Is in JSON, which as a subset of YAML, so use YAML parser
+        solsecret.open do |io|
+          ss = YAML.load(io)
+
+          pff = $cfg.file_at('passwords', :user)
+          pwd = MrMurano::Passwords.new(pff)
+          pwd.load
+          ps = pwd.get($cfg['net.host'], ss['email'])
+          if ps.nil? then
+            pwd.set($cfg['net.host'], ss['email'], ss['password'])
+            pwd.save
+          elsif ps != ss['password'] then
+            y = ask("A different password for this account already exists. Overwrite? N/y")
+            if y =~ /^y/i then
+              pwd.set($cfg['net.host'], ss['email'], ss['password'])
+              pwd.save
+            end
+          else
+            # already set, nothing to do.
+          end
+
+          $cfg.set('user.name', ss['email'])
+          $cfg.set('solution.id', ss['solution_id']) if ss.has_key? 'solution_id'
+          $cfg.set('product.id', ss['product_id']) if ss.has_key? 'product_id'
+        end
+      end
+    end
+
+  end
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Config.rb

@@ -0,0 +1,286 @@
+require 'pathname'
+require 'inifile'
+require 'highline'
+
+module MrMurano
+  class Config
+    #
+    #  internal    transient this-run-only things (also -c options)
+    #  specified   from --configfile
+    #  env         from ENV['MURANO_CONFIGFILE']
+    #  project     .murano/config at project dir
+    #  user        .murano/config at $HOME
+    #  defaults    Internal hardcoded defaults
+    #
+    ConfigFile = Struct.new(:kind, :path, :data) do
+      def load()
+        return if kind == :internal
+        return if kind == :defaults
+        self[:path] = Pathname.new(path) unless path.kind_of? Pathname
+        self[:data] = IniFile.new(:filename=>path.to_s) if self[:data].nil?
+        self[:data].restore
+      end
+
+      def write()
+        return if kind == :internal
+        return if kind == :defaults
+        self[:path] = Pathname.new(path) unless path.kind_of? Pathname
+        self[:data] = IniFile.new(:filename=>path.to_s) if self[:data].nil?
+        self[:data].save
+        path.chmod(0600)
+      end
+    end
+
+    attr :paths
+    attr_reader :projectDir
+
+    CFG_SCOPES=%w{internal specified env project user defaults}.map{|i| i.to_sym}.freeze
+
+    CFG_ENV_NAME=%{MURANO_CONFIGFILE}.freeze
+    CFG_FILE_NAME=%[.murano/config].freeze
+    CFG_DIR_NAME=%[.murano].freeze
+
+    CFG_OLD_ENV_NAME=%[MR_CONFIGFILE].freeze
+    CFG_OLD_DIR_NAME=%[.mrmurano].freeze
+    CFG_OLD_FILE_NAME=%[.mrmuranorc].freeze
+
+    def warning(msg)
+      $stderr.puts HighLine.color(msg, :yellow)
+    end
+    def error(msg)
+      $stderr.puts HighLine.color(msg, :red)
+    end
+
+    def migrateOldEnv
+      unless ENV[CFG_OLD_ENV_NAME].nil? then
+        warning %{ENV "#{CFG_OLD_ENV_NAME}" is no longer supported. Rename it to "#{CFG_ENV_NAME}"}
+        unless ENV[CFG_ENV_NAME].nil? then
+          error %{Both "#{CFG_ENV_NAME}" and "#{CFG_OLD_ENV_NAME}" defined, please remove "#{CFG_OLD_ENV_NAME}".}
+        end
+        ENV[CFG_ENV_NAME] = ENV[CFG_OLD_ENV_NAME]
+      end
+    end
+
+    def migrateOldConfig(where)
+      # Check for dir.
+      if (where + CFG_OLD_DIR_NAME).exist? then
+        warning %{Moving old directory "#{CFG_OLD_DIR_NAME}" to "#{CFG_DIR_NAME}" in "#{where}"}
+        (where + CFG_OLD_DIR_NAME).rename(where + CFG_DIR_NAME)
+      end
+
+      # check for cfg.
+      if (where + CFG_OLD_FILE_NAME).exist? then
+        warning %{Moving old config "#{CFG_OLD_FILE_NAME}" to "#{CFG_FILE_NAME}" in "#{where}"}
+        (where + CFG_DIR_NAME).mkpath
+        (where + CFG_OLD_FILE_NAME).rename(where + CFG_FILE_NAME)
+      end
+    end
+
+    def initialize
+      @paths = []
+      @paths << ConfigFile.new(:internal, nil, IniFile.new())
+      # :specified --configfile FILE goes here. (see load_specific)
+
+      migrateOldEnv
+      unless ENV[CFG_ENV_NAME].nil? then
+        # if it exists, must be a file
+        # if it doesn't exist, that's ok
+        ep = Pathname.new(ENV[CFG_ENV_NAME])
+        if ep.file? or not ep.exist? then
+          @paths << ConfigFile.new(:env, ep)
+        end
+      end
+
+      @projectDir = findProjectDir()
+      migrateOldConfig(@projectDir)
+      @paths << ConfigFile.new(:project,  @projectDir + CFG_FILE_NAME)
+      (@projectDir + CFG_DIR_NAME).mkpath
+      fixModes(@projectDir + CFG_DIR_NAME)
+
+      migrateOldConfig(Pathname.new(Dir.home))
+      @paths << ConfigFile.new(:user, Pathname.new(Dir.home) + CFG_FILE_NAME)
+      (Pathname.new(Dir.home) + CFG_DIR_NAME).mkpath
+      fixModes(Pathname.new(Dir.home) + CFG_DIR_NAME)
+
+      @paths << ConfigFile.new(:defaults, nil, IniFile.new())
+
+
+      set('tool.verbose', false, :defaults)
+      set('tool.debug', false, :defaults)
+      set('tool.dry', false, :defaults)
+      set('tool.fullerror', false, :defaults)
+      set('tool.outformat', 'best', :defaults)
+
+      set('net.host', 'bizapi.hosted.exosite.io', :defaults)
+
+      set('location.base', @projectDir, :defaults) unless @projectDir.nil?
+      set('location.files', 'files', :defaults)
+      set('location.endpoints', 'routes', :defaults)
+      set('location.modules', 'modules', :defaults)
+      set('location.eventhandlers', 'services', :defaults)
+      set('location.specs', 'specs/resources.yaml', :defaults)
+      set('location.cors', 'cors.yaml', :defaults)
+
+      set('sync.bydefault', SyncRoot.bydefault.join(' '), :defaults) if defined? SyncRoot
+
+      set('files.default_page', 'index.html', :defaults)
+      set('files.searchFor', '**/*', :defaults)
+      set('files.ignoring', '', :defaults)
+
+      set('endpoints.searchFor', '{,../endpoints}/*.lua {,../endpoints}s/*/*.lua', :defaults)
+      set('endpoints.ignoring', '*_test.lua *_spec.lua .*', :defaults)
+
+      set('eventhandler.searchFor', '*.lua */*.lua {../eventhandlers,../event_handler}/*.lua {../eventhandlers,../event_handler}/*/*.lua', :defaults)
+      set('eventhandler.ignoring', '*_test.lua *_spec.lua .*', :defaults)
+      set('eventhandler.skiplist', 'websocket webservice device.service_call', :defaults)
+
+      set('modules.searchFor', '*.lua */*.lua', :defaults)
+      set('modules.ignoring', '*_test.lua *_spec.lua .*', :defaults)
+
+      if Gem.win_platform? then
+        set('diff.cmd', 'fc', :defaults)
+      else
+        set('diff.cmd', 'diff -u', :defaults)
+      end
+    end
+
+    ## Find the root of this project Directory.
+    #
+    # The Project dir is the directory between PWD and HOME that has one of (in
+    # order of preference):
+    # - .murano/config
+    # - .mrmuranorc
+    # - .murano/
+    # - .mrmurano/
+    def findProjectDir()
+      result=nil
+      fileNames=[CFG_FILE_NAME, CFG_OLD_FILE_NAME]
+      dirNames=[CFG_DIR_NAME, CFG_OLD_DIR_NAME]
+      home = Pathname.new(Dir.home).realpath
+      pwd = Pathname.new(Dir.pwd).realpath
+      return home if home == pwd
+      pwd.ascend do |i|
+        break unless result.nil?
+        break if i == home
+        fileNames.each do |f|
+          if (i + f).exist? then
+            result = i
+          end
+        end
+        dirNames.each do |f|
+          if (i + f).directory? then
+            result = i
+          end
+        end
+      end
+
+      # Now if nothing found, assume it will live in pwd.
+      result = Pathname.new(Dir.pwd) if result.nil?
+      return result
+    end
+    private :findProjectDir
+
+    def fixModes(path)
+      if path.directory? then
+        path.chmod(0700)
+      elsif path.file? then
+        path.chmod(0600)
+      end
+    end
+
+    def file_at(name, scope=:project)
+      case scope
+      when :internal
+        root = nil
+      when :specified
+        root = nil
+      when :project
+        root = @projectDir + CFG_DIR_NAME
+      when :user
+        root = Pathname.new(Dir.home) + CFG_DIR_NAME
+      when :defaults
+        root = nil
+      end
+      return nil if root.nil?
+      root.mkpath
+      root + name
+    end
+
+    ## Load all of the potential config files
+    def load()
+      # - read/write config file in [Project, User, System] (all are optional)
+      @paths.each { |cfg| cfg.load }
+    end
+
+    ## Load specified file into the config stack
+    # This can be called multiple times and each will get loaded into the config
+    def load_specific(file)
+      spc = ConfigFile.new(:specified, Pathname.new(file))
+      spc.load
+      @paths.insert(1, spc)
+    end
+
+    ## Get a value for key, looking at the specificed scopes
+    # key is <section>.<key>
+    def get(key, scope=CFG_SCOPES)
+      scope = [scope] unless scope.kind_of? Array
+      paths = @paths.select{|p| scope.include? p.kind}
+
+      section, ikey = key.split('.')
+      paths.each do |path|
+        if path.data.has_section?(section) then
+          sec = path.data[section]
+          return sec if ikey.nil?
+          if sec.has_key?(ikey) then
+            return sec[ikey]
+          end
+        end
+      end
+      return nil
+    end
+
+    ## Dump out a combined config
+    def dump()
+      # have a fake, merge all into it, then dump it.
+      base = IniFile.new()
+      @paths.reverse.each do |ini|
+        base.merge! ini.data
+      end
+      base.to_s
+    end
+
+    def set(key, value, scope=:project)
+      section, ikey = key.split('.', 2)
+      raise "Invalid key" if section.nil?
+      if not section.nil? and ikey.nil? then
+        # If key isn't dotted, then assume the tool section.
+        ikey = section
+        section = 'tool'
+      end
+
+      paths = @paths.select{|p| scope == p.kind}
+      raise "Unknown scope" if paths.empty?
+      cfg = paths.first
+      data = cfg.data
+      tomod = data[section]
+      tomod[ikey] = value unless value.nil?
+      tomod.delete(ikey) if value.nil?
+      data[section] = tomod
+      cfg.write
+    end
+
+    # key is <section>.<key>
+    def [](key)
+      get(key)
+    end
+
+    # For setting internal, this-run-only values
+    def []=(key, value)
+      set(key, value, :internal)
+    end
+
+  end
+
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Mock.rb

@@ -0,0 +1,63 @@
+require 'erb'
+require 'securerandom'
+
+module MrMurano
+  class Mock
+    attr_accessor :uuid, :testpoint_file
+
+    def initialize
+    end
+
+    def show
+      file = Pathname.new(get_testpoint_path)
+      if file.exist? then
+        authorization = %{if request.headers["authorization"] == "}
+        file.open('rb') do |io|
+          io.each_line do |line|
+            auth_line = line.include?(authorization)
+            if auth_line then
+              capture = /\=\= "(.*)"/.match(line)
+              return capture.captures[0]
+            end
+          end
+        end
+      end
+      return false
+    end
+
+    def get_mock_template
+      path = get_mock_template_path()
+      return ::File.read(path)
+    end
+
+    def get_testpoint_path
+      file_name = 'testpoint.post.lua'
+      path = %{#{$cfg['location.endpoints']}/#{file_name}}
+      return path
+    end
+
+    def get_mock_template_path
+      return ::File.join(::File.dirname(__FILE__), 'template', 'mock.erb')
+    end
+
+    def create_testpoint
+      uuid = SecureRandom.uuid
+      template = ERB.new(get_mock_template)
+      endpoint = template.result(binding)
+
+      Pathname.new(get_testpoint_path).open('wb') do |io|
+        io << endpoint
+      end
+      return uuid
+    end
+
+    def remove_testpoint
+      file = Pathname.new(get_testpoint_path)
+      if file.exist? then
+        file.unlink
+        return true
+      end
+      return false
+    end
+  end
+end

data/lib/MrMurano/Product-1P-Device.rb

@@ -0,0 +1,145 @@
+require 'MrMurano/Product'
+
+module MrMurano
+  class Product1PDevice < ProductBase
+    include ProductOnePlatformRpcShim
+
+    def initialize
+      super
+      @uriparts << :proxy
+      @uriparts << 'onep:v1'
+      @uriparts << :rpc
+      @uriparts << :process
+      @model_rid = nil
+      @sn_rid = nil
+    end
+
+    ## Get the internal protocol identifier for a device
+    # +sn+:: Identifier for a device
+    def sn_rid(sn)
+      return @sn_rid unless @sn_rid.nil?
+      prd = Product.new()
+      found = []
+
+      offset = 0
+      loop do
+        listing = prd.list(offset)
+        break if listing.empty?
+        found = listing.select{|item| item[:sn] == sn}
+        break unless found.empty?
+
+        offset += 50
+      end
+
+      raise "Identifier Not Found: #{sn}" if found.empty?
+
+      @sn_rid = found.first[:rid]
+      @sn_rid
+    end
+
+    ## Get information about a device
+    # +sn+:: Identifier for a device
+    def info(sn)
+      do_rpc({:id=>1,
+              :procedure=>:info,
+              :arguments=>[sn_rid(sn), {}]
+      }, sn_rid(sn))
+    end
+
+    ## List resources on a device
+    # +sn+:: Identifier for a device
+    def list(sn)
+      data = info(sn)
+      dt = {}
+      data[:aliases].each{|k,v| v.each{|a| dt[a] = k.to_s}}
+      dt
+    end
+
+    def listing(sn)
+      do_rpc({:id=>1,
+              :procedure=>:listing,
+              :arguments=>[sn_rid(sn), [:dataport], {}]
+      }, sn_rid(sn))
+    end
+
+    ## Read the last value for resources on a device
+    # +sn+:: Identifier for a device
+    # +aliases+:: Array of resource names
+    def read(sn, aliases)
+      aliases = [aliases] unless aliases.kind_of? Array
+      calls = aliases.map do |a|
+        {
+         :procedure=>:read,
+         :arguments=>[ {:alias=>a}, {} ]
+        }
+      end
+      do_mrpc(calls, sn_rid(sn)).map do |i|
+        if i.has_key?(:result) and i[:result].count > 0 and i[:result][0].count > 1 then
+          i[:result][0][1]
+        else
+          nil
+        end
+      end
+    end
+
+    ## Completely remove an identifier from the product
+    # +sn+:: Identifier for a device
+    def remove(sn)
+      # First drop it from the 1P database
+      do_rpc({:id=>1, :procedure=>:drop, :arguments=>[sn_rid(sn)]}, nil)
+      # Then remove it from the provisioning databases
+      psn = ProductSerialNumber.new
+      psn.remove_sn(sn)
+    end
+
+    ## Get a tree of info for a device and its resources.
+    # @param sn [String] Identifier for a device
+    # @return [Hash]
+    def twee(sn)
+      inf = info(sn)
+      return {} if inf.nil?
+      return {} unless inf.kind_of? Hash
+      return {} unless inf.has_key? :aliases
+      return {} unless inf[:aliases].kind_of? Hash
+      aliases = inf[:aliases].keys
+      # information for all
+      info_calls = aliases.map do |rid|
+        {:procedure=>:info, :arguments=>[rid, {}]}
+      end
+
+      limitkeys = [:basic, :description, :usage, :children, :storage]
+
+      isubs = do_mrpc(info_calls, sn_rid(sn))
+      children = isubs.map{|i| i[:result].select{|k,v| limitkeys.include? k} }
+
+      # most current value
+      read_calls = aliases.map do |rid|
+        {:procedure=>:read, :arguments=>[rid, {}]}
+      end
+      ivalues = do_mrpc(read_calls, sn_rid(sn))
+
+      rez = aliases.zip(children, ivalues).map do |d|
+        dinf = d[1]
+        dinf[:rid] = d[0]
+        dinf[:alias] = inf[:aliases][d[0]].first
+
+        iv = d[2]
+        if iv.has_key?(:result) and iv[:result].count > 0 and iv[:result][0].count > 1 then
+          dinf[:value] = iv[:result][0][1]
+        else
+          dinf[:value] = nil
+        end
+
+        dinf
+      end
+
+      inf[:children] = rez
+      inf.select!{|k,v| limitkeys.include? k }
+      inf
+    end
+
+  end
+
+end
+
+#  vim: set ai et sw=2 ts=2 :