oneis 1.0.0-java

data/lib/manifest.rb

@@ -0,0 +1,41 @@
+
+module PluginTool
+  
+  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
+      # 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::SHA1.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,91 @@
+
+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
+    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": 0,
+	"load": ["js/#{plugin_name}.js"],
+	"respond": ["/do/#{plugin_name}"]
+}
+__E
+    end
+    File.open("#{plugin_name}/js/#{plugin_name}.js",'w') do |file|
+      file.write(<<__E)
+
+var #{plugin_name} = O.plugin("#{plugin_name}", {
+});
+
+(function() {
+
+    #{plugin_name}.respond("GET", "/do/#{plugin_name}/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.oneis.co.uk/dev/plugin/tests
+    
+    T.assert(true);
+  
+});
+
+__E
+    end
+    puts <<__E
+
+Plugin #{plugin_name} has been created. Run
+
+  oneis-plugin -p #{plugin_name}
+
+to upload it to the server, then visit
+
+  https://<HOSTNAME>/do/#{plugin_name}/example
+
+to see a sample page.
+
+Add additional hook handlers in the js/#{plugin_name}.js file.
+
+See http://docs.oneis.co.uk/dev/plugin for more information.
+
+__E
+  end
+
+end

data/lib/notifications.rb

@@ -0,0 +1,69 @@
+
+module PluginTool
+
+  @@notification_announce_reconnect = false
+
+  def self.start_notifications
+    @@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}"
+    else
+      puts "WARNING: Unknown notification received from server. Upgrade the plugin tool."
+      sleep(5) # throttle problematic responses
+    end
+  end
+
+end

data/lib/packing.rb

@@ -0,0 +1,59 @@
+
+module PluginTool
+  
+  PACKING_ACCEPTABLE_FILENAME = /\A(plugin\.json|(js|static|template)\/[a-z0-9_-]+\.[a-z0-9]+)\Z/
+  PACKING_ACCEPTABLE_EXCEPTIONS = ['certificates-temp-http-api.pem']
+
+  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 .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)
+    ['js','static','template'].each do |subdir|
+      FileUtils.mkdir("#{output_plugin_dir}/#{subdir}")
+    end
+    # 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::SHA1.hexdigest(data)
+      File.open("#{output_plugin_dir}/#{filename}", "w") { |f| f.write data }
+      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::SHA1.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,207 @@
+
+module PluginTool
+
+  class Plugin
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+    attr_accessor :name
+    attr_accessor :plugin_dir
+
+    # ---------------------------------------------------------------------------------------------------------
+    
+    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/
+      @registration_file = "registration.#{@plugin_dir}.yaml"
+      puts "Plugin: #{@plugin_dir}"
+    end
+    
+    def setup_for_server
+      # Make the first empty manifest (may be replaced from server)
+      @current_manifest = {}
+
+      # Get info about the current plugin
+      @loaded_plugin_id = nil
+      if File.exists? @registration_file
+        reg_info = YAML::load(File.open(@registration_file) { |f| f.read })
+        @loaded_plugin_id = reg_info[:plugin_id]
+        if @loaded_plugin_id != nil
+          # Check with server to see if this is still registered, and if so, what files it has on the server
+          s_reg_info = PluginTool.get_yaml("/api/development_plugin_loader/manifest/#{@loaded_plugin_id}")
+          end_on_error "Couldn't communicate successfully with server." if s_reg_info[:protocol_error]
+          if s_reg_info[:result] == 'success'
+            @current_manifest = s_reg_info[:manifest]
+          else
+            puts "NOTICE: Discarding registration information from #{@registration_file}"
+            @loaded_plugin_id = nil
+          end
+        end
+      end
+
+      # If minimisation is active, clear the current manifest so all files are uploaded again.
+      if @options.minimiser != nil
+        @current_manifest = {}
+      end
+
+      # Flag for registration file save
+      registration_file_needs_update = false
+
+      # If the current plugin registration isn't known, see if the server knows about it
+      if @loaded_plugin_id == nil
+        s_found_info = PluginTool.post_yaml("/api/development_plugin_loader/find_registration", {:name => @name})
+        if s_found_info[:found]
+          # Store info returned by the server
+          puts "NOTICE: Found existing registration for #{@name} on server. Using it."
+          @loaded_plugin_id = s_found_info[:plugin_id]
+          @current_manifest = s_found_info[:manifest]
+          registration_file_needs_update = true
+        end
+      end
+
+      # If there isn't an existing plugin registered, create a new one
+      if @loaded_plugin_id == nil
+        s_create_info = PluginTool.post_yaml("/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]
+        registration_file_needs_update = true
+      end
+
+      # Update registration file for next run?
+      if registration_file_needs_update
+        File.open(@registration_file, 'w') { |f| f.write YAML::dump(:plugin_id => @loaded_plugin_id) }
+      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_yaml("/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.get_yaml("/api/development_plugin_loader/apply/#{@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_yaml("/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_yaml("/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)
+      next_manifest = PluginTool.generate_manifest(@plugin_dir)
+      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_yaml("/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::SHA1.hexdigest(data)
+            puts "        minimisation: #{size_before} -> #{size_after} (#{(size_after * 100) / size_before}%)"
+          end
+          r = PluginTool.post_yaml("/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\Z/
+        end
+      end
+      if upload_failed
+        puts "\n#{@name}: Not applying changes due to failure\n\n"
+      else
+        if !(changes.empty?) || first_run
+          puts "  #{@name}: Applying changes on server"
+          r = PluginTool.get_yaml("/api/development_plugin_loader/apply/#{@loaded_plugin_id}")
+          unless r[:result] == 'success'
+            puts "\n\n#{@name}: Didn't apply changes on server\n\n"
+            PluginTool.beep
+          end
+        end
+      end
+      PluginTool.finish_with_connection
+      @current_manifest = next_manifest
+    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:#{ARGV[1]}")
+      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