tap-server 0.3.0 → 0.4.0

data/lib/tap/controllers/schema.rb

@@ -1,260 +1,174 @@
-require 'tap/controller'
+require 'tap/controllers/data'
 
 module Tap
   module Controllers
-    
-    # ::controller
-    class Schema < 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
+    class Schema < Data
+      
+      # Adds tasks or joins to the schema.  Parameters:
       #
-      # 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')
+      # tasks[]::   An array of tasks to add to the schema.
+      # inputs[]::  An array of task indicies used as inputs to a join.
+      # outputs[]:: An array of task indicies used as outputs for a join.
       #
       def add(id)
-        unless request.post?
-          raise Tap::ServerError, "add must be performed with post"
+        if id == "new"
+          id = data.next_id(type).to_s
         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
+        tasks = request['tasks'] || []
+        inputs = request['inputs'] || []
+        outputs = request['outputs'] || []
+        queue = request['queue'] || []
         
-            schema.set(Tap::Support::Join, inputs, outputs)
+        update_schema(id) do |schema|
+          current = schema.tasks
+          tasks.each do |task|
+            key = task
+            while current.has_key?(key)
+              i ||= 0
+              key = "#{task}_#{i}"
+              i += 1
+            end
+            
+            current[key] = {'id' => task}
+          end
+          
+          if !inputs.empty? && !outputs.empty?
+            schema.joins << [inputs, outputs]
+          end
+          
+          queue.each do |task|
+            schema.queue << [task]
           end
         end
-    
-        redirect("/schema/display/#{id}")
+        
+        redirect uri(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
+      
+      # Removes tasks or joins from a schema.  Parameters:
       #
-      # 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'.
+      # tasks[]:: An array of task keys to remove.
+      # joins[]:: An array of join indicies to remove.
       #
       def remove(id)
-        unless request.post?
-          raise Tap::ServerError, "remove must be performed with post"
+        if id == "new"
+          id = data.next_id(type).to_s
         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
+        
+        tasks = request['tasks'] || []
+        joins = request['joins'] || []
+        queue = request['queue'] || []
+        
+        update_schema(id) do |schema|
+          tasks.each do |key|
+            schema.tasks.delete(key)
           end
+          
+          joins.each {|index| schema.joins[index.to_i] = nil }
+          schema.joins.compact!
+          
+          queue.each {|index| schema.queue[index.to_i] = nil }
+          schema.queue.compact!
+          
+          schema.cleanup!
         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
+        redirect uri(id)
       end
-  
-      def save(id)
-        unless request.post?
-          raise Tap::ServerError, "submit must be performed with post"
+      
+      def configure(id)
+        if id == "new"
+          id = data.next_id(type).to_s
         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"
+        
+        schema = Tap::Schema.new(request['schema'] || {})
+        schema.scrub! do |obj|
+          scrub(obj['config'])
         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
+        
+        data.create_or_update(type, id) do |io| 
+          io << schema.dump
         end
-    
-        Thread.new { app.run }
-        redirect("/app/tail")
+        
+        redirect uri(id)
       end
-  
+      
+      # Helper methods
       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)
+      
+      def env
+        server.env
       end
-  
-      def initialize_schema
-        current = root.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
+      
+      def type
+        :schema
       end
-  
-      def load_schema(id)
-        unless path = root.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
+      
+      def display(id)
+        schema = if path = data.find(type, id)
+          Tap::Schema.load_file(path)
         else
-          schema
+          Tap::Schema.new
         end
+        
+        schema.resolve! do |type, key, data|
+          env.manifest(type)[key]
+        end
+        
+        render "entry.erb", :locals => {
+          :id => id,
+          :schema => schema
+        }, :layout => true
       end
-  
-      def dump_schema(id, schema=nil)
-        root.prepare(:schema, "#{id}.yml") do |file|
-          file << YAML.dump(schema.dump) if schema
+      
+      def stringify(obj)
+        case obj
+        when String, Numeric, true, false
+          obj.to_s
+        when Symbol, Regexp
+          obj.inspect
+        when nil
+          '~'
+        when $stdout
+          'data/results.txt'
+        else
+          obj
         end
       end
-  
-      def instantiate(*argv)
-        key = argv.shift
-        tasc = server.env.tasks.search(key).constantize 
-        tasc.parse(argv)
+      
+      def default_config(configurable)
+        configs = configurable.configurations
+        Configurable::DelegateHash.new(configs).to_hash do |hash, key, value|
+          hash[key.to_s] = stringify(value)
+        end
       end
-  
-      # helper to echo requests back... good for debugging
-      def echo # :nodoc:
-        "<pre>#{request.params.to_yaml}</pre>"
+      
+      def scrub(obj)
+        case obj
+        when Hash
+          obj.delete_if do |key, value|
+            value ? scrub(value) : true
+          end
+        when Array
+          obj.delete_if do |value| 
+            value ? scrub(value) : true
+          end
+        end
+        
+        false
       end
-  
-      # Generates a random integer key.
-      def random_key(length) # :nodoc:
-        length = 1 if length < 1
-        rand(length * 10000).to_s
+      
+      def update_schema(id)        
+        path = data.find(type, id) || data.create(type, id)
+        schema = Tap::Schema.load_file(path)
+        
+        yield(schema)
+        
+        data.update(type, id) do |io| 
+          io << schema.dump
+        end
+        
+        id
       end
     end
   end

data/lib/tap/controllers/server.rb

@@ -1,9 +1,11 @@
 require 'tap/controller'
+require 'rack/mime'
+require 'time'
 
 module Tap
   module Controllers
     
-    # :startdoc::controller remotely controls and monitors server
+    # :startdoc::controller remotely controls and monitor a server
     # 
     # Server provides several uris to control and monitor the server behavior.
     # Importantly, server allows the remote shutdown of a Tap::Server if a
@@ -11,48 +13,89 @@ module Tap
     # background and still have a shutdown handle on them.
     #
     class Server < Tap::Controller
-      set :default_layout, 'layout.erb'
-  
+      include Utils
+      
       def index
-        render 'index.erb'
+        render('index.erb', :layout => true)
       end
       
-      # Returns 'pong'.
+      # Returns pong
       def ping
-        response['Content-Type'] = 'text/plain'
+        response['Content-Type'] = "text/plain"
         "pong"
       end
       
-      # Returns the public server configurations as xml.
-      def config
-        response['Content-Type'] = 'text/xml'
-        %Q{<?xml version="1.0"?>
-<server>
-<uri>#{uri}</uri>
-<shutdown_key>#{shutdown_key}</shutdown_key>
-</server>}
+      # Essentially a login for server administration
+      def access
+        if request.get?
+          render 'access.erb', :locals => {
+            :secret => request['secret']
+          }, :layout => true
+        else
+          redirect uri("admin", :secret => request['secret'])
+        end
+      end
+      
+      # Administrate this server
+      def admin(secret=nil)
+        template = server.admin?(secret) ? 'admin.erb' : 'access.erb'
+        render template, :locals => {:secret => secret}, :layout => true
       end
       
-      # Shuts down the server.  Shutdown requires a shutdown key which
-      # is setup when the server is launched.  If no shutdown key was
-      # setup, shutdown does nothing and responds accordingly.
-      def shutdown
-        if shutdown_key && request['shutdown_key'].to_i == shutdown_key
-          # wait a second to shutdown, so the response is sent out.
-          Thread.new {sleep 1; server.stop! }
+      # Terminates app and stops self (on post).
+      def shutdown(secret=nil)
+        response['Content-Type'] = "text/plain"
+        
+        if server.admin?(secret) && request.post?
+          # wait a bit to shutdown, so the response is sent out.
+          Thread.new { sleep(0.1); server.stop! }
           "shutdown"
         else
-          "you do not have permission to shutdown this server"
+          ""
         end
       end
       
-      protected
+      def help(type=nil, *key)
+        if constant = server.env[type][key.join('/')]
+          module_render 'help.erb', constant
+        else
+          "unknown #{type}: #{key.join('/')}"
+        end
+      end
       
-      # returns the server shutdown key.  the shutdown key is required
-      # for shutdown to function, a nil shutdown key disables shutdown.
-      def shutdown_key  # :nodoc:
-        server.shutdown_key
+      # ensure server methods are not added as actions
+      set :define_action, false
+      
+      def call(rack_env)
+        path = rack_env['tap.server'].env.path(:public, rack_env['PATH_INFO']) {|file| File.file?(file) }
+        if path
+          static_file(path)
+        else
+          super
+        end
       end
+      
+      # Returns a controller uri, attaching the secret to the action, if specified.
+      def uri(action=nil, params={})
+        secret = params.delete(:secret)
+        
+        if secret
+          action = action ? "#{action}/#{secret}" : secret
+        end
+        
+        super(action, params)
+      end
+      
+      # Returns a help uri for the specified resource, currently only sketched out.
+      def help_uri(type, key)
+        uri("help/#{type}/#{key}")
+      end
+      
+      # Stops the server.
+      def stop!
+        server.stop!
+      end
+      
     end
   end
 end