MuranoCLI 2.0.0

data/lib/MrMurano/Solution-File.rb

@@ -0,0 +1,150 @@
+require 'uri'
+require 'net/http'
+require "http/form_data"
+require 'digest/sha1'
+require 'mime/types'
+require 'pp'
+require 'MrMurano/Solution'
+
+module MrMurano
+  # …/file
+  class File < SolutionBase
+    def initialize
+      super
+      @uriparts << 'file'
+      @itemkey = :path
+      @project_section = :assets
+    end
+
+    ##
+    # Get a list of all of the static content
+    def list
+      get()
+    end
+
+    ##
+    # Get one item of the static content.
+    def fetch(path, &block)
+      get(path) 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
+
+    ##
+    # Delete a file
+    def remove(path)
+      # TODO test
+      delete('/'+path)
+    end
+
+    def curldebug(request)
+      # The upload will get printed out inside of upload.
+      # Because we don't have the correct info here.
+      if request.method != 'PUT' then
+        super(request)
+      end
+    end
+
+    ##
+    # Upload a file
+    # @param modify Bool: True if item exists already and this is changing it
+    def upload(local, remote, modify)
+      local = Pathname.new(local) unless local.kind_of? Pathname
+
+      uri = endPoint('upload' + remote[:path])
+      # kludge past for a bit.
+      #`curl -s -H 'Authorization: token #{@token}' '#{uri.to_s}' -F file=@#{local.to_s}`
+
+      # http://stackoverflow.com/questions/184178/ruby-how-to-post-a-file-via-http-as-multipart-form-data
+      #
+      # Look at: https://github.com/httprb/http
+      # If it works well, consider porting over to it.
+      #
+      # Or just: https://github.com/httprb/form_data.rb ?
+      #
+      # Most of these pull into ram.  So maybe just go with that. Would guess that
+      # truely large static content is rare, and we can optimize/fix that later.
+
+      file = HTTP::FormData::File.new(local.to_s, {:mime_type=>remote[:mime_type]})
+      form = HTTP::FormData.create(:file=>file)
+      req = Net::HTTP::Put.new(uri)
+      set_def_headers(req)
+      workit(req) do |request,http|
+        request.content_type = form.content_type
+        request.content_length = form.content_length
+        request.body = form.to_s
+
+        if $cfg['tool.curldebug'] then
+          a = []
+          a << %{curl -s -H 'Authorization: #{request['authorization']}'}
+          a << %{-H 'User-Agent: #{request['User-Agent']}'}
+          a << %{-X #{request.method}}
+          a << %{'#{request.uri.to_s}'}
+          a << %{-F file=@#{local.to_s}}
+          puts a.join(' ')
+        end
+
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+        else
+          showHttpError(request, response)
+        end
+      end
+    end
+
+    def tolocalname(item, key)
+      name = item[key]
+      name = $cfg['files.default_page'] if name == '/'
+      name
+    end
+
+    def toRemoteItem(from, path)
+      item = super(from, path)
+      name = item[:name]
+      name = '/' if name == $cfg['files.default_page']
+      name = "/#{name}" unless name.chars.first == '/'
+
+      mime = MIME::Types.type_for(path.to_s)[0] || MIME::Types["application/octet-stream"][0]
+
+      # It does not actually take the SHA1 of the file.
+      # It first converts the file to hex, then takes the SHA1 of that string
+      #sha1 = Digest::SHA1.file(path.to_s).hexdigest
+      sha1 = Digest::SHA1.new
+      path.open('rb:ASCII-8BIT') do |io|
+        while chunk = io.read(1048576) do
+          sha1 << Digest.hexencode(chunk)
+        end
+      end
+      debug "Checking #{name} (#{mime.simplified} #{sha1.hexdigest})"
+
+      {:path=>name, :mime_type=>mime.simplified, :checksum=>sha1.hexdigest}
+    end
+
+    def synckey(item)
+      item[:path]
+    end
+
+    def docmp(itemA, itemB)
+      return (itemA[:mime_type] != itemB[:mime_type] or
+        itemA[:checksum] != itemB[:checksum])
+    end
+
+  end
+  SyncRoot.add('files', File, 'S', %{Static Files}, true)
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-ServiceConfig.rb

@@ -0,0 +1,140 @@
+require 'MrMurano/Solution'
+
+module MrMurano
+  # …/serviceconfig
+  class ServiceConfig < SolutionBase
+    def initialize
+      super
+      @uriparts << 'serviceconfig'
+      @scid = nil
+    end
+
+    def list
+      get()[:items]
+    end
+    def fetch(id)
+      get('/' + id.to_s)
+    end
+
+    def scid_for_name(name)
+      name = name.to_s unless name.kind_of? String
+      scr = list().select{|i| i[:service] == name}.first
+      return nil if scr.nil?
+      scr[:id]
+    end
+
+    def scid
+      return @scid unless @scid.nil?
+      @scid = scid_for_name(@serviceName)
+    end
+
+    def info(id=scid)
+      get("/#{id}/info")
+    end
+
+    def logs(id=scid)
+      get("/#{id}/logs")
+    end
+
+    def call(opid, meth=:get, data=nil, id=scid, &block)
+      raise "Service '#{@serviceName}' not enabled for this Solution" if id.nil?
+      call = "/#{id.to_s}/call/#{opid.to_s}"
+      debug "Will call: #{call}"
+      case meth
+      when :get
+        get(call, data, &block)
+      when :post
+        data = {} if data.nil?
+        post(call, data, &block)
+      when :put
+        data = {} if data.nil?
+        put(call, data, &block)
+      when :delete
+        delete(call, &block)
+      else
+        raise "Unknown method: #{meth}"
+      end
+    end
+
+  end
+
+  ## This is only used for debugging and deciphering APIs.
+  #
+  # There was once a plan for using this to automagically map commands into
+  # services by reading their schema.  That plan had too much magic and was too
+  # fragile for real use.
+  #
+  # A much better UI/UX happens with human intervention.
+  # :nocov:
+  class Services < SolutionBase
+    def initialize
+      super
+      @uriparts << 'service'
+    end
+
+    def sid_for_name(name)
+      name = name.to_s unless name.kind_of? String
+      scr = list().select{|i| i[:alias] == name}.first
+      scr[:id]
+    end
+
+    def sid
+      return @sid unless @sid.nil?
+      @sid = sid_for_name(@serviceName)
+    end
+
+    def list
+      ret = get()
+      ret[:items]
+    end
+
+    def schema(id=sid)
+      # TODO: cache schema in user dir?
+      get("/#{id}/schema")
+    end
+
+    ## Get list of call operations from a schema
+    def callable(id=sid)
+      scm = schema(id)
+      calls = []
+      scm[:paths].each do |path, methods|
+        methods.each do |method, params|
+          if params.kind_of?(Hash) and
+              not params['x-internal-use'.to_sym] and
+              params.has_key?(:operationId) then
+            calls << [method, params[:operationId]]
+          end
+        end
+      end
+      calls
+    end
+  end
+  # :nocov:
+
+  # Device config interface for the assign commands.
+  class SC_Device < ServiceConfig
+    def initialize
+      super
+      @serviceName = 'device'
+    end
+
+    def assignTriggers(products)
+      details = fetch(scid)
+      products = [products] unless products.kind_of? Array
+      details[:triggers] = {:pid=>products}
+      details[:parameters] = {:pid=>products}
+
+      put('/'+scid, details)
+    end
+
+    def showTriggers
+      details = fetch(scid)
+
+      return [] if details[:triggers].nil?
+      details[:triggers][:pid]
+    end
+
+  end
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-Services.rb

@@ -0,0 +1,326 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'json'
+require 'yaml'
+require 'date'
+require 'digest/sha1'
+require 'MrMurano/Solution'
+
+module MrMurano
+  ##
+  # Things that servers do that is common.
+  class ServiceBase < SolutionBase
+
+    def mkalias(remote)
+      # :nocov:
+      raise "Needs to be implemented in child"
+      # :nocov:
+    end
+
+    def mkname(remote)
+      # :nocov:
+      raise "Needs to be implemented in child"
+      # :nocov:
+    end
+
+    def list
+      ret = get()
+      ret[:items]
+    end
+
+    def fetch(name)
+      raise "Missing name!" if name.nil?
+      raise "Empty name!" if name.empty?
+      ret = get('/'+CGI.escape(name))
+      error "Unexpected result type, assuming empty instead: #{ret}" unless ret.kind_of? Hash
+      ret = {} unless ret.kind_of? Hash
+      if block_given? then
+        yield (ret[:script] or '')
+      else
+        ret[:script] or ''
+      end
+    end
+
+    # ??? remove
+    def remove(name)
+      delete('/'+name)
+    end
+
+    # @param modify Bool: True if item exists already and this is changing it
+    def upload(local, remote, modify=false)
+      local = Pathname.new(local) unless local.kind_of? Pathname
+      raise "no file" unless local.exist?
+
+      # we assume these are small enough to slurp.
+      script = local.read
+
+      pst = remote.merge ({
+        :solution_id => $cfg['solution.id'],
+        :script => script,
+        :alias=>mkalias(remote),
+        :name=>mkname(remote),
+      })
+      debug "f: #{local} >> #{pst.reject{|k,_| k==:script}.to_json}"
+      # try put, if 404, then post.
+      put('/'+mkalias(remote), pst) do |request, http|
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+          #return JSON.parse(response.body)
+        when Net::HTTPNotFound
+          verbose "Doesn't exist, creating"
+          post('/', pst)
+        else
+          showHttpError(request, response)
+        end
+      end
+      cacheUpdateTimeFor(local)
+    end
+
+    def docmp(itemA, itemB)
+      if itemA[:updated_at].nil? and itemA[:local_path] then
+        ct = cachedUpdateTimeFor(itemA[:local_path])
+        itemA[:updated_at] = ct unless ct.nil?
+        itemA[:updated_at] = itemA[:local_path].mtime.getutc if ct.nil?
+      elsif itemA[:updated_at].kind_of? String then
+        itemA[:updated_at] = DateTime.parse(itemA[:updated_at]).to_time.getutc
+      end
+      if itemB[:updated_at].nil? and itemB[:local_path] then
+        ct = cachedUpdateTimeFor(itemB[:local_path])
+        itemB[:updated_at] = ct unless ct.nil?
+        itemB[:updated_at] = itemB[:local_path].mtime.getutc if ct.nil?
+      elsif itemB[:updated_at].kind_of? String then
+        itemB[:updated_at] = DateTime.parse(itemB[:updated_at]).to_time.getutc
+      end
+      return itemA[:updated_at].to_time.round != itemB[:updated_at].to_time.round
+    end
+
+    def cacheFileName
+      ['cache',
+       self.class.to_s.gsub(/\W+/,'_'),
+       @sid,
+       'yaml'].join('.')
+    end
+
+    def cacheUpdateTimeFor(local_path, time=nil)
+      time = Time.now.getutc if time.nil?
+      entry = {
+        :sha1=>Digest::SHA1.file(local_path.to_s).hexdigest,
+        :updated_at=>time.to_datetime.iso8601(3)
+      }
+      cacheFile = $cfg.file_at(cacheFileName)
+      if cacheFile.file? then
+        cacheFile.open('r+') do |io|
+          cache = YAML.load(io)
+          cache = {} unless cache
+          io.rewind
+          cache[local_path.to_s] = entry
+          io << cache.to_yaml
+        end
+      else
+        cacheFile.open('w') do |io|
+          cache = {}
+          cache[local_path.to_s] = entry
+          io << cache.to_yaml
+        end
+      end
+      time
+    end
+
+    def cachedUpdateTimeFor(local_path)
+      cksm = Digest::SHA1.file(local_path.to_s).hexdigest
+      cacheFile = $cfg.file_at(cacheFileName)
+      return nil unless cacheFile.file?
+      ret = nil
+      cacheFile.open('r') do |io|
+        cache = YAML.load(io)
+        return nil unless cache
+        if cache.has_key?(local_path.to_s) then
+          entry = cache[local_path.to_s]
+          debug("For #{local_path}:")
+          debug(" cached: #{entry.to_s}")
+          debug(" cm: #{cksm}")
+          if entry.kind_of?(Hash) then
+            if entry[:sha1] == cksm and entry.has_key?(:updated_at) then
+              ret = DateTime.parse(entry[:updated_at])
+            end
+          end
+        end
+      end
+      ret
+    end
+  end
+
+  # …/library
+  class Library < ServiceBase
+    def initialize
+      super
+      @uriparts << 'library'
+      @itemkey = :alias
+      @project_section = :modules
+    end
+
+    def tolocalname(item, key)
+      name = item[:name]
+      "#{name}.lua"
+    end
+
+    def mkalias(remote)
+      if remote.has_key? :name then
+        [$cfg['solution.id'], remote[:name]].join('_')
+      else
+        raise "Missing parts! #{remote.to_json}"
+      end
+    end
+
+    def mkname(remote)
+      if remote.has_key? :name then
+        remote[:name]
+      else
+        raise "Missing parts! #{remote.to_json}"
+      end
+    end
+
+    def toRemoteItem(from, path)
+      name = path.basename.to_s.sub(/\..*/, '')
+      {:name => name}
+    end
+
+    def synckey(item)
+      item[:name]
+    end
+  end
+  SyncRoot.add('modules', Library, 'M', %{Modules}, true)
+
+  # …/eventhandler
+  class EventHandler < ServiceBase
+    def initialize
+      super
+      @uriparts << 'eventhandler'
+      @itemkey = :alias
+      @project_section = :services
+      @match_header = /--#EVENT (?<service>\S+) (?<event>\S+)/
+    end
+
+    def mkalias(remote)
+      if remote.has_key? :service and remote.has_key? :event then
+        [$cfg['solution.id'], remote[:service], remote[:event]].join('_')
+      else
+        raise "Missing parts! #{remote.to_json}"
+      end
+    end
+
+    def mkname(remote)
+      if remote.has_key? :service and remote.has_key? :event then
+        [remote[:service], remote[:event]].join('_')
+      else
+        raise "Missing parts! #{remote.to_json}"
+      end
+    end
+
+    def list
+      ret = get()
+      # eventhandler.skiplist is a list of whitespace seperated dot-paired values.
+      # fe: service.event service service service.event
+      skiplist = ($cfg['eventhandler.skiplist'] or '').split
+      ret[:items].reject { |i|
+        i.has_key?(:service) and i.has_key?(:event) and
+        ( skiplist.include? i[:service] or
+          skiplist.include? "#{i[:service]}.#{i[:event]}"
+        )
+      }
+    end
+
+    def fetch(name)
+      ret = get('/'+CGI.escape(name))
+      if ret.nil? then
+        error "Fetch for #{name} returned nil; skipping"
+        return ''
+      end
+      aheader = (ret[:script].lines.first or "").chomp
+      dheader = "--#EVENT #{ret[:service]} #{ret[:event]}"
+      if block_given? then
+        yield dheader + "\n" if aheader != dheader
+        yield ret[:script]
+      else
+        res = ''
+        res << dheader + "\n" if aheader != dheader
+        res << ret[:script]
+        res
+      end
+    end
+
+    def tolocalname(item, key)
+      "#{item[:name]}.lua"
+    end
+
+    def toRemoteItem(from, path)
+      # This allows multiple events to be in the same file. This is a lie.
+      # This only finds the last event in a file.
+      # :legacy support doesn't allow for that. but that's ok.
+      path = Pathname.new(path) unless path.kind_of? Pathname
+      cur = nil
+      lineno=0
+      path.readlines().each do |line|
+        md = @match_header.match(line)
+        if not md.nil? then
+          # header line.
+          cur = {:service=>md[:service],
+                 :event=>md[:event],
+                 :local_path=>path,
+                 :line=>lineno,
+                 :script=>line}
+        elsif not cur.nil? and not cur[:script].nil? then
+          cur[:script] << line
+        end
+        lineno += 1
+      end
+      cur[:line_end] = lineno unless cur.nil?
+
+      # If cur is nil here, then we need to do a :legacy check.
+      if cur.nil? and $project['services.legacy'].kind_of? Hash then
+        spath = path.relative_path_from(from)
+        debug "No headers: #{spath}"
+        service, event = $project['services.legacy'][spath.to_s]
+        debug "Legacy lookup #{spath} => [#{service}, #{event}]"
+        unless service.nil? or event.nil? then
+          warning "Event in #{spath} missing header, but has legacy support."
+          warning "Please add the header \"--#EVENT #{service} #{event}\""
+          cur = {:service=>service,
+                 :event=>event,
+                 :local_path=>path,
+                 :line=>0,
+                 :line_end => lineno,
+                 :script=>path.read()} # FIXME: ick, fix this.
+        end
+      end
+      cur
+    end
+
+    def match(item, pattern)
+      # Pattern is: #{service}#{event}
+      pattern_pattern = /^#(?<service>[^#]*)#(?<event>.*)/i
+      md = pattern_pattern.match(pattern)
+      return false if md.nil?
+      debug "match pattern: '#{md[:service]}' '#{md[:event]}'"
+
+      unless md[:service].empty? then
+        return false unless item[:service].downcase == md[:service].downcase
+      end
+
+      unless md[:event].empty? then
+        return false unless item[:event].downcase == md[:event].downcase
+      end
+
+      true # Both match (or are empty.)
+    end
+
+    def synckey(item)
+      "#{item[:service]}_#{item[:event]}"
+    end
+  end
+  SyncRoot.add('eventhandlers', EventHandler, 'E', %{Event Handlers}, true)
+
+end
+#  vim: set ai et sw=2 ts=2 :