tap-server 0.3.0 → 0.4.0

data/lib/tap/controllers/app.rb

@@ -1,59 +1,109 @@
 require 'tap/controller'
-require 'rack/mime'
-require 'time'
+require 'tap/controllers/schema'
 
 module Tap
   module Controllers
     
-    # ::controller
+    # :startdoc::controller builds and runs workflows
     class App < 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.search(:public, 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]
-          }
+      set :default_action, :info
       
-          [200, headers, [content]]
-        else
-          super
+      nest :schema, Schema do
+        def dispatch(route)
+          route.unshift rest_action(route)
+          super(route)
         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)
+      
+      # Returns the state of app.
+      def state
+        app.state.to_s
       end
       
+      # Returns the controls and current application info.
       def info
+        render 'info.erb', :locals => {
+          :actions => [:run, :stop, :terminate, :reset],
+        }, :layout => true
+      end
+      
+      # Runs app on a separate thread (on post).
+      def run
         if request.post?
-          app.info
+          server.thread ||= Thread.new { app.run; server.thread = nil; }
+        end
+        
+        redirect uri(:info)
+      end
+      
+      def reset
+        app.reset if request.post?
+        redirect uri(:info)
+      end
+      
+      # Stops app (on post).
+      def stop
+        app.stop if request.post?
+        redirect uri(:info)
+      end
+      
+      # Teminates app (on post).
+      def terminate
+        app.terminate if request.post?
+        redirect uri(:info)
+      end
+      
+      def build
+        schema = request[:schema] || server.data.read(:schema, request[:id])
+        
+        unless request.post?
+          return render('build.erb', :schema => schema, :layout => true)
+        end
+        
+        schema = Tap::Schema.load(schema).resolve! do |type, key, data|
+          server.env.manifest(type)[key]
+        end.validate!
+        
+        if request[:reset] == "on"
+          app.reset
+        end
+        
+        tasks.merge!(server.env.build(schema, app))
+        
+        if request[:run] == "on"
+          run
         else
-          render('info.erb', :locals => {:update => true, :content => app.info}, :layout => true)
+          redirect uri(:enque)
         end
       end
-  
-      #--
-      # Currently tail is hard-coded to tail the server log only.
-      def tail(id=nil)
-        begin
-          path = root.subpath(:log, 'server.log')
-          raise unless File.exists?(path)
-        rescue
-          raise Tap::ServerError.new("invalid path", 404)
+      
+      def enque
+        unless request.post?
+          return render('enque.erb', :layout => true)
         end
-    
+        
+        queue = if request[:load]
+          YAML.load(request[:queue] || "{}")
+        else
+          request[:queue] || {}
+        end
+        
+        queue.each do |(key, inputs)|
+          unless task = tasks[key]
+            raise "no task for: #{key}"
+          end
+          app.enq(task, *inputs)
+        end
+        
+        redirect uri(:info)
+      end
+      
+      def tail(id)
+        unless data.has?("#{id}.log")
+          raise Tap::ServerError.new("invalid id: #{id}", 404)
+        end
+        
+        path = data.path("#{id}.log")
         pos = request['pos'].to_i
         if pos > File.size(path)
           raise Tap::ServerError.new("tail position out of range (try update)", 500)
@@ -75,23 +125,15 @@ module Tap
           }, :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")
+      
+      protected
+      
+      def tasks
+        app.cache[:tasks] ||= {}
       end
-  
-      def help(key=nil)
+      
+      def app
+        server.app
       end
     end
   end

data/lib/tap/controllers/data.rb

@@ -0,0 +1,132 @@
+require 'tap/controller'
+
+module Tap
+  module Controllers
+    # ::controller
+    class Data < Tap::Controller
+      include RestRoutes
+      include Utils
+      
+      set :default_layout, 'layout.erb'
+      
+      # GET /projects
+      def index
+        render 'index.erb', :layout => true
+      end
+      
+      # GET /projects/id
+      # GET /projects?id=id&as=
+      def show(id)
+        case request['as']
+        when 'preview'
+          response.headers['Content-Type'] = 'text/plain'
+          data.read(type, id)
+        
+        when 'download'
+          unless path = data.find(type, id)
+            raise "unknown #{type}: #{id.inspect}"
+          end
+          
+          download(path)
+        else
+          display(id)
+        end
+      end
+      
+      # POST /projects/id
+      # POST /projects?id=id
+      # POST /projects?type=
+      def create(id)
+        if id == "new"
+          id = data.next_id(type).to_s
+        end
+        
+        data.create(type, id) {|io| io << parse_entry }
+        redirect uri(id)
+      end
+      
+      # PUT /projects/id
+      # POST /projects/id?_method=put
+      # POST /projects?_method=put&_action=select&id=id
+      def update(id)
+        data.update(type, id) {|io| io << parse_entry }
+        redirect uri(id)
+      end
+      
+      # DELETE /projects/id
+      # POST /projects/id?_method=delete
+      # POST /projects?_method=put&id=id
+      def destroy(id)
+        data.destroy(type, id)
+        redirect uri
+      end
+      
+      def upload(id=nil)
+        check_id(id)
+        data.import(type, request[type], id)
+        redirect uri
+      end
+      
+      def select(ids=[])
+        data.cache[type] = ids
+        redirect uri
+      end
+      
+      # Renames id to request['name'] in the schema data.
+      def rename(id)
+        redirect data.move(type, id, request['new_id'])
+      end
+      
+      def duplicate(id)
+        redirect data.copy(type, id, request['new_id'] || "#{id}_copy")
+      end
+      
+      # Helper methods
+      protected
+      
+      def type
+        :data
+      end
+      
+      def data
+        server.data
+      end
+      
+      #--
+      # args remains an array, ie methods can take one or no inputs (but note
+      # that if id is specified as an array, methods can receive and array of
+      # ids.)
+      def dispatch(route)
+        action, *args = route
+        
+        if args.empty?
+          if id = request['id']
+            args << id
+          end 
+        else
+          args = [File.join(*args)] 
+        end
+        
+        args.unshift(action)
+        super(args)
+      end
+      
+      def display(id)
+        render "entry.erb", :locals => {
+          :id => id,
+          :content => data.read(type, id)
+        }, :layout => true
+      end
+      
+      def parse_entry
+        request[type]
+      end
+      
+      def check_id(id)
+        if id == "new"
+          raise "reserved id: #{id.inspect}"
+        end
+      end
+    end
+  end
+end