tap-server 0.1.0

data/History

@@ -0,0 +1,5 @@
+== 0.1.0 / 2009-02-17
+
+As of the 0.12.0 release, Tap is distributed as several independent modules.
+This is the server module.  In the initial release, the server is working
+as a proof-of-principle, and not as a serious interface for tap.

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009, Regents of the University of Colorado.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,49 @@
+= {Tap Server}[http://tap.rubyforge.org/tap-server]
+
+A web interface for {Tap}[http://tap.rubyforge.org/rdoc].
+
+== Description
+
+{Tap Server}[http://tap.rubyforge.org/tap-server] provides a web interface for
+Tap tasks.  The basic interface allows the construction and execution of
+workflows, rendering of task results, and facilitates distributable
+controllers.  The intention is not to make websites for the masses, but rather
+a local interface for individuals and small groups.
+
+{Tap Server}[http://tap.rubyforge.org/tap-server] is a part of the
+{Tap-Suite}[http://tap.rubyforge.org/tap-suite].  Check out these links for
+documentation, development, and bug tracking.
+
+* Website[http://tap.rubyforge.org]
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/9908-tap-task-application/tickets]
+* Github[http://github.com/bahuvrihi/tap/tree/master]
+* {Google Group}[http://groups.google.com/group/ruby-on-tap]
+
+== Usage
+
+To get a peek, use the command:
+
+  % tap server
+  
+Then go to the url 'localhost:8080'.  Currently tap-server is in alpha and
+should not be considered stable.
+
+== Installation
+
+Tap Server is available as a gem on RubyForge[http://rubyforge.org/projects/tap].  Use:
+
+  % gem install tap-server
+
+Tap requires an updated version of RubyGems[http://docs.rubygems.org/] 
+(>= 1.2.0).  To check the version and update RubyGems:
+
+  % gem --version
+  % gem --update system
+    
+== Info 
+
+Copyright (c) 2009, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]
+

data/cmd/server.rb

@@ -0,0 +1,34 @@
+# tap server {options}
+#
+# Initializes a tap server.
+
+require 'tap'
+require 'tap/server'
+
+env = Tap::Env.instance
+app = Tap::App.instance
+
+#
+# handle options
+#
+
+config_path = nil
+opts = ConfigParser.new do |opts|
+  
+  opts.separator ""
+  opts.separator "options:"
+  opts.add(Tap::Server.configurations)
+
+  # add option to print help
+  opts.on("-h", "--help", "Show this message") do
+    puts Lazydoc.usage(__FILE__)
+    puts opts
+    exit
+  end
+end
+
+# parse!
+argv = opts.parse(ARGV)
+server = Tap::Server.new(env, app, opts.config)
+cookie_server = Rack::Session::Pool.new(server)
+Rack::Handler::WEBrick.run(cookie_server, :Port => server.port)

data/controllers/app_controller.rb

@@ -0,0 +1,92 @@
+require 'tap/controller'
+require 'rack/mime'
+require 'time'
+
+class AppController < Tap::Controller
+  set :default_layout, 'layout.erb'
+  
+  def call(env)
+    # serve public files before actions
+    server = env['tap.server'] ||= Tap::Server.new
+    
+    if path = server.public_path(env['PATH_INFO'])
+      content = File.read(path)
+      headers = {
+        "Last-Modified" => [File.mtime(path).httpdate],
+        "Content-Type" => [Rack::Mime.mime_type(File.extname(path), 'text/plain')], 
+        "Content-Length" => [content.size.to_s]
+      }
+      
+      [200, headers, [content]]
+    else
+      super
+    end
+  end
+  
+  def index
+    env_names = {}
+    server.env.minimap.each do |name, environment|
+      env_names[environment] = name
+    end 
+    
+    render('index.erb', :locals => {:env => server.env, :env_names => env_names}, :layout => true)
+  end
+  
+  def info
+    if request.post?
+      app.info
+    else
+      render('info.erb', :locals => {:update => true, :content => app.info}, :layout => true)
+    end
+  end
+  
+  #--
+  # Currently tail is hard-coded to tail the server log only.
+  def tail(id=nil)
+    begin
+      path = app.subpath(:log, 'server.log')
+      raise unless File.exists?(path)
+    rescue
+      raise Tap::ServerError.new("invalid path", 404)
+    end
+    
+    pos = request['pos'].to_i
+    if pos > File.size(path)
+      raise Tap::ServerError.new("tail position out of range (try update)", 500)
+    end
+
+    content = File.open(path) do |file|
+      file.pos = pos
+      file.read
+    end
+    
+    if request.post?
+      content
+    else
+      render('tail.erb', :locals => {
+        :id => id,
+        :path => File.basename(path),
+        :update => true,
+        :content => content
+      }, :layout => true)
+    end
+  end
+  
+  def run
+    Thread.new { app.run }
+    redirect("/app/tail")
+  end
+  
+  def stop
+    app.stop
+    redirect("/app/info")
+  end
+  
+  def terminate
+    app.terminate
+    redirect("/app/info")
+  end
+  
+  def help(key=nil)
+  end
+end

data/controllers/schema_controller.rb

@@ -0,0 +1,255 @@
+require 'tap/controller'
+
+class SchemaController < Tap::Controller
+  set :default_layout, 'layout.erb'
+  
+  # Initializes a new schema and redirects to display.
+  def index
+    id = initialize_schema
+    redirect("/schema/display/#{id}")
+  end
+  
+  # Loads the schema indicated by id and renders 'schema.erb' with the default
+  # layout.
+  def display(id)
+    schema = load_schema(id)
+    render 'schema.erb', :locals => {
+      :id => id, 
+      :schema => schema
+    }, :layout => true
+  end
+  
+  # Updates the specified schema with the request parameters.  Update forwards
+  # the request to the action ('add' or 'remove') specified in the action
+  # parameter.
+  def update(id)
+    case request['action']
+    when 'add'    then add(id)
+    when 'remove' then remove(id)
+    when 'echo'   then echo
+    else raise Tap::ServerError, "unknown action: #{request['action']}"
+    end
+  end
+  
+  # Adds nodes or joins to the schema.  Parameters:
+  #
+  # nodes[]:: An array of nodes to add to the schema. Each entry is split using
+  #           Shellwords to yield an argv; the argv initializes the node.  The
+  #           index of each new node is added to targets[].
+  # sources[]:: An array of source node indicies used to create a join.
+  # targets[]:: An array of target node indicies used to create a join (note
+  #             the indicies of new nodes are added to targets).
+  #
+  # Add creates and pushes new nodes onto schema as specified in nodes, then
+  # creates joins between the sources and targets.  The join class is inferred
+  # by Utils.infer_join; if no join can be inferred the join class is 
+  # effectively nil, and consistent with that, the node output for sources
+  # and the node input for targets is set to nil.
+  #
+  # === Notes
+  #
+  # The nomenclature for source and target is relative to the join, and may
+  # seem backwards for the node (ex: 'sources[]=0&targets[]=1' makes a join
+  # like '0:1')
+  #
+  def add(id)
+    unless request.post?
+      raise Tap::ServerError, "add must be performed with post"
+    end
+    
+    round = (request['round'] || 0).to_i
+    outputs = (request['outputs[]'] || []).collect {|index| index.to_i }
+    inputs = (request['inputs[]'] || []).collect {|index| index.to_i }
+    nodes = request['nodes[]'] || []
+    
+    load_schema(id) do |schema|
+      nodes.each do |arg|
+        next unless arg && !arg.empty?
+
+        outputs << schema.nodes.length
+        schema.nodes << Tap::Support::Node.new(Shellwords.shellwords(arg), round)
+      end
+      
+      if inputs.empty? || outputs.empty?
+        inputs.each {|index| schema[index].output = nil }
+        outputs.each {|index| schema[index].input = round }
+      else
+        
+        # temporary
+        if inputs.length > 1 && outputs.length > 1
+          raise "multi-way join specified"
+        end
+        
+        schema.set(Tap::Support::Join, inputs, outputs)
+      end
+    end
+    
+    redirect("/schema/display/#{id}")
+  end
+  
+  # Removes nodes or joins from the schema.  Parameters:
+  #
+  # sources[]:: An array of source node indicies to remove.
+  # targets[]:: An array of target node indicies to remove.
+  #
+  # Normally remove sets the node.output for each source to nil and the
+  # node.input for each target to nil.  However, if a node is indicated in
+  # both sources and targets AND it has no join input/output, then it will
+  # be removed.
+  #
+  # === Notes
+  #
+  # The nomenclature for source and target is relative to the join, and may
+  # seem backwards for the node (ex: for the sequence '0:1:2', 'targets[]=1'
+  # breaks the join '0:1' while 'sources[]=1' breaks the join '1:2'.
+  #
+  def remove(id)
+    unless request.post?
+      raise Tap::ServerError, "remove must be performed with post"
+    end
+    
+    round = (request['round'] || 0).to_i
+    outputs = (request['outputs[]'] || []).collect {|index| index.to_i }
+    inputs = (request['inputs[]'] || []).collect {|index| index.to_i }
+    
+    load_schema(id) do |schema|
+      # Remove joins.  Removed indicies are popped to ensure
+      # that if a join was removed the node will not be.
+      outputs.delete_if do |index|
+        next unless node = schema.nodes[index]
+        if node.input_join
+          node.input = round
+          true
+        else
+          false
+        end
+      end
+      
+      inputs.delete_if do |index|
+        next unless node = schema.nodes[index]
+        if node.output_join
+          node.output = nil
+          true
+        else
+          false
+        end
+      end
+    
+      # Remove nodes. Setting a node to nil causes it's removal during 
+      # compact; orphaned joins are removed during compact as well.
+      (inputs & outputs).each do |index|
+        schema.nodes[index] = nil
+      end
+    end
+    
+    redirect("/schema/display/#{id}")
+  end
+  
+  def submit(id)
+    case request['action']
+    when 'save'    then save(id)
+    when 'preview' then preview(id)
+    when 'echo'    then echo
+    when 'run'
+      dump_schema(id, schema)
+      run(id)
+    else raise Tap::ServerError, "unknown action: #{request['action']}"
+    end
+  end
+  
+  def save(id)
+    unless request.post?
+      raise Tap::ServerError, "submit must be performed with post"
+    end
+    
+    dump_schema(id, schema)
+    redirect("/schema/display/#{id}")
+  end
+  
+  def preview(id)
+    response.headers['Content-Type'] = 'text/plain'
+    render('preview.erb', :locals => {:id => id, :schema => schema})
+  end
+  
+  def run(id)
+    unless request.post?
+      raise Tap::ServerError, "run must be performed with post"
+    end
+    
+    # it would be nice to someday put all this on a separate thread...
+    schema = load_schema(id)
+    tasks = server.env.tasks
+    schema.build(app) do |(key, *args)|
+      if const = tasks.search(key) 
+        const.constantize.parse(args, app) do |help|
+          raise "help not implemented"
+          #redirect("/app/help/#{key}")
+        end
+      else
+        raise ArgumentError, "unknown task: #{key}"
+      end
+    end
+    
+    Thread.new { app.run }
+    redirect("/app/tail")
+  end
+  
+  protected
+  
+  # Parses a Tap::Support::Schema from the request.
+  def schema
+    argv = request['argv[]'] || []
+    argv.delete_if {|arg| arg.empty? }
+    Tap::Support::Schema.parse(argv)
+  end
+  
+  def initialize_schema
+    current = app.glob(:schema, "*").collect {|path| File.basename(path).chomp(".yml") }
+    
+    id = random_key(current.length)
+    while current.include?(id)
+      id = random_key(current.length)
+    end
+    
+    dump_schema(id, schema)
+    id
+  end
+  
+  def load_schema(id)
+    unless path = app.filepath(:schema, "#{id}.yml")
+      raise ServerError, "no schema for id: #{id}"
+    end
+    schema = Tap::Support::Schema.load_file(path)
+    
+    if block_given?
+      result = yield(schema)
+      dump_schema(id, schema)
+      result
+    else
+      schema
+    end
+  end
+  
+  def dump_schema(id, schema=nil)
+    app.prepare(:schema, "#{id}.yml") do |file|
+      file << schema.dump.to_yaml if schema
+    end
+  end
+  
+  def instantiate(*argv)
+    key = argv.shift
+    tasc = server.env.tasks.search(key).constantize 
+    tasc.parse(argv)
+  end
+  
+  # helper to echo requests back... good for debugging
+  def echo # :nodoc:
+    "<pre>#{request.params.to_yaml}</pre>"
+  end
+  
+  # Generates a random integer key.
+  def random_key(length) # :nodoc:
+    length = 1 if length < 1
+    rand(length * 10000).to_s
+  end
+end

data/lib/tap/controller.rb

@@ -0,0 +1,231 @@
+require 'tap/server'
+autoload(:ERB, 'erb')
+
+module Tap
+  
+  # === Declaring Actions
+  # By default all public methods in subclasses are declared as actions.  You
+  # can declare a private or protected method as an action by:
+  #
+  # * manually adding it directly to actions
+  # * defining it as a public method and then call private(:method) or protected(:method)
+  #
+  # Similarly, public method can be made non-action by actions by:
+  #
+  # * manually deleting it from actions
+  # * define it private or protected then call public(:method)
+  #
+  class Controller
+    class << self
+      
+      # Initialize instance variables on the child and inherit as necessary.
+      def inherited(child) # :nodoc:
+        super
+        child.set(:actions, actions.dup)
+        child.set(:middleware, middleware.dup)
+        child.set(:default_layout, default_layout)
+        child.set(:define_action, true)
+      end
+      
+      # An array of methods that can be called as actions.  Actions must be
+      # stored as symbols.  Actions are inherited.
+      attr_reader :actions
+      
+      # An array of Rack middleware that will be applied when handing requests
+      # through the class call method.  Middleware is inherited.
+      attr_reader :middleware
+      
+      # The default layout rendered when the render option :layout is true.
+      attr_reader :default_layout
+      
+      # The base path prepended to render paths (ie render(<path>) renders
+      # <templates_dir/name/path>).
+      def name
+        @name ||= to_s.underscore
+      end
+      
+      # Adds the specified middleware.  Middleware classes are initialized
+      # with the specified args and block, and applied to in the order in
+      # which they are declared (ie first use processes requests first).
+      #
+      # Middleware is applied through the class call method, and on a per-call
+      # basis... middleware like Rack::Session::Pool that is supposed to
+      # persist for the life of an application will not work properly.
+      # 
+      # Middleware is inherited.
+      def use(middleware, *args, &block)
+        @middleware << [middleware, args, block]
+      end
+      
+      # Instantiates self and performs call.  Middleware is applied in the
+      # order in which it was declared.
+      #--
+      # Note that middleware needs to be initialized in reverese, so that
+      # the first declared middleware runs first.
+      def call(env)
+        app = new
+        middleware.reverse_each do |(m, args, block)|
+          app = m.new(app, *args, &block)
+        end
+        app.call(env)
+      end
+      
+      # Sets an instance variable for self, short for:
+      #
+      #   instance_variable_set(:@attribute, input)
+      #
+      # Typically only these variables should be set:
+      #
+      #   actions:: sets actions
+      #   name:: the name of the controller
+      #   default_layout:: the default layout (used by render)
+      #
+      def set(variable, input)
+        instance_variable_set("@#{variable}", input)
+      end
+      
+      protected
+      
+      # Overridden so that if declare_action is set, new methods
+      # are added to actions.
+      def method_added(sym) # :nodoc:
+        actions << sym if @define_action
+        super
+      end
+      
+      # Turns on declare_action when changing method context.
+      def public(*symbols) # :nodoc:
+        @define_action = true if symbols.empty?
+        super
+      end
+      
+      # Turns off declare_action when changing method context.
+      def protected(*symbols) # :nodoc:
+        @define_action = false if symbols.empty?
+        super
+      end
+      
+      # Turns off declare_action when changing method context.
+      def private(*symbols) # :nodoc:
+        @define_action = false if symbols.empty?
+        super
+      end
+    end
+    
+    set :actions, []
+    set :middleware, []
+    set :default_layout, nil
+    set :define_action, false
+    
+    include Rack::Utils
+    
+    # Accesses the 'tap.server' specified in env, set during call.
+    attr_accessor :server
+    
+    # A Rack::Request wrapping env, set during call.
+    attr_accessor :request
+    
+    # A Rack::Response.  If the action returns a string, it will be written to
+    # response and response will be returned by call.  Otherwise, call returns
+    # the action result and response is ignored.
+    attr_accessor :response
+    
+    # Initializes a new instance of self.  The input attributes are reset by
+    # call and are only provided for convenience during testing.
+    def initialize(server=nil, request=nil, response=nil)
+      @server = server
+      @request = request
+      @response = response
+    end
+    
+    def call(env)
+      @server = env['tap.server'] || Tap::Server.new
+      @request = Rack::Request.new(env)
+      @response = Rack::Response.new
+      
+      # route to an action
+      blank, action, *args = request.path_info.split("/").collect {|arg| unescape(arg) }
+      action = "index" if action == nil || action.empty?
+      
+      unless self.class.actions.include?(action.to_sym)
+        raise ServerError.new("404 Error: page not found", 404)
+      end
+      
+      result = send(action, *args)
+      if result.kind_of?(String) 
+        response.write result
+        response.finish
+      else 
+        result
+      end
+    end
+    
+    def render(path, options={})
+      options, path = path, nil if path.kind_of?(Hash)
+      
+      # lookup template
+      template_path = case
+      when options.has_key?(:template)
+        server.template_path(options[:template])
+      else
+        server.template_path("#{self.class.name}/#{path}")
+      end
+      
+      unless template_path
+        raise "could not find template for: #{path}"
+      end
+      
+      # render template
+      template = server.content(template_path)
+      content = render_erb(template, options)
+      
+      # render layout
+      layout = options[:layout]
+      layout = self.class.default_layout if layout == true
+      if layout
+        render(:template => layout, :locals => {:content => content})
+      else
+        content
+      end
+    end
+    
+    def render_erb(template, options={})
+      # assign locals to the render binding
+      # this almost surely may be optimized...
+      locals = options[:locals]
+      binding = empty_binding
+      
+      locals.each_pair do |key, value|
+        @assignment_value = value
+        eval("#{key} = remove_instance_variable(:@assignment_value)", binding)
+      end if locals
+      
+      ERB.new(template, nil, "<>").result(binding)
+    end
+    
+    # Redirects to the specified uri.
+    def redirect(uri, status=302, headers={}, body="")
+      response.status = status
+      response.headers.merge!(headers)
+      response.body = body
+      
+      response['Location'] = uri
+      response.finish
+    end
+    
+    # Returns a session hash.
+    def session
+      request.env['rack.session'] ||= {}
+    end
+    
+    # Returns the app for the current session.
+    def app
+      server.app(session[:id] ||= server.initialize_session)
+    end
+    
+    # Generates an empty binding to self without any locals assigned.
+    def empty_binding # :nodoc:
+      binding
+    end
+  end
+end