stella 0.8.8.001 → 2.0.1.001

data/lib/stella/report.rb

@@ -0,0 +1,391 @@
+begin
+  require 'pismo'
+rescue LoadError
+end
+
+class Stella
+  class Log
+    class HTTP < Storable
+      include Gibbler::Complex
+      include Selectable::Object
+      field :stamp
+      field :httpmethod
+      field :uri     
+      field :request_params
+      field :request_headers
+      field :request_body
+      field :response_status
+      field :response_headers
+      field :response_body
+      field :msg
+    end
+  end
+  class Report < Storable
+    include Gibbler::Complex
+    CRLF = "\r\n" unless defined?(Report::CRLF)
+    @plugins, @plugin_order = {}, []
+    class << self
+      attr_reader :plugins, :plugin_order
+      def plugin?(name)
+        @plugins.has_key? name
+      end
+      def load(name)
+        @plugins[name]
+      end
+    end
+    module Plugin
+      def self.included(obj)
+        obj.extend ClassMethods
+        obj.field :processed => Boolean
+      end
+      def processed!
+        @processed = true
+      end
+      def processed?
+        @processed == true
+      end
+      attr_reader :report
+      def initialize(report=nil)
+        @report = report
+      end
+      module ClassMethods
+        attr_reader :plugin
+        def register(plugin)
+          @plugin = plugin
+          extra_methods = eval "#{self}::ReportMethods" rescue nil
+          Stella::Report.send(:include, extra_methods) if extra_methods
+          Stella::Report.field plugin => self
+          Stella::Report.plugins[plugin] = self
+          Stella::Report.plugin_order << plugin
+        end
+        def process *args
+          raise StellaError, "Must override run"
+        end
+      end
+    end
+
+    class Errors < Storable
+      include Gibbler::Complex
+      include Report::Plugin
+      field :exceptions
+      field :timeouts
+      field :fubars
+      def process(filter={})
+        @exceptions = report.timeline.messages.filter(:kind => :http_log, :state => :exception)
+        @timeouts = report.timeline.messages.filter(:kind => :http_log, :state => :timeout)
+        @fubars = report.timeline.messages.filter(:kind => :http_log, :state => :fubar)
+        processed!
+      end
+      def exceptions?
+        !@exceptions.nil? && !@exceptions.empty?
+      end
+      def timeouts?
+        !@timeouts.nil? && !@timeouts.empty?
+      end
+      def fubars?
+        !@fubars.nil? && !@fubars.empty?
+      end
+      def all 
+        [@exceptions, @timeouts, @fubars].flatten
+      end
+      module ReportMethods
+        # expects Statuses plugin is loaded
+        def errors?
+          exceptions? || timeouts? || fubars? || (statuses && !statuses.nonsuccessful.empty?)
+        end
+        def exceptions?
+          return false unless processed? && errors
+          errors.exceptions?
+        end
+        def timeouts?
+          return false unless processed? && errors
+          errors.timeouts?
+        end
+        def error_count
+          errors.all.size
+        end
+        def fubars?
+          return false unless processed? && errors
+          errors.fubars?
+        end
+      end
+      register :errors
+    end
+    
+    class Content < Storable
+      include Gibbler::Complex
+      include Report::Plugin
+      field :request_body
+      field :response_body
+      field :request_body_digest
+      field :response_body_digest
+      field :keywords => Array
+      field :title
+      field :favicon
+      field :author
+      field :lede
+      field :description
+      field :is_binary => Boolean
+      field :is_image => Boolean
+      field :log => Array
+      def binary?
+        @is_binary == true
+      end
+      def image?
+        @is_image == true
+      end
+      def process(filter={})
+        if report.errors.exceptions?
+          @log = report.errors.exceptions
+        elsif report.errors.fubars?
+          @log = report.errors.fubars
+        elsif report.errors.timeouts?
+          @log = report.errors.timeouts
+        else
+          @log = report.timeline.messages.filter(:kind => :http_log, :state => :nominal)
+        end
+        
+        return if @log.empty?
+        
+        unless Stella::Utils.binary?(@log.first.request_body) || Stella::Utils.image?(@log.first.request_body)
+          @request_body = @log.first.request_body 
+        end
+        
+        @request_body_digest = @log.first.request_body.digest
+        @is_binary = Stella::Utils.binary?(@log.first.response_body)
+        @is_image = Stella::Utils.image?(@log.first.response_body)
+        unless binary? || image?
+          @response_body = @log.first.response_body.to_s
+          if @response_body.size >= 250_000
+            @response_body = @response_body.slice 0, 249_999
+            @response_body << ' [truncated]'
+          end
+          @response_body.force_encoding("UTF-8") if RUBY_VERSION >= "1.9.0"
+          begin 
+            if defined?(Pismo) && @response_body
+              doc = Pismo::Document.new @response_body
+              @keywords = doc.keywords rescue nil  # BUG: undefined method `downcase' for nil:NilClass
+              @title = doc.title
+              @favicon = doc.favicon
+              @author = doc.author
+              @lede = doc.lede
+              @description = doc.description
+            end
+          rescue => ex
+            Stella.li ex.message
+            # /Library/Ruby/Gems/1.8/gems/nokogiri-1.4.1/lib/nokogiri/xml/fragment_handler.rb:37: [BUG] Segmentation fault
+            #  ruby 1.8.7 (2008-08-11 patchlevel 72) [universal-darwin10.0]
+          end
+        end
+        @response_body_digest = @log.first.response_body.digest
+        @log.each { |entry| entry.response_body = ''; entry.request_body = '' }
+        processed!
+      end
+      module ReportMethods
+        def log
+          content.log
+        end
+      end
+      register :content
+    end
+    
+    class Statuses < Storable
+      include Gibbler::Complex
+      include Report::Plugin
+      field :values => Array
+      def process(filter={})
+        @values = report.content.log.collect { |entry| entry.tag_values(:status) }.flatten
+        processed!
+      end
+      def nonsuccessful
+        @values.select { |status| status.to_i >= 400 }
+      end
+      def successful
+        @values.select { |status| status.to_i < 400 }
+      end
+      def redirected
+        @values.select { |status| (300..399).member?(status.to_i) }
+      end
+      def success?
+        nonsuccessful.empty?
+      end
+      def redirect?
+        @values.size == redirected.size
+      end
+      module ReportMethods
+        def redirect?
+          statuses.redirect?
+        end
+        def success?
+          statuses.success?
+        end
+        def statuses_pretty
+          pretty = ["Statuses"]
+          if statuses.successful.size > 0
+            pretty << '%20s: %s' % ['successful', statuses.successful.join(', ')] 
+          end
+          if statuses.nonsuccessful.size > 0
+            pretty << '%20s: %s' % ['nonsuccessful', statuses.nonsuccessful.join(', ')] 
+          end
+          pretty.join $/
+        end
+      end
+      register :statuses
+    end
+    
+    class Headers < Storable
+      include Gibbler::Complex
+      include Report::Plugin
+      field :request_headers
+      field :response_headers
+      field :request_headers_digest
+      field :response_headers_digest
+      def init *args
+        # TODO: This doesn't seem to be called anymore.
+        @request_headers_hash = {}
+        @response_headers_hash = {}
+      end
+      def process(filter={})
+        return if report.content.log.empty?
+        @request_headers = report.content.log.first.request_headers
+        @response_headers = report.content.log.first.response_headers
+        @request_headers_digest = report.content.log.first.request_headers.digest
+        @response_headers_digest = report.content.log.first.response_headers.digest
+        processed!
+      end
+      def request_header name=nil
+        @request_headers_hash ||= {}
+        if @request_headers_hash.empty? && @request_headers
+          @request_headers_hash = parse(@request_headers)
+        end
+        name.nil? ? @request_headers_hash : @request_headers_hash[name.to_s.upcase]
+      end
+      def response_header name=nil
+        @response_headers_hash ||= {}
+        if @response_headers_hash.empty? && @response_headers
+          @response_headers_hash = parse(@response_headers)
+        end
+        name.nil? ? @response_headers_hash : @response_headers_hash[name.to_s.upcase]
+      end
+      def empty?
+        @response_headers.to_s.empty?
+      end
+      private 
+      def parse str
+        headers = {}
+        str.split(CRLF).each do|line|
+          key, value = line.split(/\s*:\s*/, 2)
+          headers[key.upcase] = value
+        end
+        headers
+      end
+      register :headers
+    end
+
+    class Metrics < Storable
+      include Gibbler::Complex
+      include Report::Plugin
+      field :response_time            => Benelux::Stats::Calculator
+      field :socket_connect           => Benelux::Stats::Calculator
+      field :first_byte               => Benelux::Stats::Calculator
+      field :last_byte                => Benelux::Stats::Calculator
+      field :send_request             => Benelux::Stats::Calculator
+      field :request_headers_size     => Benelux::Stats::Calculator
+      field :request_content_size     => Benelux::Stats::Calculator
+      field :response_headers_size    => Benelux::Stats::Calculator
+      field :response_content_size    => Benelux::Stats::Calculator
+      field :requests                 => Integer
+      def process(filter={})
+        return if processed?
+        @response_time = report.timeline.stats.group(:response_time).merge
+        @socket_connect = report.timeline.stats.group(:socket_connect).merge
+        @first_byte = report.timeline.stats.group(:first_byte).merge
+        @send_request = report.timeline.stats.group(:send_request).merge
+        @last_byte = report.timeline.stats.group(:last_byte).merge
+        #@response_time2 = Benelux::Stats::Calculator.new 
+        #@response_time2.sample @socket_connect.mean + @send_request.mean + @first_byte.mean + @last_byte.mean
+        @requests = report.timeline.stats.group(:requests).merge.n
+        @request_headers_size = Benelux::Stats::Calculator.new 
+        @request_content_size = Benelux::Stats::Calculator.new 
+        @response_headers_size = Benelux::Stats::Calculator.new 
+        @response_content_size = Benelux::Stats::Calculator.new 
+
+        @request_content_size.sample report.content.request_body.size unless report.content.request_body.to_s.empty?
+        @response_content_size.sample report.content.response_body.size unless report.content.response_body.to_s.empty?
+
+        @request_headers_size.sample report.headers.request_headers.size unless report.headers.request_headers.to_s.empty?
+        @response_headers_size.sample report.headers.response_headers.size unless report.headers.response_headers.to_s.empty?
+
+        # unless report.content.log.empty?
+        #   report.content.log.each do |entry|
+        #     @request_headers_size.sample entry.request_headers.size if entry.request_headers
+        #     @request_content_size.sample entry.request_body.size if entry.request_body
+        #     @response_headers_size.sample entry.response_headers.size if entry.response_headers
+        #     @response_content_size.sample entry.response_body.size if entry.response_body
+        #   end
+        # end
+        processed!
+      end
+      def postprocess
+        self.class.field_names.each do |fname|
+          next unless self.class.field_types[fname] == Benelux::Stats::Calculator
+          hash = send(fname)
+          val = Benelux::Stats::Calculator.from_hash hash
+          send("#{fname}=", val)
+        end
+      end
+      module ReportMethods
+        def metrics_pack
+          return unless metrics
+          pack = ::MetricsPack.new
+          pack.update Stella.now, runid.shorten, metrics.requests, metrics.response_time, metrics.socket_connect, metrics.send_request.to_f.to_s,
+                      metrics.first_byte, metrics.last_byte, metrics.request_headers_size, metrics.request_content_size,
+                      metrics.response_headers_size, metrics.response_content_size, 0, error_count
+          pack
+        end
+        def metrics_pretty
+          return unless metrics
+          pretty = ['Metrics   (across %d requests)' % metrics.requests]
+          [:socket_connect, :send_request, :first_byte, :last_byte, :response_time].each do |fname|
+            val = metrics.send(fname)
+            pretty << ('%20s: %8sms' % [fname.to_s.tr('_', ' '), val.mean.to_ms])
+          end
+          pretty << ''
+          [:request_headers_size, :response_content_size].each do |fname|
+            val = metrics.send(fname)
+            pretty << ('%20s: %8s' % [fname.to_s.tr('_', ' '), val.mean.to_bytes])
+          end
+          pretty.join $/
+        end
+      end
+      register :metrics
+    end
+    
+    field :processed => Boolean
+    
+    attr_reader :runid, :timeline, :filter
+    def initialize(timeline=nil, runid=nil)
+      @timeline, @runid = timeline, runid
+      @processed = false
+    end
+    def postprocess
+      self.class.plugins.each_pair do |name,klass|
+        val = klass.from_hash(self.send(name))
+        self.send("#{name}=", val)
+      end
+    end
+    def process
+      self.class.plugin_order.each do |name|
+        klass = self.class.plugins[name]
+        Stella.ld "processing #{name}"
+        plugin = klass.new self
+        plugin.process(filter)
+        self.send("#{name}=", plugin)
+      end
+      @processed = true
+    end
+    def processed?
+      @processed == true
+    end
+  end
+end

data/lib/stella/testplan.rb

@@ -1,344 +1,470 @@
-autoload :CSV, 'csv'
-#Gibbler.enable_debug
 
-module Stella
-class Testplan < Storable
-  include Gibbler::Complex
-  extend Attic
-  
-  @file_cache = {}
-  @globals = {}
-  class << self
-    attr_reader :file_cache
-    attr_reader :globals
-    def readlines path
-      if @file_cache.has_key?(path)
-        Stella.ld "FILE CACHE HIT: #{path}"
-        return @file_cache[path]
-      end
-      Stella.ld "FILE CACHE LOAD: #{path}"
-      @file_cache[path] = File.readlines(path)
-    end
-    def global(n,v=nil)
-      @globals[n.to_sym] = v unless v.nil?
-      @globals[n.to_sym]
-    end
-    def global?(n)
-      @globals.has_key?(n.to_sym)
+
+class Stella
+  module Common
+    module PrivacyMethods
+      def private?
+        privacy == true
+      end
+      def public?
+        !private?
+      end
+      def private!
+        @privacy = true
+      end
+      def public!
+        @privacy = false
+      end
     end
   end
-  
-  attic :base_path
-  attic :plan_path
-  attic :description
-  
-  field :id => String, &gibbler_id_processor
-  field :userid => String
-  field :usecases => Array
-  field :description => String
-  #field :resources
-  
-  gibbler :usecases, :userid
-  
-  def initialize(*uris)
-    uris.flatten!
-    self.description = "Test plan"
-    @usecases = []
-    @testplan_current_ratio = 0
-    #@resources = {}
-    
-    unless uris.empty?
-      uris = [uris] unless Array === uris
-      usecase = Stella::Testplan::Usecase.new
-      usecase.ratio = 1.0
-      uris.each do |uri|
-        req = usecase.add_request :get, uri
+  class Testplan < Storable
+    include Gibbler::Complex
+    include Familia
+    include Common::PrivacyMethods
+    prefix :testplan
+    index :id
+    field :id, :class => Gibbler::Digest, :meth => :gibbler, &gibbler_id_processor
+    field :custid             => String
+    field :usecases           => Array
+    field :desc               => String
+    field :privacy            => Boolean
+    field :favicon            => String
+    field :last_run           => Integer
+    field :planid             => Gibbler::Digest
+    field :notify => Boolean
+    include Familia::Stamps
+    sensitive_fields :custid, :privacy, :notify
+    # Don't include privacy in the gibbler calculation because it
+    # doesn't make sense to have both a public and private testplan.
+    gibbler :custid, :usecases
+    def init(uri=nil)
+      preprocess
+      if uri
+        req = Stella::RequestTemplate.new :get, Stella.canonical_uri(uri)
+        @usecases << Stella::Usecase.new(req) 
       end
-      self.add_usecase usecase
     end
-  end
-  
-  def postprocess
-    @id &&= Gibbler::Digest.new @id
-  end
-  
-  def self.load_file(path)
-    conf = File.read path
-    plan = Stella::Testplan.new
-    plan.base_path = File.dirname path
-    plan.plan_path = path
-    # eval so the DSL code can be executed in this namespace.
-    plan.instance_eval conf, path 
-    plan
-  end
-  
-  def check!
-    # Adjust ratios if necessary
-    needy = @usecases.select { |u| u.ratio == -1 }
-    needy.each do |u|
-      u.ratio = (remaining_ratio / needy.size).to_f
+    alias_method :planid, :id
+    def favicon?() !@favicon.nil? && !@favicon.empty? end
+    def preprocess
+      @usecases ||= []
+      @privacy = false if @privacy.nil?
     end
-    if @testplan_current_ratio > 1.0 
-      msg = "Usecase ratio cannot be higher than 1.0"
-      msg << " (#{@testplan_current_ratio})"
-      raise Stella::WackyRatio, msg
+    def first_request
+      return if @usecases.empty?
+      @usecases.first.requests.first
+    end
+    def freeze
+      return if frozen?
+      @usecases.each { |uc| uc.freeze }
+      @id &&= Gibbler::Digest.new(@id || self.digest)
+      super
+      self
+    end
+    def postprocess
+      @id &&= Gibbler::Digest.new(@id)
+      @notify ||= false 
+      @notify &&= false if @notify == 'false'
+    end
+    def cust
+      @cust ||= Customer.from_redis @custid
+      @cust || Customer.anonymous
+    end
+    def monitor
+      MonitorInfo.from_redis @id
+    end
+    def monitored?
+      mon = monitor
+      mon && mon.enabled
+    end
+    def host
+      h = @host.nil? || frozen? ? HostInfo.load_or_create(hostid) : @host
+      frozen? ? h : (@host=h)
+    end
+    def hostid
+      h = (@hostid.nil? || frozen?) && first_request ? Stella.canonical_host(first_request.uri) : @hostid
+      frozen? ? h : (@hostid=h)
+    end
+    def destroy!
+      raise BS::Problem, "Monitor exists #{index}" if MonitorInfo.exists?(index)
+      host.testplans.rem self unless host.nil?
+      cust.testplans.rem self unless cust.nil?
+      super
+    end
+    def owner?(guess)
+      custid != nil && cust.custid?(guess)
+    end
+    def checkup base_uri, opts={}
+      opts[:base_uri] = base_uri
+      run Stella::Engine::Checkup, opts
+    end
+    def run engine, opts={}
+      testrun = Stella::Testrun.new self, engine.mode, opts
+      engine.run testrun
+    end
+    module ClassMethods
+      def usecases
+        @usecases ||= []
+        @usecases
+      end
+      def checkup base_uri, opts={}
+        Stella::Testplan.plan(self).checkup base_uri, opts
+      end
+      def run engine, opts={}
+        Stella::Testplan.plan(self).run engine, opts
+      end
+      def testplan
+        Stella::Testplan.plan(self)
+      end
+      # Session objects will extend registered classes.
+      def register klass=nil
+        unless klass.nil?
+          @registered_classes ||= []
+          @registered_classes << klass
+        end
+        @registered_classes
+      end
+      attr_reader :registered_classes
+      def session
+        @session ||= {}
+        @session
+      end
+    end
+    class << self
+      attr_reader :plans
+      def inherited obj
+        super
+        obj.extend ClassMethods
+      end
+      def from_hash(*args)
+        me = super(*args)
+        me.usecases.collect! { |uc| Stella::Usecase.from_hash(uc) }
+        me
+      end
+      def plans
+        @plans ||= {}
+        @plans
+      end
+      def plan(klass,v=nil)
+        # Store the class as a string. Ruby calls Object#hash before setting
+        # the hash key which conflicts with Familia::Object.hash.
+        plans[klass.to_s] = v unless v.nil?
+        plans[klass.to_s]
+      rescue NameError => ex
+        nil
+      end
+      def plan?(name)
+        !plan(name).nil?
+      end
+      def global?(name)
+        global.has_key?(name)
+      end
+      def global
+        @global ||= {}
+        @global
+      end
     end
   end
-  
-  # make sure all clients share identical test plans
-  def freeze
-    return if frozen?
-    Stella.ld "FREEZE TESTPLAN: #{self.description}"
-    @usecases.each { |uc| uc.freeze }
-    super
-    self
-  end
-  
-  def id
-    Gibbler::Digest.new(@id || self.digest)
-  end
-  
-  def self.from_hash(*args)
-    me = super(*args)
-    me.usecases.collect! { |uc| Stella::Testplan::Usecase.from_hash(uc) }
-    me
-  end
-  
-  def usecase(*args, &blk)
-    return @usecases if args.empty? && blk.nil?
-    ratio, name = nil,nil
-    unless args.empty?
-      ratio, name = args[0], args[1] if args[0].is_a?(Numeric)
-      ratio, name = args[1], args[0] if args[0].is_a?(String)
-    end
-    uc = Stella::Testplan::Usecase.new
-    uc.base_path = self.base_path
-    uc.plan_path = self.plan_path
-    uc.instance_eval &blk
-    uc.ratio = (ratio || -1).to_f
-    uc.description = name unless name.nil?
-    @testplan_current_ratio += uc.ratio if uc.ratio > 0
-    add_usecase uc
+  class Usecase < Storable
+    include Gibbler::Complex
+    field :id, :class => Gibbler::Digest, :meth => :gibbler, &gibbler_id_processor
+    field :desc             => String
+    field :ratio            => Float
+    field :requests         => Array
+    field :http_auth        => Hash
+    field :ucid             => Gibbler::Digest
+    gibbler :requests
+    def initialize(req=nil)
+      preprocess
+      @requests << req if req
+    end
+    alias_method :ucid, :id
+    def preprocess
+      @requests ||= []
+    end
+    def postprocess
+      @id &&= Gibbler::Digest.new(@id)
+    end
+    def freeze
+      return if frozen?
+      @requests.each { |r| r.freeze }
+      @id &&= Gibbler::Digest.new(@id || self.digest)
+      super
+      self
+    end
+    module ClassMethods
+      [:get, :put, :head, :post, :delete].each do |meth|
+        define_method meth do |*args,&definition|
+          path, opts = *args
+          create_request_template meth, path, opts, &definition
+        end
+      end
+      [:xget, :xput, :xhead, :xpost, :xdelete].each do |ignore|
+        define_method ignore do |*args|
+          Stella.ld " ignoring #{ignore}: #{args.inspect}"
+        end
+      end
+      def http_auth user, pass=nil, domain=nil
+        planname, ucname = *names
+        uc = Stella::Testplan.plan(planname).usecases.last
+        uc.http_auth = { :user => user, :pass => pass, :domain => domain }
+        uc.http_auth
+      end
+      # Session objects will extend registered classes.
+      def register klass=nil
+        unless klass.nil?
+          @registered_classes ||= []
+          @registered_classes << klass
+        end
+        @registered_classes
+      end
+      attr_reader :registered_classes
+      def session
+        @session ||= {}
+        @session
+      end
+      private 
+      def create_request_template meth, path, opts=nil, &definition
+        opts ||= {}
+        planname, ucname = *names
+        uc = Stella::Testplan.plan(planname).usecases.last
+        Stella.ld " (#{uc.class}) define: #{meth} #{path} #{opts if !opts.empty?}"
+        rt = RequestTemplate.new meth, path, opts, &definition
+        uc.requests << rt
+      end
+    end
+    class << self 
+      attr_accessor :instance, :testplan
+      # The class syntax uses the session method defined in ClassMethods.
+      # This is here for autogenerated usecases and ones loaded from JSON.
+      attr_reader :registered_classes, :session
+      def from_hash(*args)
+        me = super(*args)
+        me.requests.collect! { |req| Stella::RequestTemplate.from_hash(req) }
+        me
+      end
+      def checkup base_uri, opts={}
+        (opts[:usecases] ||= []) << self
+        testplan.checkup base_uri, opts
+      end
+      def names
+        names = self.to_s.split('::')
+        planname, ucname = case names.size
+        when 1 then ['DefaultTestplan', names.last]
+        else        [names[0..-2].join('::'), names[-1]] end
+        [eval(planname), ucname.to_sym]
+      end
+      def inherited(obj)
+        super
+        planclass, ucname = *obj.names
+        planclass.extend Stella::Testplan::ClassMethods
+        unless Stella::Testplan.plan? planclass
+          Stella::Testplan.plan(planclass, planclass.new)
+          Stella::Testplan.plan(planclass).desc = planclass
+        end
+        
+        obj.instance = obj.new
+        obj.testplan = Stella::Testplan.plan(planclass)
+        Stella::Testplan.plan(planclass).usecases << obj.instance
+        Stella::Testplan.plan(planclass).usecases.last.desc = ucname
+        obj.extend ClassMethods
+      end
+    end
   end
-  def xusecase(*args, &blk); Stella.ld "Skipping usecase"; end
-  
-  def add_usecase(uc)
-    Stella.ld "Usecase: #{uc.description}"
-    @usecases << uc
-    uc
+    
+  class EventTemplate < Storable
+    include Gibbler::Complex
   end
   
-  # for DSL use-only (otherwise use: self.description)
-  def desc(*args)
-    self.description = args.first unless args.empty?
-    self.description
+  class StringTemplate
+    include Gibbler::String
+    attr_reader :src
+    def initialize(src)
+      src = src.to_s
+      @src, @template = src, ERB.new(src)
+    end
+    def result(binding)
+      @template.result(binding)
+    end
+    def to_s() src end
   end
   
-  def pretty(long=false)
-    self.digest # make sure we have values in the cache
-    str = []
-    dig = long ? self.digest_cache : self.digest_cache.shorter
-    str << " %-66s  ".att(:reverse) % ["#{self.description}  (#{dig})"]
-    @usecases.each_with_index do |uc,i| 
-      uc.digest
-      dig = long ? uc.digest_cache : uc.digest_cache.shorter
-      desc = uc.description || "Usecase ##{i+1}"
-      desc += "  (#{dig}) "
-      str << (' ' << " %-61s %s%% ".att(:reverse).bright) % [desc, uc.ratio_pretty]
-      unless uc.http_auth.nil?
-        str << '    Auth: %s (%s/%s)' % uc.http_auth.values
-      end
-      requests = uc.requests.each do |r| 
-        r.digest
-        dig = long ? r.digest_cache : r.digest_cache.shorter
-        str << "    %-62s".bright % ["#{r.description}  (#{dig})"]
-        str << "      %s" % [r]
-        if Stella.stdout.lev > 1
-          [:wait].each { |i| str << "      %s: %s" % [i, r.send(i)] }
-          str << '       %s: %s' % ['params', r.params.inspect] 
-          r.response_handler.each do |status,proc|
-            str << "      response: %s%s" % [status, proc.source.split($/).join("#{$/}    ")]
-          end
+  class RequestTemplate < EventTemplate
+    field :id, :class => Gibbler::Digest, :meth => :gibbler, &gibbler_id_processor
+    field :protocol         => Symbol
+    field :http_method
+    field :http_version
+    field :http_auth
+    field :uri              => String do |v| v.to_s end
+    field :params           => Hash
+    field :headers          => Hash
+    field :body
+    field :desc
+    field :rtid             => Gibbler::Digest
+    field :wait             => Range
+    field :response_handler => Hash, &hash_proc_processor
+    field :follow           => Boolean
+    attr_accessor :callback
+    gibbler :http_method, :uri, :http_version, :params, :headers, :body
+    def initialize(meth=nil, uri=nil, opts={}, &definition)
+      @protocol = :http
+      @http_method, @uri = meth, uri
+      opts.each_pair { |n,v| self.send("#{n}=", v) if self.class.has_field?(n) }
+      @params ||= {}
+      @headers ||= {}
+      @follow ||= false
+      @callback = definition
+    end
+    def postprocess
+      @id &&= Gibbler::Digest.new(@id)
+      unless response_handler.nil?
+        response_handler.keys.each do |range|
+          proc = response_handler[range]
+          response_handler[range] = Proc.from_string(proc) if proc.kind_of?(ProcString)
         end
       end
     end
-    str.join($/)
-  end
-  
-  private
-  def remaining_ratio
-    1.0 - @testplan_current_ratio
+    def freeze
+      return if frozen?
+      @id &&= Gibbler::Digest.new(@id || self.digest)
+      super
+      self
+    end
+    alias_method :param, :params
+    alias_method :header, :headers
   end
+    
+  TP = Testplan
+  UC = Usecase
+  RT = RequestTemplate
+  ET = EventTemplate
   
 end
-end  
-  
-  
-module Stella
-class Testplan
 
-  #
-  # Any valid Ruby syntax will do the trick:
-  #
-  #     usecase(10, "Self-serve") {
-  #       post("/listing/add", "Add a listing") {
-  #         wait 1..4 
-  #         param :name => random(8)
-  #         param :city => "Vancouver"
-  #         response(302) {
-  #           repeat 3
-  #         }
-  #       }
-  #     }
-  #
-  class Usecase < Storable
+
+
+class Stella
+  class Testrun < Storable
     include Gibbler::Complex
-    include Stella::Data::Helpers
-    extend Attic
-    
-    class Auth < Struct.new(:domain, :user, :pass)
-      include Gibbler::Complex
+    include Familia
+    prefix :testrun
+    index :id
+    include Familia::Stamps
+    include Common::PrivacyMethods
+    field :id, :class => Gibbler::Digest, :meth => :gibbler, &gibbler_id_processor
+    field :custid             => String
+    field :status             => Symbol
+    field :options            => Hash
+    field :mode               => Symbol
+    field :hosts
+    field :ctime              => Float
+    field :stime              => Float
+    field :etime              => Float
+    field :salt
+    field :planid             => Gibbler::Digest
+    field :runid              => Gibbler::Digest
+    field :hostid
+    field :privacy            => Boolean
+    field :report             => Stella::Report
+    sensitive_fields :custid, :salt, :privacy
+    gibbler :salt, :planid, :custid, :hosts, :mode, :options, :ctime
+    attr_reader :plan
+    alias_method :start_time, :stime
+    alias_method :end_time, :etime
+    def init plan=nil, mode=nil, options={}
+      @ctime = Stella.now
+      @plan, @mode = plan, mode
+      @options = {
+      }.merge options
+      preprocess
     end
-    
-    attic :base_path # we don't want gibbler to see this
-    attic :plan_path
-    
-    field :id => String, &gibbler_id_processor
-    
-    attic :description
-    field :description => String
-    
-    field :ratio => Float
-    field :http_auth => Hash
-    field :timeout => Float
-    field :requests => Array
-    field :resources => Hash
-    
-    class UnknownResource < Stella::Error
-      def message; "UnknownResource: #{@obj}"; end
+    alias_method :runid, :id
+    def duration
+      return 0 unless @stime
+      (@etime || Stella.now) - @stime
     end
-    
-    def initialize(&blk)
-      @requests, @resources = [], {}
-      instance_eval &blk unless blk.nil?
+    def errors?
+      @report && @report.errors?
     end
-    
-    def id
-      Gibbler::Digest.new(@id || self.digest)
+    def preprocess
+      @salt ||= Stella.now.digest.short
+      @status ||= :new
+      if @plan
+        @planid = @plan.id 
+        @hostid = @plan.hostid
+      end
+      @options ||= {}
+      @privacy ||= false
     end
-    
-    def self.from_hash(hash={})
-      me = super(hash)
-      me.requests.collect! { |req| Stella::Data::HTTP::Request.from_hash(req) }
-      me
+    def postprocess
+      @id &&= Gibbler::Digest.new(@id)
+      # Calling plan calls Redis. 
+      #@privacy = plan.privacy if Stella::Testplan === plan
+      @report = Stella::Report.from_hash @report if Hash === @report
+      @planid &&= Gibbler::Digest.new(@planid)
     end
-    
-    
-    def desc(*args)
-      self.description = args.first unless args.empty?
-      self.description
+    def hostid
+      # NOTE: This method is needed only until May 30 or so.
+      # (there was an issue where incidents were not including a hostid)
+      @hostid || (plan.nil? ? nil : plan.hostid)
     end
-    
-    def timeout(*args)
-      @timeout = args.first unless args.empty?
-      @timeout
+    def run opts={}
+      raise StellaError.new("No mode") unless Stella::Engine.mode?(@mode)
+      engine = Stella::Engine.load(@mode)
+      opts.merge! @options
+      engine.run self, opts
+      save if respond_to? :save
+      self.report
     end
-    
-    def resource(name, *args)
-      if Hash === name
-        Stella.ld "ARGS IGNORED: #{args.inspect} (#{caller[0]})" if !args.empty?
-        @resources.merge! name
-      elsif !name.nil? && !args.empty?
-        @resources.merge!({name => args[0]})
-      elsif @resources.has_key?(name)
-        @resources[name]
-      elsif Stella::Testplan.global?(name)
-        Stella::Testplan.global(name)
-      end
-    end
-    alias_method :set, :resource
-    
-    def ratio
-      r = (@ratio || 0).to_f
-      r = r/100 if r > 1 
-      r
+    def checkup?
+      @mode == :checkup
     end
-    
-    def ratio_pretty
-      r = (@ratio || 0).to_f
-      r > 1.0 ? r.to_i : (r * 100).to_i
+    def monitor?
+      @mode == :monitor
     end
-    
-    # Reads the contents of the file <tt>path</tt> (the current working
-    # directory is assumed to be the same directory containing the test plan).
-    def read(path)
-      path = File.join(base_path, path) if base_path
-      Stella.ld "READING FILE: #{path}"
-      Stella::Testplan.readlines path
+    def destroy!
+      VendorInfo.global.checkups.remove self
+      host.checkups.remove self if host
+      plan.checkups.remove self if plan
+      cust.checkups.remove self if cust
+      super
     end
-      
-    def list(path)
-      read(path).collect { |line| line.strip }
+    def plan
+      if @plan.nil? 
+        @plan = Stella::Testplan.from_redis @planid
+        @plan.freeze
+      end
+      @plan
     end
-    
-    def csv(path)
-      path = File.join(base_path, path) if base_path
-      Stella.ld "READING CSV: #{path}"
-      file = Stella::Testplan.readlines path
-      CSV.parse file.join
+    def owner?(obj)
+      obj = Customer === obj ? obj.custid : obj
+      cust.username?(obj)
     end
-    
-    def quickcsv(path)
-      path = File.join(base_path, path) if base_path
-      Stella.ld "READING CSV(QUICK): #{path}"
-      ar = []
-      file = Stella::Testplan.readlines path
-      file.each do |l|
-        l.strip!
-        ar << l.split(',')
-      end
-      ar
+    def cust
+      @cust ||= Customer.from_redis @custid
+      @cust || Customer.anonymous
     end
-    
-    def freeze
-      return if frozen?
-      @requests.each { |r| r.freeze }
-      self.id ||= self.digest
-      super
-      self
+    def host
+      @host ||= plan.host if plan
+      @host
     end
-    
-    def auth(user, pass=nil, domain=nil)
-      @http_auth ||= Auth.new
-      @http_auth.user, @http_auth.pass, @http_auth.domain = user, pass, domain
+    class << self
+      attr_reader :statuses
+    end
+    @statuses = [:new, :pending, :running, :done, :failed, :fubar, :cancelled]
+    @statuses.each do |status|
+      define_method :"#{status}?" do
+        @status == status
+      end
+      define_method :"#{status}!" do
+        @status = status
+        begin
+          save if respond_to? :save
+        rescue Errno::ECONNREFUSED => ex
+          Stella.ld ex.message
+        end
+      end
     end
-    
-    def add_request(meth, *args, &blk)
-      if args[0].nil?
-        msg = "No URI given for request ##{@requests.size} "
-        msg << "#{meth} block in #{self.plan_path}"
-        raise Stella::Error, msg 
-      end
-      req = Stella::Data::HTTP::Request.new meth.to_s.upcase, args[0], &blk
-      req.description = args[1] if args.size > 1 # Description is optional
-      Stella.ld req
-      @requests << req
-      req
-    end
-    def get(*args, &blk);    add_request :get,    *args, &blk; end
-    def put(*args, &blk);    add_request :put,    *args, &blk; end
-    def post(*args, &blk);   add_request :post,   *args, &blk; end
-    def head(*args, &blk);   add_request :head,   *args, &blk; end
-    def delete(*args, &blk); add_request :delete, *args, &blk; end
-    
-    def xget(*args, &blk);    Stella.ld "Skipping get" end
-    def xput(*args, &blk);    Stella.ld "Skipping put" end
-    def xpost(*args, &blk);   Stella.ld "Skipping post" end
-    def xhead(*args, &blk);   Stella.ld "Skipping head" end
-    def xdelete(*args, &blk); Stella.ld "Skipping delete" end
-    
   end
-  
 end
-end
-
+class DefaultTestplan < Stella::Testplan; end