MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/Solution-Cors.rb

@@ -1,47 +0,0 @@
-require 'yaml'
-require 'json'
-require 'MrMurano/hash'
-require 'MrMurano/Solution'
-
-module MrMurano
-  class Cors < SolutionBase
-    def initialize
-      super
-      @uriparts << 'cors'
-      @project_section = :cors
-    end
-
-    def fetch(id=nil, &block)
-      ret = get()
-      return [] if ret.is_a? Hash and ret.has_key? :error
-      if ret.kind_of?(Hash) and ret.has_key?(:cors) then
-        # 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? then
-        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)
-      unless file.nil? then
-        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.kind_of? String
-      end
-      put('', data)
-    end
-
-  end
-end
-
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-Endpoint.rb

@@ -1,191 +0,0 @@
-require 'uri'
-require 'net/http'
-require 'json'
-require 'pp'
-require 'MrMurano/Solution'
-
-module MrMurano
-  # …/endpoint
-  class Endpoint < SolutionBase
-    # 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
-
-    ##
-    # This gets all data about all endpoints
-    def list
-      ret = get()
-      return [] if ret.is_a? Hash and ret.has_key? :error
-      ret.map do |item|
-        if item[:content_type].nil? or item[:content_type].empty? then
-          item[:content_type] = 'application/json'
-        end
-        # XXX should this update the script header?
-        RouteItem.new(item)
-      end
-    end
-
-    def fetch(id)
-      ret = get('/' + id.to_s)
-      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 = ''
-      name << item[:path].split('/').reject{|i|i.empty?}.join('-')
-      name << '.'
-      name << item[:method].downcase
-      name << '.lua'
-    end
-
-    def toRemoteItem(from, path)
-      # Path could be have multiple endpoints inside, 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?
-          cur = RouteItem.new(:method=>md[:method],
-                              :path=>md[:path],
-                              :content_type=> (md[:ctype] or 'application/json'),
-                              :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?
-      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].downcase == md[:method].downcase
-      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.add('endpoints', Endpoint, 'A', %{Endpoints}, true)
-end
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-File.rb

@@ -1,166 +0,0 @@
-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
-    # 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
-
-    ##
-    # Get a list of all of the static content
-    def list
-      ret = get()
-      return [] if ret.is_a? Hash and ret.has_key? :error
-      ret.map{|i| FileItem.new(i)}
-    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
-    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 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
-
-      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}}
-          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})"
-
-      FileItem.new(: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/commands/assign.rb

@@ -1,57 +0,0 @@
-require 'terminal-table'
-
-command 'assign list' do |c|
-  c.syntax = 'murano assign list [options]'
-  c.description = 'List the products that are assigned'
-  c.option '--idonly', 'Only return the ids'
-
-  c.action do |args, options|
-    sol = MrMurano::SC_Device.new
-
-    trigs = sol.showTriggers()
-    options.idonly = true if $cfg['business.id'].nil?
-
-    if options.idonly then
-      say trigs.join(' ')
-    else
-      acc = MrMurano::Account.new
-      products = acc.products
-      products.select!{|p| trigs.include? p[:modelId] }
-      if products.empty? then
-        say trigs.join(' ')
-      else
-        busy = products.map{|r| [r[:label], r[:modelId]]}
-        table = Terminal::Table.new :rows => busy, :headings => ['Label', 'ModelID']
-        say table
-      end
-    end
-  end
-end
-alias_command :assign, 'assign list'
-
-command 'assign set' do |c|
-  c.syntax = 'murano assign set [product]'
-  c.description = 'Assign a product to a eventhandler'
-
-  c.action do |args, options|
-    sol = MrMurano::SC_Device.new
-
-    prname = args.shift
-    if prname.nil? then
-      prid = $cfg['product.id']
-    else
-      acc = MrMurano::Account.new
-      products = acc.products
-      products.select!{|p|
-        p[:label] == prname or p[:modelId] == prname or p[:pid] == prname
-      }
-      prid = products.map{|p| p[:modelId]}
-    end
-    raise "No product ID!" if prid.nil?
-    say "Assigning #{prid} to solution" if $cfg['tool.verbose']
-    sol.assignTriggers(prid) unless $cfg['tool.dry']
-  end
-
-end
-
-#  vim: set ai et sw=2 ts=2 :