haplo 2.1.0-java

data/lib/local_config.rb

@@ -0,0 +1,28 @@
+
+module PluginTool
+
+  module LocalConfig
+
+    LOCAL_CONFIG_FILENAME = "server.config.json"
+
+    def self.load
+      if File.exist? LOCAL_CONFIG_FILENAME
+        @@local_config = JSON.parse(File.open(LOCAL_CONFIG_FILENAME) { |f| f.read })
+      else
+        @@local_config = {}
+      end
+    end
+
+    def self.get_list(list_name)
+      lookup = @@local_config[list_name]
+      return [] unless lookup
+      list = []
+      server_name = PluginTool.get_server_hostname
+      list.concat(lookup['*']) if lookup.has_key?('*')
+      list.concat(lookup[server_name]) if server_name && lookup.has_key?(server_name)
+      list
+    end
+
+  end
+
+end

data/lib/manifest.rb

@@ -0,0 +1,44 @@
+
+module PluginTool
+  
+  # NOTE: Also update packing.rb if this changes
+  ALLOWED_PLUGIN_DIRS = ['js', 'static', 'template', 'test', 'data']
+  
+  def self.generate_manifest(directory)
+    manifest = Hash.new
+    Dir.glob("#{directory}/**/*").sort.each do |pathname|
+      # Ignore directories
+      next unless File.file? pathname
+      # Ignore Emacs backup files
+      next if pathname =~ /\~\z/
+      # Check file
+      filename = pathname.slice(directory.length + 1, pathname.length)
+      raise "Bad filename for #{filename}" unless filename =~ /\A([a-zA-Z0-9_\/\-]+\/)?([a-z0-9_-]+\.[a-z0-9]+)\z/
+      dir = $1
+      name = $2
+      if dir != nil
+        dir = dir.gsub(/\/\z/,'')
+        raise "Bad directory #{dir}" unless dir =~ /\A([a-zA-Z0-9_\-]+)[a-zA-Z0-9_\/\-]*\z/
+        raise "Bad root directory #{$1}" unless ALLOWED_PLUGIN_DIRS.include?($1)
+      end
+      # Get hash of file
+      digest = File.open(pathname) { |f| Digest::SHA256.hexdigest(f.read) }
+      # And add to manifest
+      manifest[filename] = digest
+    end
+    manifest
+  end
+  
+  def self.determine_manifest_changes(from, to)
+    changes = []
+    from.each_key do |name|
+      changes << [name, :delete] unless to.has_key?(name)
+    end
+    to.each do |name,hash|
+      changes << [name, hash] unless from[name] == hash
+    end
+    changes
+  end
+  
+end
+

data/lib/minimise.rb

@@ -0,0 +1,68 @@
+
+module PluginTool
+
+  class Minimiser
+    Context = Java::OrgMozillaJavascript::Context
+    
+    def initialize
+      # Load UglifyJS into a JavaScript interpreter
+      raise "Another JS Context is active" unless nil == Context.getCurrentContext()
+      @cx = Context.enter();
+      @cx.setLanguageVersion(Context::VERSION_1_7)
+      @javascript_scope = @cx.initStandardObjects()
+      ['js_min.js','uglifyjs/parse-js.js','uglifyjs/process.js','uglifyjs/squeeze-more.js'].each do |filename|
+        js = File.open("#{File.dirname(__FILE__)}/#{filename}") { |f| f.read }
+        @cx.evaluateString(@javascript_scope, js, "<#{filename}>", 1, nil);
+      end
+      @js_min = @javascript_scope.get("js_min", @javascript_scope);
+    end
+
+    def process(data, filename)
+      if filename =~ /\.js\z/
+        # JavaScript - use UglifyJS loaded into the JavaScript interpreter
+        @js_min.call(@cx, @javascript_scope, @javascript_scope, [data])
+
+      elsif filename =~ /\.html\z/
+        # Simple processing of HTML
+        # Remove HTML comments
+        html = data.gsub(/\<\!\-\-.+?\-\-\>/m,'')
+        # Remove indents
+        html.gsub!(/^\s+/,'')
+        # Remove any unnecessary line breaks (fairly conservative)
+        html.gsub!(/\>[\r\n]+\</m,'><')
+        html.gsub!(/([\>}])[\r\n]+([\<{])/m,'\1\2')
+        html
+
+      elsif filename =~ /\.css\z/
+        # Simple processing of CSS
+        css = data.gsub(/(^|\s)\/\*.+?\*\/($|\s)/m,'') # remove C style comments
+        out = []
+        css.split(/[\r\n]+/).each do |line|
+          line.chomp!; line.gsub!(/^\s+/,''); line.gsub!(/\s+$/,'')
+          line.gsub!(/\s+/,' ')       # contract spaces
+          line.gsub!(/\s*:\s*/,':')   # remove unnecessary spaces
+          if line =~ /\S/
+            out << line
+          end
+        end
+        css = out.join("\n")
+        # Remove unnecessary line endings
+        css.gsub!(/[\r\n]*(\{[^\}]+\})/m) do |m|
+          $1.gsub(/[\r\n]/m,'')
+        end
+        css
+
+      else
+        # No processing
+        data
+      end
+    end
+    
+    def finish
+      Context.exit()
+    end
+
+  end
+
+end
+

data/lib/misc.rb

@@ -0,0 +1,8 @@
+
+module PluginTool
+
+  def self.beep
+    $stdout.write("\07")
+  end
+
+end

data/lib/new_plugin.rb

@@ -0,0 +1,88 @@
+
+module PluginTool
+
+  def self.make_new_plugin(plugin_name)
+    unless plugin_name =~ /\A[a-z0-9_]+\z/ && plugin_name.length > 8
+      end_on_error "Bad plugin name - must use a-z0-9_ only, and more than 8 characters."
+    end
+    if File.exist?(plugin_name)
+      end_on_error "File or directory #{plugin_name} already exists"
+    end
+    FileUtils.mkdir(plugin_name)
+    ['js', 'static', 'template', 'test'].each do |dir|
+      FileUtils.mkdir("#{plugin_name}/#{dir}")
+    end
+    random = java.security.SecureRandom.new()
+    rbytes = Java::byte[20].new
+    random.nextBytes(rbytes)
+    install_secret = String.from_java_bytes(rbytes).unpack('H*').join
+    plugin_url_fragment = plugin_name.gsub('_','-')
+    File.open("#{plugin_name}/plugin.json",'w') do |file|
+      file.write(<<__E)
+{
+  "pluginName": "#{plugin_name}",
+  "pluginAuthor": "TODO Your Company",
+  "pluginVersion": 1,
+  "displayName": "#{plugin_name.split('_').map {|e| e.capitalize} .join(' ')}",
+  "displayDescription": "TODO Longer description of plugin",
+  "installSecret": "#{install_secret}",
+  "apiVersion": 4,
+  "load": [
+      "js/#{plugin_name}.js"
+    ],
+  "respond": ["/do/#{plugin_url_fragment}"]
+}
+__E
+    end
+    File.open("#{plugin_name}/js/#{plugin_name}.js",'w') do |file|
+      file.write(<<__E)
+
+P.respond("GET", "/do/#{plugin_url_fragment}/example", [
+], function(E) {
+    E.render({
+        pageTitle: "Example page"
+    });
+});
+
+__E
+    end
+    File.open("#{plugin_name}/template/example.html",'w') do |file|
+      file.write(<<__E)
+<p>This is an example template.</p>
+__E
+    end
+    File.open("#{plugin_name}/test/#{plugin_name}_test1.js",'w') do |file|
+      file.write(<<__E)
+
+t.test(function() {
+
+    // For documentation, see
+    //   http://docs.haplo.org/dev/plugin/tests
+
+    t.assert(true);
+
+});
+
+__E
+    end
+    File.open("#{plugin_name}/requirements.schema",'w') do |file|
+      file.write("\n\n\n")
+    end
+    puts <<__E
+
+Plugin #{plugin_name} has been created. Run
+
+  haplo-plugin -p #{plugin_name}
+
+to upload it to the server, then visit
+
+  https://<HOSTNAME>/do/#{plugin_url_fragment}/example
+
+to see a sample page.
+
+See http://docs.haplo.org/dev/plugin for more information.
+
+__E
+  end
+
+end

data/lib/notifications.rb

@@ -0,0 +1,89 @@
+
+module PluginTool
+
+  @@notification_options = nil
+  @@notification_have_suppressed_first_system_audit_entry = false
+  @@notification_announce_reconnect = false
+
+  def self.start_notifications(options)
+    @@notification_options = options
+    @@notification_queue_name = nil
+    Thread.new do
+      while true
+        begin
+          self.do_notifications
+        rescue => e
+          puts "NOTICE: Lost notification connection, will attempt to reconnect soon."
+          @@notification_announce_reconnect = true
+          sleep(5)  # throttle errors
+        end
+      end
+    end
+  end
+
+  def self.do_notifications
+    http = make_http_connection
+    puts "NOTICE: Notification connection established." if @@notification_announce_reconnect
+    while true
+      sleep(0.25) # small throttle of requests
+      path = '/api/development-plugin-loader/get-notifications'
+      path << "?queue=#{@@notification_queue_name}" if @@notification_queue_name
+      request = Net::HTTP::Get.new(path)
+      setup_request(request)
+      # Server uses long-polling, and will respond after a long timeout, or when a notification
+      # has been queued for sending to this process.
+      response = http.request(request)
+      if response.kind_of?(Net::HTTPOK)
+        @@notification_queue_name = response['X-Queue-Name']
+        begin
+          decode_and_handle_notifications response.body
+        rescue
+          puts "NOTICE: Error handling notification from server."
+        end
+      else
+        raise "Bad response"
+      end
+    end
+  end
+  
+  def self.decode_and_handle_notifications(encoded)
+    size = encoded.length
+    pos = 0
+    while pos < (size - 12)
+      type = encoded[pos, 4]
+      data_size = encoded[pos + 4, 8].to_i(16)
+      data = encoded[pos + 12, data_size]
+      pos += 12 + data_size
+      handle_notification(type, data)
+    end
+  end
+  
+  def self.handle_notification(type, data)
+    case type
+    when 'log '
+      # Output from console.log()
+      puts "LOG:#{data}"
+    when 'audt'
+      decoded = JSON.parse(data)
+      kind = decoded.find { |name,value| name == 'auditEntryType' }.last
+      if kind =~ /\A[A-Z\-]+\z/
+        # System audit entry - suppressed by default
+        unless @@notification_options.show_system_audit
+          unless @@notification_have_suppressed_first_system_audit_entry
+            @@notification_have_suppressed_first_system_audit_entry = true
+            puts "NOTICE: System audit trail entries are not being shown. Run with --show-system-audit to display."
+          end
+          return
+        end
+      end
+      puts "AUDIT -------------------------------------------"
+      decoded.each do |key, value|
+        puts sprintf("%22s: %s", key, value.to_s)
+      end
+    else
+      puts "WARNING: Unknown notification received from server. Upgrade the plugin tool using 'jgem update haplo'."
+      sleep(5) # throttle problematic responses
+    end
+  end
+
+end

data/lib/packing.rb

@@ -0,0 +1,62 @@
+
+module PluginTool
+  
+  PACKING_ACCEPTABLE_FILENAME = /\A(js|static|template|test|data)\/([a-z0-9_-]+\/)*[a-z0-9_-]+\.[a-z0-9]+\z/
+  PACKING_ACCEPTABLE_EXCEPTIONS = ['plugin.json', 'requirements.schema', 'global.js', 'certificates-temp-http-api.pem']
+  PACKING_EXCLUDE = ['developer.json']
+
+  def self.pack_plugin(plugin_name, output_directory)
+    # Get filenames and sort
+    files = Dir.glob("#{plugin_name}/**/*").map do |filename|
+      if File.file? filename
+        filename[plugin_name.length+1, filename.length]
+      else
+        nil
+      end
+    end .select { |f| !PACKING_EXCLUDE.include?(f) }.compact.sort
+    # Check each filename is acceptable
+    files.each do |filename|
+      unless filename =~ PACKING_ACCEPTABLE_FILENAME || PACKING_ACCEPTABLE_EXCEPTIONS.include?(filename)
+        puts "File '#{filename}' has an unacceptable filename"
+        exit 1
+      end
+    end
+    # Clean output directory
+    output_plugin_dir = "#{output_directory}/#{plugin_name}"
+    puts "Output directory: #{output_plugin_dir}"
+    if File.exist? output_plugin_dir
+      puts "Removing old output directory #{output_plugin_dir}"
+      FileUtils.rm_r(output_plugin_dir)
+    end
+    # Make file structure
+    FileUtils.mkdir(output_plugin_dir)
+    # Process each file, building a manifest
+    puts "Processing files:"
+    manifest = ''
+    minimiser = PluginTool::Minimiser.new
+    files.each do |filename|
+      puts "  #{filename}"
+      data = File.open("#{plugin_name}/#{filename}") { |f| f.read }
+      # Minimise file?
+      unless filename =~ /\Ajs\//
+        data = minimiser.process(data, filename)
+      end
+      hash = Digest::SHA256.hexdigest(data)
+      # Make sure output directory exists, write file
+      output_pathname = "#{output_plugin_dir}/#{filename}"
+      output_directory = File.dirname(output_pathname)
+      FileUtils.mkdir_p(output_directory) unless File.directory?(output_directory)
+      File.open(output_pathname, "w") { |f| f.write data }
+      # Filename entry in Manifest
+      manifest << "F #{hash} #{filename}\n"
+    end
+    minimiser.finish
+    # Write manifest and version
+    File.open("#{output_plugin_dir}/manifest", "w") { |f| f.write manifest }
+    version = Digest::SHA256.hexdigest(manifest)
+    File.open("#{output_plugin_dir}/version", "w") { |f| f.write "#{version}\n" }
+    # All done
+    puts "Version: #{version}\nPlugin packed."
+  end
+
+end

data/lib/plugin.rb

@@ -0,0 +1,227 @@
+
+module PluginTool
+
+  class Plugin
+    DEFAULT_PLUGIN_LOAD_PRIORITY = 9999999
+
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+    attr_accessor :name
+    attr_accessor :plugin_dir
+    attr_accessor :loaded_plugin_id
+
+    # ---------------------------------------------------------------------------------------------------------
+
+    @@pending_apply = []
+
+    # ---------------------------------------------------------------------------------------------------------
+    
+    def start
+      # Check to see if the plugin is valid
+      unless File.file?("#{@name}/plugin.json")
+        end_on_error "Plugin #{@name} does not exist (no plugin.json file)"
+      end
+      # Setup for using the plugin
+      @plugin_dir = @name
+      end_on_error "logic error" unless @plugin_dir =~ /\A[a-zA-Z0-9_-]+\z/
+      @loaded_plugin_id = nil
+    end
+    
+    def plugin_load_priority
+      pj = File.open("#{@plugin_dir}/plugin.json") { |f| JSON.parse(f.read) }
+      pj['loadPriority'] || DEFAULT_PLUGIN_LOAD_PRIORITY
+    end
+
+    def print_banner
+      puts "Plugin: #{@plugin_dir}"
+    end
+
+    def setup_for_server
+      # Make the first empty manifest (may be replaced from server)
+      @current_manifest = {}
+
+      # If minimisation is active, clear the current manifest so all files are uploaded again.
+      if @options.minimiser != nil
+        @current_manifest = {}
+      end
+
+      # See if the plugin has already been registered with the server
+      s_found_info = PluginTool.post_with_json_response("/api/development-plugin-loader/find-registration", {:name => @name})
+      if s_found_info["found"]
+        # Store info returned by the server
+        @loaded_plugin_id = s_found_info["plugin_id"]
+        @current_manifest = s_found_info["manifest"]
+      end
+
+      # If there isn't an existing plugin registered, create a new one
+      if @loaded_plugin_id == nil
+        s_create_info = PluginTool.post_with_json_response("/api/development-plugin-loader/create")
+        end_on_error "Couldn't communicate successfully with server." if s_create_info["protocol_error"]
+        end_on_error "Failed to create plugin on server" unless s_create_info["plugin_id"] != nil
+        @loaded_plugin_id = s_create_info["plugin_id"]
+      end
+    end
+
+    # ---------------------------------------------------------------------------------------------------------
+
+    def exclude_files_from_syntax_check
+      @exclude_files_from_syntax_check ||= begin
+        # developer.json file might contain some files which should not be syntax checked
+        exclude_files_from_check = []
+        developer_json_pathname = "#{@plugin_dir}/developer.json"
+        if File.exist? developer_json_pathname
+          developer_json = JSON.parse(File.read(developer_json_pathname))
+          if developer_json['excludeFromSyntaxCheck'].kind_of?(Array)
+            exclude_files_from_check = developer_json['excludeFromSyntaxCheck']
+          end
+        end
+        exclude_files_from_check
+      end
+    end
+
+    # ---------------------------------------------------------------------------------------------------------
+
+    def command(cmd)
+      case cmd
+      when 'license-key'
+        application_id = @options.args.first
+        if application_id == nil || application_id !~ /\A\d+\z/
+          end_on_error "Numeric application ID must be specified"
+        end
+        generate_license_key(application_id)
+
+      when 'pack'
+        PluginTool.pack_plugin(@name, @options.output)
+
+      when 'reset-db'
+        puts "Resetting database on server for #{@name}..."
+        reset_result = PluginTool.post_with_json_response("/api/development-plugin-loader/resetdb/#{@loaded_plugin_id}")
+        end_on_error "Couldn't remove old database tables" unless reset_result["result"] == 'success'
+        apply_result = PluginTool.post_with_json_response("/api/development-plugin-loader/apply", :plugins => @loaded_plugin_id)
+        end_on_error "Couldn't apply changes" unless apply_result["result"] == 'success'
+        puts "Done."
+
+      when 'uninstall'
+        puts "Uninstalling plugin #{@name} from server..."
+        reset_result = PluginTool.post_with_json_response("/api/development-plugin-loader/uninstall/#{@loaded_plugin_id}")
+        end_on_error "Couldn't uninstall plugin" unless reset_result["result"] == 'success'
+        puts "Done."
+
+      when 'test'
+        puts "Running tests..."
+        params = {}
+        params["test"] = @options.args.first unless @options.args.empty?
+        test_result = PluginTool.post_with_json_response("/api/development-plugin-loader/run-tests/#{@loaded_plugin_id}", params)
+        end_on_error "Couldn't run tests" unless test_result["result"] == 'success'
+        puts
+        puts test_result["output"] || ''
+        puts test_result["summary"] || "(unknown results)"
+
+      when 'develop'
+        # do nothing here
+      
+      else
+        end_on_error "Unknown command '#{cmd}'"
+
+      end
+    end
+
+    # ---------------------------------------------------------------------------------------------------------
+
+    def develop_setup
+    end
+
+    def develop_scan_and_upload(first_run)
+      should_apply = first_run
+      next_manifest = PluginTool.generate_manifest(@plugin_dir)
+      if !(next_manifest.has_key?("plugin.json"))
+        # If the plugin.json file is deleted, just uninstall the plugin from the server
+        command('uninstall')
+        @is_uninstalled = true
+        return
+      elsif @is_uninstalled
+        should_apply = true
+      end
+      changes = PluginTool.determine_manifest_changes(@current_manifest, next_manifest)
+      upload_failed = false
+      changes.each do |filename, action|
+        filename =~ /\A(.*?\/)?([^\/]+)\z/
+        params = {:filename => $2}
+        params[:directory] = $1.gsub(/\/\z/,'') if $1
+        if action == :delete
+          puts "  #{@name}: Deleting #{filename}"
+          PluginTool.post_with_json_response("/api/development-plugin-loader/delete-file/#{@loaded_plugin_id}", params)
+        else
+          puts "  #{@name}: Uploading #{filename}"
+          data = File.open("#{@plugin_dir}/#{filename}") { |f| f.read }
+          hash = action
+          # Minimise file before uploading?
+          if @options.minimiser != nil && filename =~ /\A(static|template)\//
+            size_before = data.length
+            data = @options.minimiser.process(data, filename)
+            size_after = data.length
+            hash = Digest::SHA256.hexdigest(data)
+            puts "        minimisation: #{size_before} -> #{size_after} (#{(size_after * 100) / size_before}%)"
+          end
+          r = PluginTool.post_with_json_response("/api/development-plugin-loader/put-file/#{@loaded_plugin_id}", params, {:file => [filename, data]})
+          if r["result"] == 'success'
+            # If the file was uploaded successfully, but the hash didn't match, abort now
+            end_on_error "#{@name}: Disagreed with server about uploaded file hash: local=#{hash}, remote=#{r["hash"]}" unless hash == r["hash"]
+          else
+            # Otherwise mark as a failed upload to stop an apply operation which will fail
+            upload_failed = true
+          end
+          PluginTool.syntax_check(self, filename) if filename =~ /\.(js|hsvt)\z/i
+        end
+      end
+      if upload_failed
+        puts "\n#{@name}: Not applying changes due to failure\n\n"
+      else
+        if !(changes.empty?) || should_apply
+          @@pending_apply.push(self) unless @@pending_apply.include?(self)
+        end
+      end
+      @current_manifest = next_manifest
+    end
+
+    # ---------------------------------------------------------------------------------------------------------
+
+    def self.do_apply
+      return if @@pending_apply.empty?
+      puts "Applying changes on server: #{@@pending_apply.map { |p| p.name } .join(', ')}"
+      r = PluginTool.post_with_json_response("/api/development-plugin-loader/apply", {
+        :plugins => @@pending_apply.map { |p| p.loaded_plugin_id }.join(' ')
+      })
+      if r["result"] == 'success'
+        @@pending_apply = []
+      else
+        puts "\n\nDidn't apply changes on server\n\n"
+        PluginTool.beep
+      end
+    end
+
+    # ---------------------------------------------------------------------------------------------------------
+
+    def generate_license_key(application_id)
+      info = File.open("#{@plugin_dir}/plugin.json") { |f| JSON.parse(f.read) }
+      if info["installSecret"] == nil
+        end_on_error "#{@name}: No installSecret specified in plugin.json"
+      end
+      license_key = HMAC::SHA1.sign(info["installSecret"], "application:#{application_id}")
+      puts <<__E
+
+Plugin:       #{@name}
+Application:  #{application_id}
+License key:  #{license_key}
+__E
+    end
+    
+    def end_on_error(err)
+      puts err
+      exit 1
+    end
+  end
+
+end