MrMurano 1.0.0

data/lib/MrMurano/Solution-ServiceConfig.rb

@@ -0,0 +1,86 @@
+require 'terminal-table'
+
+module MrMurano
+  # …/serviceconfig
+  class ServiceConfig < SolutionBase
+    def initialize
+      super
+      @uriparts << 'serviceconfig'
+    end
+
+    def list
+      get()['items']
+    end
+    def fetch(id)
+      get('/' + id.to_s)
+    end
+
+
+    def assignTriggers(products)
+      scr = list().select{|i| i['service'] == 'device' or i[:service] == 'device'}.first
+      scid = scr['id'] or scr[:id]
+
+      details = Hash.transform_keys_to_symbols(fetch(scid))
+      products = [products] unless products.kind_of? Array
+      details[:triggers] = {:pid=>products}
+
+      put('/'+scid, details)
+      
+    end
+
+    def showTriggers
+      scr = list().select{|i| i['service'] == 'device' or i[:service] == 'device'}.first
+      scid = scr['id'] or scr[:id]
+
+      details = Hash.transform_keys_to_symbols(fetch(scid))
+
+      return [] if details[:triggers].nil?
+      details[:triggers][:pid]
+    end
+
+  end
+end
+
+command :assign do |c|
+  c.syntax = 'mr assign [product]'
+  c.description = 'Assign a product to a eventhandler'
+
+  c.option '--list', %{List assigned products}
+  c.option '--idonly', 'Only return the ids'
+
+  c.action do |args, options|
+    sol = MrMurano::ServiceConfig.new
+
+    if options.list then
+      trigs = sol.showTriggers()
+      if options.idonly then
+        say trigs.join(' ')
+      else
+        acc = MrMurano::Account.new
+        products = acc.products.map{|p| Hash.transform_keys_to_symbols(p)}
+        products.select!{|p| trigs.include? p[:pid] }
+        busy = products.map{|r| [r[:label], r[:type], r[:pid], r[:modelId]]}
+        table = Terminal::Table.new :rows => busy, :headings => ['Label', 'Type', 'PID', 'ModelID']
+        say table
+      end
+
+    else
+      prname = args.shift
+      if prname.nil? then
+        prid = $cfg['product.id']
+      else
+        acc = MrMurano::Account.new
+        products = acc.products.map{|p| Hash.transform_keys_to_symbols(p)}
+        products.select!{|p| p[:label] == prname or p[:pid] == prname }
+        prid = products.map{|p| p[:pid]}
+      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
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-Services.rb

@@ -0,0 +1,163 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require 'pp'
+
+module MrMurano
+  ##
+  # Things that servers do that is common.
+  class ServiceBase < SolutionBase
+    # not quite sure why this is needed, but…
+    def mkalias(name)
+      case name
+      when String
+        "/#{$cfg['solution.id']}_#{name}"
+      when Hash
+        if name.has_key? :name then
+          "/#{$cfg['solution.id']}_#{name[:name]}"
+        elsif name.has_key? :service and name.has_key? :event then
+          "/#{$cfg['solution.id']}_#{name[:service]}_#{name[:event]}"
+        else
+          raise "unknown keys. #{name}"
+        end
+      else
+        raise "unknown type. #{name}"
+      end
+    end
+
+    def list
+      ret = get()
+      ret['items']
+    end
+
+    def fetch(name)
+      ret = get('/'+name)
+      if block_given? then
+        yield ret['script']
+      else
+        ret['script']
+      end
+    end
+
+    # ??? remove
+    def remove(name)
+      delete('/'+name)
+    end
+
+    def upload(local, remote)
+      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
+      })
+
+      # 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
+          say_error "got #{response} from #{request} #{request.uri.to_s}"
+          say_error ":: #{response.body}"
+        end
+      end
+    end
+
+    def docmp(itemA, itemB)
+      if itemA[:updated_at].nil? and itemA[:local_path] then
+        itemA[:updated_at] = itemA[:local_path].mtime.getutc
+      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
+        itemB[:updated_at] = itemB[:local_path].mtime.getutc
+      elsif itemB[:updated_at].kind_of? String then
+        itemB[:updated_at] = DateTime.parse(itemB[:updated_at]).to_time.getutc
+      end
+      return itemA[:updated_at] != itemB[:updated_at]
+    end
+
+  end
+
+  # …/library
+  class Library < ServiceBase
+    def initialize
+      super
+      @uriparts << 'library'
+      @itemkey = :alias
+    end
+
+    def tolocalname(item, key)
+      name = item[:name]
+      "#{name}.lua"
+    end
+
+
+    def toremotename(from, path)
+      name = path.basename.to_s.sub(/\..*/, '')
+      {:name => name}
+    end
+
+    def synckey(item)
+      item[:name]
+    end
+  end
+
+  # …/eventhandler
+  class EventHandler < ServiceBase
+    def initialize
+      super
+      @uriparts << 'eventhandler'
+      @itemkey = :alias
+    end
+
+    def list
+      ret = get()
+      skiplist = ($cfg['eventhandler.skiplist'] or '').split
+      ret['items'].reject{|i| i.has_key?('service') and skiplist.include? i['service'] }
+    end
+
+    def fetch(name)
+      ret = get('/'+name)
+      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 toremotename(from, path)
+      path = Pathname.new(path) unless path.kind_of? Pathname
+      aheader = path.readlines().first
+      md = /--#EVENT (\S+) (\S+)/.match(aheader)
+      raise "Not an Event handler: #{path.to_s}" if md.nil?
+      {:service=>md[1], :event=>md[2]}
+    end
+
+    def synckey(item)
+      "#{item[:service]}_#{item[:event]}"
+    end
+  end
+
+  # How do we enable product.id to flow into the eventhandler?
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-Users.rb

@@ -0,0 +1,123 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require 'yaml'
+require 'pp'
+
+module MrMurano
+  ##
+  # User Management common things
+  class UserBase < SolutionBase
+    def list()
+      get()
+    end
+
+    def fetch(id)
+      get('/' + id.to_s)
+    end
+
+    def remove(id)
+      delete('/' + id.to_s)
+    end
+
+    def upload(local, remote)
+      # Roles cannot be modified, so must delete and post.
+      delete('/' + remote[@itemkey]) do |request, http|
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+        when Net::HTTPNotFound
+        else
+          say_error "got #{response} from #{request} #{request.uri.to_s}"
+          say_error ":: #{response.body}"
+        end
+      end
+      post('/', remote)
+    end
+
+    def download(local, item)
+      # needs to append/merge with file
+      # for now, we'll read, modify, write
+      here = []
+      if local.exist? then
+        local.open('rb') {|io| here = YAML.load(io)}
+        here = [] if here == false
+      end
+      here.delete_if do |i|
+        Hash.transform_keys_to_symbols(i)[@itemkey] == item[@itemkey]
+      end
+      here << item
+      local.open('wb') do |io|
+        io.write here.map{|i| Hash.transform_keys_to_strings(i)}.to_yaml
+      end
+    end
+
+    def removelocal(dest, item)
+      # needs to append/merge with file
+      # for now, we'll read, modify, write
+      here = []
+      if local.exist? then
+        local.open('rb') {|io| here = YAML.load(io)}
+        here = [] if here == false
+      end
+      key = @itemkey.to_sym
+      here.delete_if do |it|
+        Hash.transform_keys_to_symbols(it)[key] == item[key]
+      end
+      local.open('wb') do|io|
+        io.write here.map{|i| Hash.transform_keys_to_strings(i)}.to_yaml
+      end
+    end
+
+    def tolocalpath(into, item)
+      into
+    end
+
+    def locallist(from)
+      from = Pathname.new(from) unless from.kind_of? Pathname
+      if not from.exist? then
+        say_warning "Skipping missing #{from.to_s}"
+        return []
+      end
+      unless from.file? then
+        say_warning "Cannot read from #{from.to_s}"
+        return []
+      end
+      key = @itemkey.to_sym
+
+      here = []
+      from.open {|io| here = YAML.load(io) }
+      here = [] if here == false
+
+      here
+    end
+  end
+
+  # …/role
+  class Role < UserBase
+    def initialize
+      super
+      @uriparts << 'role'
+      @itemkey = :role_id
+    end
+  end
+
+  # …/user
+  class User < UserBase
+    def initialize
+      super
+      @uriparts << 'user'
+    end
+
+    def upload(local, remote)
+      # TODO figure out APIs for updating users.
+      say_warning "Updating Users isn't working currently."
+      # post does work if the :password field is set.
+    end
+
+    def synckey(item)
+      item[:email]
+    end
+  end
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution.rb

@@ -0,0 +1,318 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require 'pp'
+
+module MrMurano
+  class SolutionBase
+    # This might also be a valid ProductBase.
+    def initialize
+      @token = Account.new.token
+      @sid = $cfg['solution.id']
+      raise "No solution!" if @sid.nil?
+      @uriparts = [:solution, @sid]
+      @itemkey = :id
+    end
+
+    def verbose(msg)
+      if $cfg['tool.verbose'] then
+        say msg
+      end
+    end
+
+    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
+    def http
+      uri = URI('https://' + $cfg['net.host'])
+      if @http.nil? then
+        @http = Net::HTTP.new(uri.host, uri.port)
+        @http.use_ssl = true
+        @http.start
+      end
+      @http
+    end
+
+    def set_req_defaults(request)
+      request.content_type = 'application/json'
+      request['authorization'] = 'token ' + @token
+      request['User-Agent'] = "MrMurano/#{MrMurano::VERSION}"
+      request
+    end
+
+    def workit(request, &block)
+      set_req_defaults(request)
+      if block_given? then
+        yield request, http()
+      else
+        response = http().request(request)
+        case response
+        when Net::HTTPSuccess
+          return {} if response.body.nil?
+          begin
+            return JSON.parse(response.body)
+          rescue
+            return response.body
+          end
+        else
+          say_error "got #{response} from #{request} #{request.uri.to_s}"
+          say_error ":: #{response.body}"
+          raise response
+        end
+      end
+    end
+
+    def get(path='', &block)
+      uri = endPoint(path)
+      workit(Net::HTTP::Get.new(uri), &block) 
+    end
+
+    def post(path='', body={}, &block)
+      uri = endPoint(path)
+      req = Net::HTTP::Post.new(uri)
+      req.body = JSON.generate(body)
+      workit(req, &block)
+    end
+
+    def put(path='', body={}, &block)
+      uri = endPoint(path)
+      req = Net::HTTP::Put.new(uri)
+      req.body = JSON.generate(body)
+      workit(req, &block)
+    end
+
+    def delete(path='', &block)
+      uri = endPoint(path)
+      workit(Net::HTTP::Delete.new(uri), &block)
+    end
+
+    # …
+
+    def toremotename(root, path)
+      path = Pathname.new(path) unless path.kind_of? Pathname
+      root = Pathname.new(root) unless root.kind_of? Pathname
+      path.relative_path_from(root).to_s
+    end
+    def tolocalpath(into, item)
+      into.mkpath unless $cfg['tool.dry']
+      return item[:local_path] if item.has_key? :local_path
+      itemkey = @itemkey.to_sym
+      name = tolocalname(item, itemkey)
+      raise "Bad key(#{itemkey}) for #{item}" if name.nil?
+      dest = into + name
+    end
+
+    def locallist(from)
+      from = Pathname.new(from) unless from.kind_of? Pathname
+      unless from.exist? then
+        return []
+      end
+      raise "Not a directory: #{from.to_s}" unless from.directory?
+
+      Pathname.glob(from.to_s + '/**/*').map do |path|
+        name = toremotename(from, path)
+        case name
+        when Hash
+          name[:local_path] = path
+          name
+        else
+          {:local_path => path, :name => name}
+        end
+      end
+    end
+
+    def synckey(item)
+      key = @itemkey.to_sym
+      item[key]
+    end
+
+    def syncup(from, options={})
+      there = list()
+      here = locallist(from)
+      itemkey = @itemkey.to_sym
+ 
+      # split into three lists.
+      # - Items here and not there. (toadd)
+      # - Items there and not here. (todel)
+      # - Items here and there. (tomod)
+      therebox = {}
+      there.each do |item|
+        item = Hash.transform_keys_to_symbols(item)
+        therebox[ synckey(item) ] = item
+      end
+      herebox = {}
+      here.each do |item|
+        item = Hash.transform_keys_to_symbols(item)
+        herebox[ synckey(item) ] = item
+      end
+      toadd = herebox.keys - therebox.keys
+      todel = therebox.keys - herebox.keys
+      tomod = herebox.keys & therebox.keys
+
+      if options.delete then
+        todel.each do |key|
+          verbose "Removing item #{key}"
+          unless $cfg['tool.dry'] then
+            item = therebox[key]
+            remove(item[itemkey])
+          end
+        end
+      end
+      if options.create then
+        toadd.each do |key|
+          verbose "Adding item #{key}"
+          unless $cfg['tool.dry'] then
+            item = herebox[key]
+            upload(item[:local_path], item.reject{|k,v| k==:local_path})
+          end
+        end
+      end
+      if options.update then
+        tomod.each do |key|
+          verbose "Updating item #{key}"
+          unless $cfg['tool.dry'] then
+            #item = therebox[key].merge herebox[key] # need to be consistent with key types for this to work
+            id = therebox[key][itemkey]
+            item = herebox[key].dup
+            item[itemkey] = id
+            upload(item[:local_path], item.reject{|k,v| k==:local_path})
+          end
+        end
+      end
+    end
+
+    def syncdown(into, options={})
+      there = list()
+      into = Pathname.new(into) unless into.kind_of? Pathname
+      here = locallist(into)
+      itemkey = @itemkey.to_sym
+ 
+      # split into three lists.
+      # - Items here and not there. (todel)
+      # - Items there and not here. (toadd)
+      # - Items here and there. (tomod)
+      therebox = {}
+      there.each do |item|
+        item = Hash.transform_keys_to_symbols(item)
+        therebox[ synckey(item) ] = item
+      end
+      herebox = {}
+      here.each do |item|
+        item = Hash.transform_keys_to_symbols(item)
+        herebox[ synckey(item) ] = item
+      end
+      todel = herebox.keys - therebox.keys
+      toadd = therebox.keys - herebox.keys
+      tomod = herebox.keys & therebox.keys
+
+      if options.delete then
+        todel.each do |key|
+          verbose "Removing item #{key}"
+          unless $cfg['tool.dry'] then
+            item = herebox[key]
+            dest = tolocalpath(into, item)
+            removelocal(dest, item)
+          end
+        end
+      end
+      if options.create then
+        toadd.each do |key|
+          verbose "Adding item #{key}"
+          unless $cfg['tool.dry'] then
+            item = therebox[key]
+            dest = tolocalpath(into, item)
+
+            download(dest, item)
+          end
+        end
+      end
+      if options.update then
+        tomod.each do |key|
+          verbose "Updating item #{key}"
+          unless $cfg['tool.dry'] then
+            item = therebox[key]
+            dest = tolocalpath(into, herebox[key].merge(item) )
+
+            download(dest, item)
+          end
+        end
+      end
+    end
+
+    def download(local, item)
+      id = item[@itemkey.to_sym]
+      local.open('wb') do |io|
+        fetch(id) do |chunk|
+          io.write chunk
+        end
+      end
+    end
+
+    def removelocal(dest, item)
+      dest.unlink
+    end
+
+    def status(from, options={})
+      there = list()
+      here = locallist(from)
+      itemkey = @itemkey.to_sym
+ 
+      therebox = {}
+      there.each do |item|
+        item = Hash.transform_keys_to_symbols(item)
+        item[:synckey] = synckey(item)
+        therebox[ item[:synckey] ] = item
+      end
+      herebox = {}
+      here.each do |item|
+        item = Hash.transform_keys_to_symbols(item)
+        item[:synckey] = synckey(item)
+        herebox[ item[:synckey] ] = item
+      end
+      if options.asdown then
+        todel = herebox.keys - therebox.keys
+        toadd = therebox.keys - herebox.keys
+        tomod = herebox.keys & therebox.keys
+        {
+          :toadd=> toadd.map{|key| therebox[key] },
+          :todel=> todel.map{|key| herebox[key] },
+          # FIXME what if therebox[key] is nil?
+          :tomod=> tomod.map{|key| therebox[key].merge(herebox[key]) }
+        }
+      else
+        toadd = herebox.keys - therebox.keys
+        todel = therebox.keys - herebox.keys
+        tomod = herebox.keys & therebox.keys
+        {
+          :toadd=> toadd.map{|key| herebox[key] },
+          :todel=> todel.map{|key| therebox[key] },
+          :tomod=> tomod.map{|key| therebox[key].merge(herebox[key]) }
+        }
+      end
+    end
+  end
+
+  class Solution < SolutionBase
+    def version
+      get('/version')
+    end
+
+    def info
+      get()
+    end
+
+    def list
+      get('/')
+    end
+
+    def log
+      get('/logs')
+    end
+
+  end
+
+end
+
+#  vim: set ai et sw=2 ts=2 :