MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/Webservice-Cors.rb

@@ -0,0 +1,71 @@
+# Last Modified: 2017.08.17 /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 'json'
+require 'yaml'
+require 'MrMurano/Webservice'
+
+module MrMurano
+  module Webservice
+    class Settings < WebserviceBase
+      def initialize
+        super
+        @uriparts << :cors
+      end
+
+      def cors
+        ret = get
+        return {} unless ret.is_a?(Hash) && !ret.key?(:error)
+        ret
+      end
+
+      def cors=(x)
+        raise 'Not Hash' unless x.is_a? Hash
+        put('', x)
+      end
+    end
+
+    class Cors < WebserviceBase
+      def initialize
+        super
+        @uriparts << :cors
+        #@project_section = :cors
+      end
+
+      def fetch(_id=nil)
+        ret = get
+        return [] unless ret.is_a?(Hash) && !ret.key?(:error)
+        if ret.key?(:cors)
+          # XXX cors is a JSON encoded string. That seems weird. keep an eye on this.
+          data = JSON.parse(ret[:cors], @json_opts)
+        else
+          data = ret
+        end
+        if block_given?
+          yield Hash.transform_keys_to_strings(data).to_yaml
+        else
+          data
+        end
+      end
+
+      ##
+      # Upload CORS
+      # @param file [String,Nil] File path to upload other than defaults
+      def upload(file=nil)
+        if !file.nil?
+          data = YAML.load_file(file)
+        else
+          data = $project['routes.cors']
+          # If it is just a string, then is a file to load.
+          data = YAML.load_file(data) if data.is_a? String
+        end
+        put('', data)
+      end
+    end
+  end
+end
+

data/lib/MrMurano/Webservice-Endpoint.rb

@@ -0,0 +1,234 @@
+# Last Modified: 2017.08.17 /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 'json'
+require 'net/http'
+require 'pp'
+require 'uri'
+require 'MrMurano/SyncRoot'
+require 'MrMurano/Webservice'
+
+module MrMurano
+  # …/endpoint
+  module Webservice
+    class Endpoint < WebserviceBase
+
+      # Route Specific details on an Item
+      class RouteItem < Item
+        # @return [String] HTTP method for this endpoint
+        attr_accessor :method
+        # @return [String] path for URL maps to this endpoint
+        attr_accessor :path
+        # @return [String] Acceptable Content-Type for this endpoint
+        attr_accessor :content_type
+        # ???? What is this?
+        attr_accessor :use_basic_auth
+      end
+
+      def initialize
+        super
+        @uriparts << :endpoint
+        @project_section = :routes
+        @match_header = /--#ENDPOINT (?<method>\S+) (?<path>\S+)( (?<ctype>.*))?/
+      end
+
+      def self.description
+        # 2017-08-07: UI and ProjectFile call these "Routes". Let's be consistent.
+        # 2017-08-14: UI team says "Route" changing to "Endpoint" in new UI.
+        #%(Route)
+        %(Endpoint)
+      end
+
+      ##
+      # This gets all data about all endpoints
+      def list
+        ret = get
+        return [] unless ret.is_a?(Array)
+        ret.map do |item|
+          if item[:content_type].to_s.empty? then
+            item[:content_type] = 'application/json'
+          end
+          # XXX should this update the script header?
+          RouteItem.new(item)
+        end
+        # MAYBE/2017-08-17:
+        #   ret.map! ...
+        #   sort_by_name(ret)
+      end
+
+      def fetch(id)
+        ret = get('/' + id.to_s)
+        unless ret.is_a?(Hash) && !ret.key?(:error)
+          error "#{UNEXPECTED_TYPE_OR_ERROR_MSG}: #{ret}"
+          ret = {}
+        end
+
+        ret[:content_type] = 'application/json' if ret[:content_type].empty?
+
+        script = ret[:script].lines.map{|l|l.chomp}
+
+        aheader = (script.first or "")
+
+        rh = ['--#ENDPOINT', ret[:method].upcase, ret[:path]]
+        rh << ret[:content_type] if ret[:content_type] != 'application/json'
+        rheader = rh.join(' ')
+
+        # if header is missing add it.
+        # If header is wrong, replace it.
+
+        md = @match_header.match(aheader)
+        if md.nil? then
+          # header missing.
+          script.unshift rheader
+        elsif md[:method] != ret[:method] or
+          md[:path] != ret[:path] or
+          md[:ctype] != ret[:content_type] then
+          # header is wrong.
+          script[0] = rheader
+        end
+        # otherwise current header is good.
+
+        script = script.join("\n") + "\n"
+        if block_given? then
+          yield script
+        else
+          script
+        end
+      end
+
+      ##
+      # Upload endpoint
+      # @param local [Pathname] path to file to push
+      # @param remote [RouteItem] of method and endpoint path
+      # @param modify [Boolean] True if item exists already and this is changing it
+      def upload(local, remote, modify)
+        local = Pathname.new(local) unless local.kind_of? Pathname
+        raise "no file" unless local.exist?
+        # we assume these are small enough to slurp.
+        if remote.script.nil? then
+          script = local.read
+          remote[:script] = script
+        end
+        limitkeys = [:method, :path, :script, :content_type, @itemkey]
+        remote = remote.to_h.select{|k,v| limitkeys.include? k }
+        #      post('', remote)
+        if remote.has_key? @itemkey then
+          put('/' + remote[@itemkey], remote) do |request, http|
+            response = http.request(request)
+            case response
+            when Net::HTTPSuccess
+              #return JSON.parse(response.body)
+            when Net::HTTPNotFound
+              verbose "\tDoesn't exist, creating"
+              post('/', remote)
+            else
+              showHttpError(request, response)
+            end
+          end
+        else
+          verbose "\tNo itemkey, creating"
+          post('', remote)
+        end
+      end
+
+      ##
+      # Delete an endpoint
+      def remove(id)
+        delete('/' + id.to_s)
+      end
+
+      def tolocalname(item, key)
+        name = ''
+        # 2017-07-02: Changing shovel operator << to +=
+        # to support Ruby 3.0 frozen string literals.
+        name += item[:path].split('/').reject { |i| i.empty? }.join('-')
+        name += '.'
+        # This downcase is just for the filename.
+        name += item[:method].downcase
+        name += '.lua'
+      end
+
+      def to_remote_item(from, path)
+        # Path could be have multiple endpoints in side, so a loop.
+        items = []
+        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[:line_end] = lineno unless cur.nil?
+            items << cur unless cur.nil?
+            # VERIFY/2017-07-03: The syncdown test is revealing a
+            #   problem with casing. The original file has a lowercase
+            #   HTTP verb, e.g., "post". This is what syncup uploaded.
+            #   But on murano status, the local route's method is upcased
+            #   in memory, so the status command says the route is diff.
+            #   But on murano diff, MurCLI makes two local temp files
+            #   to execute the diff, and it also upcases the method in
+            #   both files, so the diff runs clean!
+            #   VERIFY/2017-07-03: [lb] adding upcase here; hope that works!
+            #   OHOHOH/2017-07-03: [lb] also recreating the header line.
+            up_line = "--#ENDPOINT #{md[:method].upcase} #{md[:path]}"
+            up_line += " #{md[:ctype]}" unless md[:ctype].to_s.empty?
+            up_line += "\n"
+            cur = RouteItem.new(
+              #method: md[:method],
+              method: md[:method].upcase,
+              path: md[:path],
+              content_type: (md[:ctype] or 'application/json'),
+              local_path: path,
+              line: lineno,
+              script: up_line,
+            )
+          elsif not cur.nil? and not cur[:script].nil? then
+            # 2017-07-02: Frozen string literal: change << to +=
+            cur[:script] += line
+          end
+          lineno += 1
+        end
+        cur[:line_end] = lineno unless cur.nil?
+        items << cur unless cur.nil?
+        items
+      end
+
+      def match(item, pattern)
+        # Pattern is: #{method}#{path glob}
+        pattern_pattern = /^#(?<method>[^#]*)#(?<path>.*)/i
+        md = pattern_pattern.match(pattern)
+        return false if md.nil?
+        debug "match pattern: '#{md[:method]}' '#{md[:path]}'"
+
+        unless md[:method].empty? then
+          return false unless item[:method].casecmp(md[:method]).zero?
+        end
+
+        return true if md[:path].empty?
+
+        ::File.fnmatch(md[:path],item[:path])
+      end
+
+      def synckey(item)
+        "#{item[:method].upcase}_#{item[:path]}"
+      end
+
+      def docmp(itemA, itemB)
+        if itemA[:script].nil? and itemA[:local_path] then
+          itemA[:script] = itemA[:local_path].read
+        end
+        if itemB[:script].nil? and itemB[:local_path] then
+          itemB[:script] = itemB[:local_path].read
+        end
+        return (itemA[:script] != itemB[:script] or itemA[:content_type] != itemB[:content_type])
+      end
+    end
+
+    SyncRoot.instance.add('endpoints', Endpoint, 'E', true, %w[routes])
+  end
+end
+

data/lib/MrMurano/Webservice-File.rb

@@ -0,0 +1,193 @@
+require 'digest/sha1'
+require "http/form_data"
+require 'mime/types'
+require 'net/http'
+require 'uri'
+require 'MrMurano/Webservice'
+require 'MrMurano/SyncRoot'
+
+module MrMurano
+  module Webservice
+    # Static File content
+    class File < WebserviceBase
+      # File Specific details on an Item
+      class FileItem < Item
+        # @return [String] path for URL maps to this static file
+        attr_accessor :path
+        # @return [String] The MIME-Type for this content
+        attr_accessor :mime_type
+        # @return [String] Checksum for the content.
+        attr_accessor :checksum
+      end
+
+      def initialize
+        super
+        @uriparts << :file
+        @itemkey = :path
+        @project_section = :assets
+      end
+
+      def self.description
+        # 2017-08-07: The UI calls these ASSETS in the tab
+        # (and refers to "Static file hosting").
+        #%(Static File)
+        %(Asset)
+      end
+
+      ##
+      # Get a list of all of the static content
+      # @return [Array<FileItem>] List of items on server
+      def list
+        ret = get
+        return [] unless ret.is_a?(Array)
+        ret.map { |i| FileItem.new(i) }
+        # MAYBE/2017-08-17:
+        #   ret.map! { |i| FileItem.new(i) }
+        #   sort_by_name(ret)
+      end
+
+      ##
+      # Get one item of the static content.
+      def fetch(path, &block)
+        path = path[1..-1] if path[0] == '/'
+        path = '/'+ URI.encode_www_form_component(path)
+        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
+      # @param path [String] The identifying key for this item
+      def remove(path)
+        path = path[1..-1] if path[0] == '/'
+        delete('/' + URI.encode_www_form_component(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 src [Pathname] Full path of where to upload from
+      # @param item [Hash] The item details to upload
+      # @param modify [Boolean] True if item exists already and this is changing it
+      def upload(local, remote, modify)
+        local = Pathname.new(local) unless local.kind_of? Pathname
+
+        path = remote[:path]
+        path = path[1..-1] if path[0] == '/'
+        uri = endpoint('upload/' + URI.encode_www_form_component(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, { content_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}}
+            if $cfg.curlfile_f.nil?
+              puts a.join(' ')
+            else
+              $cfg.curlfile_f << a.join(' ') + "\n\n"
+              $cfg.curlfile_f.flush
+            end
+          end
+
+          response = http.request(request)
+          showHttpError(request, response) unless response.is_a?(Net::HTTPSuccess)
+        end
+      end
+
+      # @param item [Item] listing details for the item.
+      # @param itemkey [Symbol] Key for look up.
+      def tolocalname(item, key)
+        name = item[key]
+        name = $cfg['files.default_page'] if name == '/'
+        name
+      end
+
+      # @param root [Pathname,String] Root path for this resource type from config files
+      # @param path [Pathname,String] Path to local item
+      # @return [Item] hash of the details for the remote item for this path
+      def to_remote_item(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})"
+
+        FileItem.new(:path=>name, :mime_type=>mime.simplified, :checksum=>sha1.hexdigest)
+      end
+
+      # @param item [FileItem] The item to get a key from
+      # @return [Object] The object to use a comparison key
+      def synckey(item)
+        item[:path]
+      end
+
+      # Compare items.
+      # @param itemA [FileItem]
+      # @param itemB [FileItem]
+      def docmp(itemA, itemB)
+        return (itemA[:mime_type] != itemB[:mime_type] or
+          itemA[:checksum] != itemB[:checksum])
+      end
+    end
+
+    SyncRoot.instance.add('assets', File, 'A', true, %w[files])
+  end
+end
+#  vim: set ai et sw=2 ts=2 :