MuranoCLI 2.0.0

data/lib/MrMurano/Product-Resources.rb

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

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