MuranoCLI 2.2.4 → 3.0.0

data/bin/mr

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-require 'highline'
-
-puts HighLine.color("!"*80, :yellow)
-puts HighLine.color("The command 'mr' is deprecated.  Use 'murano' instead.", :yellow)
-puts HighLine.color("!"*80, :yellow)
-
-exec 'murano', *ARGV

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

@@ -1,145 +0,0 @@
-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 :

data/lib/MrMurano/Product-Resources.rb

@@ -1,205 +0,0 @@
-require 'MrMurano/Product'
-require 'MrMurano/SyncUpDown'
-
-module MrMurano
-
-  ## Manage the resources on a Product
-  #
-  # There isn't an okami-shim for most of this, it maps right over to 1P-RPC.
-  # Or better stated, that's all okami-shim is.
-  class ProductResources < ProductBase
-    include SyncUpDown
-    include ProductOnePlatformRpcShim
-
-    # Resource Specific details on an Item
-    class ResourceItem < Item
-      # @return [String] Reasource Identifier, internal use only.
-      attr_accessor :rid
-      # @return [String] The name of this resource
-      attr_accessor :alias
-      # @return [String] The format of thie resource.
-      attr_accessor :format
-    end
-
-    def initialize
-      super
-      @uriparts << :proxy
-      @uriparts << 'onep:v1'
-      @uriparts << :rpc
-      @uriparts << :process
-      @model_rid = nil
-
-      @itemkey = :rid # this is the key that is the identifier used by murano
-    end
-
-    ## Get 1P info about the prodcut
-    def info
-      do_rpc({:id=>1,
-              :procedure=>:info,
-              :arguments=>[model_rid, {}]
-      })
-    end
-
-    ## Return a list of the product resources as items
-    def list()
-      data = info()
-      ret = []
-      data[:aliases].each do |rid, aliases|
-        aliases.each do |al|
-          ret << {
-            :alias => al,
-            :rid => rid
-          }
-        end
-      end
-
-      ret
-    end
-
-    ## Fetch data from one resource
-    def fetch(rid)
-      do_rpc({:id=>1,
-              :procedure=>:info,
-              :arguments=>[rid, {}],
-      })
-    end
-
-    ## Remove a resource by RID
-    def remove(rid)
-      do_rpc({:id=>1,
-              :procedure=>:drop,
-              :arguments=>[rid]
-      })
-    end
-
-    ## Create a new resource in the prodcut
-    def create(alias_id, format=:string)
-      raise "Alias cannot be nil" if alias_id.nil?
-      # create then map.
-      rid = do_rpc({:id=>1,
-                  :procedure=>:create,
-                  :arguments=>[:dataport,
-                               {:format=>format,
-                                :name=>alias_id,
-                                :retention=>{:count=>1,:duration=>:infinity}
-                               }
-                              ]
-      })
-      return rid unless not rid.kind_of?(String) or rid.match(/\p{XDigit}{40}/)
-
-      do_rpc({:id=>1,
-              :procedure=>:map,
-              :arguments=>[:alias, rid, alias_id]
-      })
-    end
-
-    ## Upload a resource.
-    # this is for SyncUpDown
-    # @param modify Bool: True if item exists already and this is changing it
-    def upload(src, item, modify)
-      if modify then
-        # this is usually a format change, which can only be set on create.
-        # So delete then create.
-        remove(item[:rid])
-      end
-      r = create(item[:alias], item[:format])
-      raise "Create Failed: #{r}" unless r.nil?
-    end
-
-    ## Use alias for doing sync compares
-    # (The RID will change if destroyed and recreated.)
-    def synckey(item)
-      item[:alias]
-    end
-
-    ##
-    #
-    def tolocalpath(into, item)
-      into
-    end
-
-    ## Get a local list of items from the single file
-    def localitems(from)
-      from = Pathname.new(from) unless from.kind_of? Pathname
-      debug "#{self.class.to_s}: Getting local items from: #{from}"
-      if not from.exist? then
-        warning "Skipping missing #{from.to_s}"
-        return []
-      end
-      unless from.file? then
-        warning "Cannot read from #{from.to_s}"
-        return []
-      end
-
-      here = []
-      from.open {|io| here = YAML.load(io) }
-      return [] if here == false
-
-      if here.kind_of?(Hash) and here.has_key?('resources') then
-        here['resources'].map{|i| Hash.transform_keys_to_symbols(i)}
-      else
-        warning "Unexpected data in #{from.to_s}"
-        []
-      end
-    end
-
-    def download(local, item)
-      # needs to append/merge with file
-      # for now, we'll read, modify, write
-      data = fetch(item[:rid])
-      item[:format] = data[:description][:format]
-
-      here = []
-      if local.exist? then
-        local.open('rb') {|io| here = YAML.load(io)}
-        here = [] if here == false
-        if here.kind_of?(Hash) and here.has_key?('resources') then
-          here = here['resources'].map{|i| Hash.transform_keys_to_symbols(i)}
-        else
-          here = []
-        end
-      end
-      here.delete_if do |i|
-        i[:alias] == item[:alias]
-      end
-      here << item.reject{|k,v| k==:synckey or k==:rid}
-      here.map!{|i| Hash.transform_keys_to_strings(i)}
-      local.dirname.mkpath
-      local.open('wb') do |io|
-        io << {'resources'=>here}.to_yaml
-      end
-    end
-
-    def removelocal(dest, item)
-      # needs to append/merge with file
-      # for now, we'll read, modify, write
-      here = []
-      if dest.exist? then
-        dest.open('rb') {|io| here = YAML.load(io)}
-        here = [] if here == false
-        if here.kind_of?(Hash) and here.has_key?('resources') then
-          here = here['resources'].map{|i| Hash.transform_keys_to_symbols(i)}
-        else
-          here = []
-        end
-      end
-      here.delete_if do |it|
-        it[:alias] == item[:alias]
-      end
-      here.map!{|i| Hash.transform_keys_to_strings(i)}
-      dest.open('wb') do|io|
-        io << {'resources'=>here}.to_yaml
-      end
-    end
-
-    ##
-    # True if itemA and itemB are different
-    def docmp(itemA, itemB)
-      itemA[:alias] != itemB[:alias] or itemA[:format] != itemB[:format]
-    end
-
-  end
-  SyncRoot.add('specs', ProductResources, 'P', %{Product Specification})
-
-end
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Product.rb

@@ -1,358 +0,0 @@
-require 'uri'
-require 'mime/types'
-require 'csv'
-require 'pp'
-require 'MrMurano/http'
-require 'MrMurano/verbosing'
-
-module MrMurano
-  class ProductBase
-    def initialize
-      @pid = $cfg['product.id']
-      raise "No Product ID!" if @pid.nil?
-      @uriparts = [:product, @pid]
-      @project_section = :resources
-    end
-
-    include Http
-    include Verbose
-
-    ## Generate an endpoint in Murano
-    # Uses the uriparts and path
-    # @param path String: any additional parts for the URI
-    # @return URI: The full URI for this enpoint.
-    def endPoint(path='')
-      parts = ['https:/', $cfg['net.host'], 'api:1'] + @uriparts
-      s = parts.map{|v| v.to_s}.join('/')
-      URI(s + path.to_s)
-    end
-  end
-
-  module ProductOnePlatformRpcShim
-    ## The model RID for this product.
-    def model_rid
-      return @model_rid unless @model_rid.nil?
-      prd = Product.new
-      data = prd.info
-      if data.kind_of?(Hash) and data.has_key?(:modelrid) then
-        @model_rid = data[:modelrid]
-      else
-        raise "Bad info; #{data}"
-      end
-      @model_rid
-    end
-
-    ## Do a 1P RPC call
-    #
-    # While this will take an array of calls, don't. Only pass one.
-    # This only returns the result of the first call. Results from other calls are
-    # dropped.
-    def do_rpc(calls, cid=model_rid)
-      calls = [calls] unless calls.kind_of?(Array)
-      r = do_mrpc(calls, cid)
-      return r if not r.kind_of?(Array) or r.count < 1
-      r = r[0]
-      return r if not r.kind_of?(Hash) or r[:status] != 'ok'
-      r[:result]
-    end
-    private :do_rpc
-
-    ## Do many 1P RPC calls
-    def do_mrpc(calls, cid=model_rid)
-      calls = [calls] unless calls.kind_of?(Array)
-      maxid = ((calls.max_by{|c| c[:id] or 0 }[:id]) or 0)
-      calls.map!{|c| c[:id] = (maxid += 1) unless c.has_key?(:id); c}
-      post('', {
-        :auth=>(cid ? {:client_id=>cid} : {}),
-        :calls=>calls
-      })
-    end
-    private :do_mrpc
-
-  end
-
-  class Product < ProductBase
-    ## Get info about the product
-    def info
-      get('/info')
-    end
-
-    ## List enabled devices
-    def list(offset=0, limit=50)
-      get("/device/?offset=#{offset}&limit=#{limit}")
-    end
-
-    ## Enable a serial number
-    # This creates the device and opens the activation window.
-    def enable(sn)
-      post("/device/#{sn.to_s}")
-    end
-
-    ## Upload a spec file.
-    #
-    # Note that this will fail if any of the resources already exist.
-    def update(specFile)
-      specFile = Pathname.new(specFile) unless specFile.kind_of? Pathname
-
-      uri = endPoint('/definition')
-      request = Net::HTTP::Post.new(uri)
-      ret = nil
-
-      specFile.open do |io|
-        request.body_stream = io
-        request.content_length = specFile.size
-        set_def_headers(request)
-        request.content_type = 'text/yaml'
-        ret = workit(request)
-      end
-      ret
-    end
-
-    ## Write a value to an alias on a device
-    def write(sn, values)
-      post("/write/#{sn}", values) unless $cfg['tool.dry']
-    end
-
-    ## Converts an exoline style spec file into a Murano style one
-    # @param fin IO: IO Stream to read from
-    # @return String: Converted yaml data
-    def convertit(fin)
-      specOut = {'resources'=>[]}
-      spec = YAML.load(fin)
-      if spec.has_key?('dataports') and spec['dataports'].kind_of?(Array) then
-        dps = spec['dataports'].map do |dp|
-          dp.delete_if{|k,v| k != 'alias' and k != 'format' and k != 'initial'}
-          dp['format'] = 'string' if (dp['format']||'')[0..5] == 'string'
-          dp
-        end
-        specOut['resources'] = dps
-      else
-        raise "No dataports section found, or not an array"
-      end
-      specOut
-    end
-
-    ## Converts an exoline style spec file into a Murano style one
-    # @param specFile String: Path to file or '-' for stdin
-    # @return String: Converted yaml data
-    def convert(specFile)
-      if specFile == '-' then
-        convertit($stdin).to_yaml
-      else
-        specFile = Pathname.new(specFile) unless specFile.kind_of? Pathname
-        out = ''
-        specFile.open() do |fin|
-          out = convertit(fin).to_yaml
-        end
-        out
-      end
-    end
-  end
-
-  ##
-  # Manage the uploadable content for products.
-  class ProductContent < ProductBase
-    def initialize
-      super
-      @uriparts << :proxy
-      @uriparts << :provision
-      @uriparts << :manage
-      @uriparts << :content
-      @uriparts << @pid
-    end
-
-    ## List all things in content area
-    def list
-      ret = get('/')
-      return [] if ret.kind_of?(Hash)
-      ret.lines.map{|i|i.chomp}
-    end
-
-    ## List all contents allowed for sn
-    def list_for(sn)
-      ret = get("/?sn=#{sn}")
-      return [] if ret.kind_of?(Hash)
-      ret.lines.map{|i|i.chomp}
-    end
-
-    ## Create a new content item
-    def create(id, meta='', protect=false)
-      http_reset
-      data = {:id=>id, :meta=>meta}
-      data[:protected] = true if protect
-      postf('/', data)
-    end
-
-    ## Remove Content item
-    def remove(id)
-      postf('/', {:id=>id, :delete=>true})
-    end
-
-    ## Get info for content item
-    def info(id)
-      get("/#{id}") do |request, http|
-        http.request(request) do |resp|
-          case resp
-          when Net::HTTPSuccess
-            return CSV.parse(resp.body)
-          else
-            return nil
-          end
-        end
-      end
-    end
-
-    ## Download data for content item
-    def download(id, &block)
-      get("/#{id}?download=true") do |request, http|
-        http.request(request) do |resp|
-          case resp
-          when Net::HTTPSuccess
-            if block_given? then
-              resp.read_body(&block)
-            else
-              resp.read_body do |chunk|
-                $stdout.write chunk
-              end
-            end
-          else
-            showHttpError(request, resp)
-          end
-        end
-        nil
-      end
-    end
-
-    ## Upload data for content item
-    # TODO: add support for passing in IOStream
-    # @param modify Bool: True if item exists already and this is changing it
-    def upload(id, path, modify=false)
-      path = Pathname.new(path) unless path.kind_of? Pathname
-
-      mime = MIME::Types.type_for(path.to_s)[0] || MIME::Types["application/octet-stream"][0]
-      uri = endPoint("/#{id}")
-      request = Net::HTTP::Post.new(uri)
-      ret = nil
-
-      path.open do |io|
-        request.body_stream = io
-        set_def_headers(request)
-        request.content_length = path.size
-        request.content_type = mime.simplified
-        ret = workit(request)
-      end
-      ret
-    end
-
-    ## Delete data for content item
-    # Note that the content item is still present and listed.
-    def remove_content(id)
-      delete("/#{id}")
-    end
-
-  end
-
-  ##
-  # This is not applicable to Murano.  Remove?
-  # :nocov:
-  class ProductModel < ProductBase
-    def initialize
-      super
-      @uriparts << :proxy
-      @uriparts << :provision
-      @uriparts << :manage
-      @uriparts << :model
-    end
-
-    # In Murano, there should only ever be one.
-    # AND it should be @pid
-    def list
-      get('/')
-    end
-
-    def info(modelID=@pid)
-      get("/#{modelID}")
-    end
-
-    def list_sn(modelID=@pid)
-      get("/#{modelID}/")
-    end
-  end
-
-  class ProductSerialNumber < ProductBase
-    def initialize
-      super
-      @uriparts << :proxy
-      @uriparts << :provision
-      @uriparts << :manage
-      @uriparts << :model
-      @uriparts << @pid
-    end
-
-    def list(offset=0, limit=1000)
-      ret = get("/?offset=#{offset}&limit=#{limit}&status=true")
-      return [] if ret.kind_of?(Hash)
-      CSV.parse(ret)
-    end
-
-    def logs(sn)
-      get("/#{sn}?show=log") # results are empty
-    end
-
-    def regen(sn)
-      postf("/#{sn}", {:enable=>true})
-    end
-
-    def disable(sn)
-      postf("/#{sn}", {:disable=>true})
-    end
-
-    def activate(sn)
-      uri = URI("https://#{@pid}.m2.exosite.com/provision/activate")
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.start
-      request = Net::HTTP::Post.new(uri)
-      request.form_data = {
-        :vendor => @pid,
-        :model => @pid,
-        :sn => sn
-      }
-      request['User-Agent'] = "MrMurano/#{MrMurano::VERSION}"
-      request['Authorization'] = nil
-      request.content_type = 'application/x-www-form-urlencoded; charset=utf-8'
-      curldebug(request)
-      response = http.request(request)
-      case response
-      when Net::HTTPSuccess
-        return response.body
-      else
-        showHttpError(request, response)
-      end
-    end
-
-    def add_sn(sn, extra='')
-      # this does add, but what does that mean?
-      # Still need to call …/device/<sn> to enable.
-      # How long is the activation window?
-      postf('/', {:sn=>sn,:extra=>extra})
-    end
-
-    def remove_sn(sn)
-      #postf('/', {:sn=>sn, :delete=>true})
-      delete("/#{sn}")
-    end
-
-    def ranges
-      get('/?show=ranges')
-    end
-
-    def add_range()
-      post('/', {:ranges=>[ ]})
-    end
-
-  end
-  # :nocov:
-
-end
-#  vim: set ai et sw=2 ts=2 :