MrMurano 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 907d8f71d784965567eff90d5ca1d88e29e08b93
+  data.tar.gz: c97c0feb26e1f54898a8c24da2d1e84d30e7a6c0
+SHA512:
+  metadata.gz: 436e65b69681a6df929bcbd8fe8a55842363dd6f13abae114d35209d59d83c575d082e8fd01737693d368a725defd8116b6c1aa59e638c5e566a6f39121bce4a
+  data.tar.gz: 639221f5cb46bea583e71d3945e6a3b74043548fef47dea5b234e7dae232ca1a02db0c264a31150130947fb4e5802e8bb581e648a549e8ac571add4e15a57c09

data/.gitignore

@@ -0,0 +1,30 @@
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+*.sw[a-z]
+cookies
+.jiraProject
+.rpjProject
+tags
+
+xcuserdata
+Pods/
+pkg/
+
+.mrmuranorc
+files/
+endpoints/
+modules/
+eventhandlers/
+roles.yaml
+users.yaml
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+
+#gemspec
+
+gem 'commander', '~> 4.4.0'
+gem 'http-form_data', '~> 1.0.1'
+gem 'inifile', '~> 3.0'
+gem 'netrc', '~> 0.11.0'
+

data/MrMurano.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'mrmurano/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'MrMurano'
+  s.version     = MrMurano::VERSION
+  s.authors     = ['Michael Conrad Tadpol Tilstra']
+  s.email       = ['tadpol@tadpol.org']
+  s.license     = 'MIT'
+  s.homepage    = 'https://github.com/tadpol/MrMurano'
+  s.summary     = 'Do more from the command line with Murano'
+  s.description = %{Do more from the command line with Murano
+  
+  Push and pull data from Murano.
+  Get status on what things have changed.
+  See a diff of the changes before you push.
+  }
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency('commander', '~> 4.4.0')
+  s.add_runtime_dependency('inifile', '~> 3.0')
+  s.add_runtime_dependency('netrc', '~> 0.11.0')
+  s.add_runtime_dependency('http-form_data', '~> 1.0.1')
+
+  s.add_development_dependency('bundler', '~> 1.7.6')
+  s.add_development_dependency('rspec', '~> 3.2')
+  s.add_development_dependency('rake')
+end
+
+

data/README.markdown

@@ -0,0 +1,27 @@
+# MrMurano
+
+Do more from the command line with [Murano](https://exosite.com/platform/)
+
+## Usage
+
+To start from an existing project in Murano
+```
+mkdir myproject
+cd myproject
+mr syncdown --all
+```
+
+Do stuff, see what changed: `mr status --all` or `mr diff -same`.
+Then deploy `mr syncup --all`
+
+
+
+## Install
+
+Source install for now.
+```
+git clone … MrMurano
+cd MrMurano
+rake install
+```
+

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+
+#task :default => []
+
+# TODO: figure out better way to test.
+desc "Install gem in user dir"
+task :bob do
+	sh %{gem install --user-install pkg/MrMurano-#{Bundler::GemHelper.gemspec.version}.gem}
+end
+
+desc "Uninstall from user dir"
+task :unbob do
+	sh %{gem uninstall --user-install pkg/MrMurano-#{Bundler::GemHelper.gemspec.version}.gem}
+end
+
+task :echo do
+	puts "= #{Bundler::GemHelper.gemspec.version} ="
+end
+
+task :run do
+	sh %{ruby -Ilib bin/mr }
+end
+
+#  vim: set sw=4 ts=4 :
+

data/TODO.taskpaper

@@ -0,0 +1,45 @@
+
+Commands:
+	- Add Diff Command @done(2016-07-27)
+
+Endpoints:
+	- Add support for multiple endpoints in one file
+	- Add directory support like in modules @done(2016-07-26)
+  
+Files:
+	- Fix upload. @done(2016-08-01)
+	- Files won't update, they always delete then add. @done(2016-07-28)
+
+Users:
+	Much of this is stuck until we get more docs on the User/Role management
+	- Figure out how to upload (create and update) user info.
+	- Figure out how to add Roles to Users in the local data and upload it.
+	- Fix diff for Users and Roles.
+	- Have hash keys in the yaml be strings not symbols. (don't start with colon) @done(2016-07-27)
+
+Product:
+	- Need to add way to set the product ID on a device eventhandler. @done(2016-08-01)
+
+Config:
+	- Think about adding dev,staging,prod system; how would that work?
+
+SolutionBase:
+	- All network traffic is serialized. Make some parallel.
+	- Rebuild how local names and paths are computed from remote items. @done(2016-07-27)
+
+Bundles:
+	- Work on design
+	Thinking of something like VIM bundles.  A directory of directories. Each with a
+	manafest file? (maybe)  A Bundle is a group of modules, endpoints, static files
+	and the other things.  
+
+	There needs to be some layering logic added, where the bundles are stacked and
+	then the top-level files are stack on top of that. This builds the final map of
+	what gets uploaded to the server.
+
+	For syncdown, bundles are considered to be read-only.
+
+	The goal is to have things like Users or Debug that you just include into a
+	project.  And it gives all of the library, routes, statics and whatnot that you
+	need.
+

data/bin/mr

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander/import'
+require 'pathname'
+require 'MrMurano'
+require 'pp'
+
+program :version, MrMurano::VERSION
+program :description, %{Manage a Solution in Exosite's Murano}
+
+global_option('-V', '--verbose', 'Be chatty') {
+  $cfg['tool.verbose'] = true
+}
+global_option('-n', '--dry', %{Don't run actions that make changes}) {
+  $cfg['tool.dry'] = true
+  $cfg['tool.verbose'] = true # dry implies verbose
+}
+global_option '--skip-plugins', %{Don't load plugins. Good for when one goes bad.}
+
+global_option('-C', '--configfile FILE', %{Load additional configuration file}) {|file|
+  # this is called after all of the top level code in this file.
+  $cfg.load_specific(file)
+}
+global_option('-c', '--config KEY=VALUE', %{Set a single config key}) {|param|
+  key, value = param.split('=', 2)
+  raise "Bad config '#{param}'" if key.nil?
+  $cfg[key] = value
+}
+
+default_command :help
+#default_command :syncup
+
+$cfg = MrMurano::Config.new
+$cfg.load
+
+# Basic command support is:
+# - read/write config file in [Project, User, System] (all are optional)
+# - Introspection for tab completion.
+# - Look for tools in PATH that are +x and "mr-foo..." 
+
+
+# Look for plug-ins
+pgds = [
+  Pathname.new(Dir.home) + '.mrmurano' + 'plugins'
+]
+# Add plugin dirs from configs
+# This is run before the command line options are parsed, so need to check old way.
+if not ARGV.include? '--skip-plugins' then
+  pgds << Pathname.new(ENV['MR_MURANO_PLUGIN_DIR']) if ENV.has_key? 'MR_MURANO_PLUGIN_DIR'
+  pgds.each do |path|
+    next unless path.exist?
+    path.each_child do |plugin|
+      next if plugin.directory?
+      next unless plugin.readable?
+      next if plugin.basename.fnmatch('.*') # don't read anything starting with .
+      begin
+        require plugin.to_s
+      rescue Exception => e
+        $stderr.puts "Failed to load plugin at #{plugin} because #{e}"
+      end
+    end
+  end
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Account.rb

@@ -0,0 +1,176 @@
+require 'netrc'
+require 'uri'
+require 'net/http'
+require 'json'
+require 'date'
+require 'pp'
+require 'terminal-table'
+
+module MrMurano
+  class Account
+
+
+    def endPoint(path)
+      URI('https://' + $cfg['net.host'] + '/api:1/' + path.to_s)
+    end
+
+    def _password
+      host = $cfg['net.host']
+      user = $cfg['user.name']
+      if user.nil? then
+        user = ask("Account name: ")
+        $cfg['user.name'] = user
+      end
+      # Maybe in the future use Keychain.  For now all in Netrc.
+#      if (/darwin/ =~ RUBY_PLATFORM) != nil then
+#        # macOS
+#        pws = `security 2>&1 >/dev/null find-internet-password -gs "#{host}" -a "#{user}"`
+#        pws.strip!
+#        pws.sub!(/^password: "(.*)"$/, '\1')
+#        return pws
+      # Use Netrc
+      nrc = Netrc.read
+      ruser, pws = nrc[host]
+      pws = nil unless ruser == user
+      if pws.nil? then
+        pws = ask("Password:  ") { |q| q.echo = "*" }
+        nrc[host] = user, pws
+        nrc.save
+      end
+      pws
+    end
+
+    def token
+      if @token.nil? then
+        r = endPoint('token/')
+        Net::HTTP.start(r.host, r.port, :use_ssl=>true) do |http|
+          request = Net::HTTP::Post.new(r)
+          request.content_type = 'application/json'
+          #request.basic_auth(username(), password())
+          request.body = JSON.generate({
+            :email => $cfg['user.name'],
+            :password => _password
+          })
+
+          response = http.request(request)
+          case response
+          when Net::HTTPSuccess
+            token = JSON.parse(response.body)
+            @token = token['token']
+          else
+            say_error "No token! because: #{response}"
+            @token = nil
+            raise response
+          end
+        end
+      end
+      @token
+    end
+
+    def businesses
+      r = endPoint('user/' + $cfg['user.name'] + '/membership/')
+      Net::HTTP.start(r.host, r.port, :use_ssl=>true) do |http|
+        request = Net::HTTP::Get.new(r)
+        request.content_type = 'application/json'
+        request['authorization'] = 'token ' + token
+
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+          busy = JSON.parse(response.body)
+          return busy
+        else
+          raise response
+        end
+      end
+    end
+
+    def products
+      r = endPoint('business/' + $cfg['business.id'] + '/product/')
+      Net::HTTP.start(r.host, r.port, :use_ssl=>true) do |http|
+        request = Net::HTTP::Get.new(r)
+        request.content_type = 'application/json'
+        request['authorization'] = 'token ' + token
+
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+          busy = JSON.parse(response.body)
+          return busy
+        else
+          raise response
+        end
+      end
+    end
+
+    def solutions
+      r = endPoint('business/' + $cfg['business.id'] + '/solution/')
+      Net::HTTP.start(r.host, r.port, :use_ssl=>true) do |http|
+        request = Net::HTTP::Get.new(r)
+        request.content_type = 'application/json'
+        request['authorization'] = 'token ' + token
+
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+          busy = JSON.parse(response.body)
+          return busy
+        else
+          raise response
+        end
+      end
+    end
+
+  end
+end
+
+# This is largely for testing.
+command :account do |c|
+  c.syntax = %{mr account ...}
+  c.description = %{Show things about your account.}
+  c.option '--businesses', 'Get businesses for user'
+  c.option '--products', 'Get products for user (needs a business)'
+  c.option '--solutions', 'Get solutions for user (needs a business)'
+  c.option '--idonly', 'Only return the ids'
+
+  c.action do |args, options|
+
+    acc = MrMurano::Account.new
+
+    if options.businesses then
+      data = acc.businesses
+      if options.idonly then
+        say data.map{|row| row['bizid']}.join(' ')
+      else
+        busy = data.map{|row| [row['bizid'], row['role'], row['name']]}
+        table = Terminal::Table.new :rows => busy, :headings => ['Biz ID', 'Role', 'Name']
+        say table
+      end
+
+    elsif options.products then
+      data = acc.products
+      if options.idonly then
+        say data.map{|row| row['pid']}.join(' ')
+      else
+        busy = data.map{|r| [r['label'], r['type'], r['pid'], r['modelId']]}
+        table = Terminal::Table.new :rows => busy, :headings => ['Label', 'Type', 'PID', 'ModelID']
+        say table
+      end
+
+    elsif options.solutions then
+      data = acc.solutions
+      if options.idonly then
+        say data.map{|row| row['apiId']}.join(' ')
+      else
+        busy = data.map{|r| [r['apiId'], r['domain'], r['type'], r['sid']]}
+        table = Terminal::Table.new :rows => busy, :headings => ['API ID', 'Domain', 'Type', 'SID']
+        say table
+      end
+
+    else
+      say acc.token
+    end
+
+  end
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-Endpoint.rb

@@ -0,0 +1,107 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require 'pp'
+
+module MrMurano
+  # …/endpoint
+  class Endpoint < SolutionBase
+    def initialize
+      super
+      @uriparts << 'endpoint'
+    end
+
+    ##
+    # This gets all data about all endpoints
+    def list
+      get()
+    end
+
+    def fetch(id)
+      ret = get('/' + id.to_s)
+      aheader = ret['script'].lines.first.chomp
+      dheader = /^--#ENDPOINT (?i:#{ret['method']}) #{ret['path']}$/
+      if block_given? then
+        yield dheader + "\n" unless dheader =~ aheader
+        yield ret['script']
+      else
+        res = ''
+        res << dheader + "\n" unless dheader =~ aheader
+        res << ret['script']
+        res
+      end
+    end
+
+    ##
+    # Upload endpoint 
+    # :local path to file to push
+    # :remote hash of method and endpoint path
+    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
+      limitkeys = [:method, :path, :script, @itemkey]
+      remote = remote.select{|k,v| limitkeys.include? k }
+      remote[:script] = script
+#      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
+            say_error "got #{response} from #{request} #{request.uri.to_s}"
+            say_error ":: #{response.body}"
+          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 = item[:method].downcase
+      name << '_'
+      name << item[:path].gsub(/\//, '-')
+      name << '.lua'
+    end
+
+    def toremotename(from, path)
+      # read first line of file and get method/path from it?
+      path = Pathname.new(path) unless path.kind_of? Pathname
+      aheader = path.readlines().first
+      md = /--#ENDPOINT (\S+) (.*)/.match(aheader)
+      raise "Not an Endpoint: #{path.to_s}" if md.nil?
+      {:method=>md[1], :path=>md[2]}
+    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]
+    end
+
+  end
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Solution-File.rb

@@ -0,0 +1,137 @@
+require 'uri'
+require 'net/http'
+require "http/form_data"
+require 'digest/sha1'
+require 'mime/types'
+require 'pp'
+
+module MrMurano
+  # …/file 
+  class File < SolutionBase
+    def initialize
+      super
+      @uriparts << 'file'
+      @itemkey = :path
+    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
+            say_error "got #{resp.to_s} from #{request} #{request.uri.to_s}"
+            raise resp
+          end
+        end
+        nil
+      end
+    end
+
+    ##
+    # Delete a file
+    def remove(path)
+      # TODO test
+      delete('/'+path)
+    end
+
+    ##
+    # Upload a file
+    def upload(local, remote)
+      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.
+
+      form = HTTP::FormData.create(:file=>HTTP::FormData::File.new(local.to_s))
+      req = Net::HTTP::Put.new(uri)
+      workit(req) do |request,http|
+        request.content_type = form.content_type
+        request.content_length = form.content_length
+        request.body = form.to_s
+
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+        else
+          say_error "got #{response} from #{request} #{request.uri.to_s}"
+          say_error ":: #{response.body}"
+        end
+      end
+    end
+
+    def tolocalname(item, key)
+      name = item[key]
+      name = $cfg['files.default_page'] if name == '/'
+      name
+    end
+
+    def toremotename(from, path)
+      name = super(from, path)
+      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]
+
+      sha1 = Digest::SHA1.file(path.to_s).hexdigest
+
+      {:path=>name, :mime_type=>mime.simplified, :checksum=>sha1}
+    end
+
+    def synckey(item)
+      item[:path]
+    end
+
+    def docmp(itemA, itemB)
+      return (itemA[:mime_type] != itemB[:mime_type] or
+        itemA[:checksum] != itemB[:checksum])
+    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
+
+  end
+end
+#  vim: set ai et sw=2 ts=2 :