infod 0.0.2 → 0.0.3

data/infod/Th.rb

@@ -1,36 +0,0 @@
-#watch __FILE__
-require 'rack'
-%w{GET HEAD POST PATCH perf uid util 404 500}.map{|i|require_relative 'Th/' + i}
-
-class E
-
-  def E.call e
-    dev
-    e.extend Th
-    e['HTTP_X_FORWARDED_HOST'].do{|h| e['SERVER_NAME'] = h }
-    p = e['REQUEST_PATH'].force_encoding 'UTF-8'
-
-    uri = CGI.unescape(if (p.index Prefix) == 0
-                         p[Prefix.size..-1]
-                       else
-                         'http://' + e['SERVER_NAME'] + (p.gsub '+','%2B')
-                       end).E.env e
-    
-    if (uri.node.expand_path.to_s.index FSbase) == 0
-      e['uri'] = uri.uri
-      # response
-      r = nil              # request method
-      b = Benchmark.measure{ r = uri.send e.fn }
-      F['log'][r[0],e,b.real]
-      r
-    else
-      [403,{},['Forbidden']]
-    end
-
-  rescue Exception => x
-    $stderr.puts 500, e['REQUEST_URI'] ,x.message,x.backtrace
-    F['log'][500,e]
-    F['E500'][x,@r]
-  end
-
-end

data/infod/Th/500.rb

@@ -1,41 +0,0 @@
-class E
-
-  fn '/css/500.css/GET',->e,r{
-    [200,{'Content-Type'=>'text/css'},["
-body {margin:0; font-family: sans-serif; background-color:#fff; color:#000}
-h1 {padding:.2em; background-color:#f00; color:#fff; margin:0}
-div {display:inline}
-table {border-spacing:0;margin:0}
-b {background-color:#eee;color:#500;padding:.1em .3em .1em .3em}
-.frag {font-weight:bold; color:#000; background-color:#{E.cs}}
-td.space {background-color:#ddd}
-td.message {background-color:#009;color:#fff}
-td.path {text-align:right}
-td.index {text-align:right;border-color:#000;border-width:0 0 .1em 0;border-style:dotted;background-color:#ddd;color:#000}
-td.context {border-color:#ddd;border-width:0 0 .1em 0;border-style:dotted;padding:.15em}"]]}
-
-  F['/E/error/GET'] = ->e,r{1/0}
-
-  fn 'E500',->x,r{
-  [500,{'Content-Type'=>'text/html'},
-   [H[{_: :html,
-        c: [{_: :head,
-              c: [{_: :title, c: 500},(H.css '/css/500')]},
-            {_: :body,
-              c: [{_: :h1, c: 500},
-                  {_: :table,
-                    c: [{_: :tr,
-                          c: [{_: :td, c: {_: :b, c: x.class}},
-                              {_: :td, class: :space},
-                              {_: :td, class: :message, c: x.message.hrefs}
-                             ]},
-                        x.backtrace.map{|p|
-                          p = p.split /:/, 3
-                          {_: :tr,
-                            c: [{_: :td, class: :path, c: F['abbrURI'][p[0]]},
-                                {_: :td, class: :index, c: p[1]},
-                                {_: :td, class: :context, c: (p[2]||'').hrefs}].cr}}.cr]}]}]}]]]}
-
-  F['/500/GET'] = ->e,r{H([Errors.sort_by{|u,r|r[:time]}.reverse.html,H.css('/css/500')]).hR}
-  
-end

data/infod/Th/GET.rb

@@ -1,62 +0,0 @@
-class E
-
-  def GET
-    # bespoke handler ||
-    # raw file ||
-    # resource
-    if reqFn = F['req/'+@r.q['y']]
-      reqFn[self,@r]
-    elsif file = [self,pathSegment].compact.find(&:f)
-      a = @r.accept.values.flatten
-      accepted = a.empty? || (a.member? file.mimeP) || (a.member? '*/*')
-      (@r.q.has_any_key(%w{format view}) ||
-       MIMEcook[file.mimeP] || !accepted) ? resource : (file.env @r).getFile
-    else
-      resource
-    end
-  end
-
-  def getFile
-    @r['ETag'] = [m,size].h
-    maybeSend mimeP,->{self},:link
-  end
-
-  def resource
-    # bubble up site then global tree until handled (false return-value to pass)
-    pathSegment.do{|path|
-      lambdas = path.cascade.map{|p| p.uri.t + 'GET' }
-      ['http://'+@r['SERVER_NAME'],""].map{|h| lambdas.map{|p|
-          F[h + p].do{|fn| fn[self,@r].do{|r| return r}}}}}
-    
-    # default handler
-    response
-  end
-
-  def send?
-    !((m=@r['HTTP_IF_NONE_MATCH']) && m.strip.split(/\s*,\s*/).include?(@r['ETag']))
-  end
-  
-  def maybeSend m,b,lH=false
-    # agent need this version?
-    send? ?
-    # continue
-    b[].do{|b|
-      # response metadata
-      h = {'Content-Type'=> m,
-           'ETag'=> @r['ETag']}
-      h.update({'Cache-Control' => 'no-transform'}) if m.match /^(audio|image|video)/
-      h.update({'Link' => '<' + @r['uri'] + '?view=base>; rel=meta'}) if lH
-
-      b.class == E ? (Nginx ?                                                     # nginx enabled
-                      [200,h.update({'X-Accel-Redirect' => '/fs' + b.path}),[]] : # Nginx file-handler
-                      Apache ?                                              # Apache enabled
-                      [200,h.update({'X-Sendfile' => b.d}),[]] :   # Apache file-handler
-                      (r = Rack::File.new nil                      # Rack file-handler
-                       r.instance_variable_set '@path',b.d
-                       r.serving(@r).do{|s,m,b|[s,m.update(h),b]})
-                      ) :
-      [200, h, b]} : # normal (unaccelerated) response
-      [304,{},[]]    # client has response version
-  end
-
-end

data/infod/Th/HEAD.rb

@@ -1,5 +0,0 @@
-class E
-  def HEAD
-    self.GET.do{|s,h,b|[s,h,[]]}
-  end
-end

data/infod/Th/POST.rb

@@ -1,39 +0,0 @@
-watch __FILE__
-class E
-
-  def POST
-    r = Rack::Request.new @r
-    p = nil
-    # each triple
-    r.params.map{|k,v|
-
-      # path-format triple
-      sP,pP,oP = (CGI.unescape k).split S
-
-      # original triple
-      s,p,o = [sP,pP,oP].map &:unpath
-
-      p = p.uri[0..-2].E if p.uri[-1] == '/'
-
-      # object-delta URIs
-      vU = E.literal v
-      oU = oP.E
-
-      # change detected
-      unless oU.uri == vU.uri
-        # edit triple
-        s[p,o,v]
-      end
-
-      # snapshot current resource state
-      
-    }
-
-    # parameters for editor
-    @r.q.update({'view' => 'editPO',
-                 'graph' => 'editable',
-                 'p' => p.uri})
-    self.GET
-  end
-
-end

data/infod/Th/perf.rb

@@ -1,37 +0,0 @@
-#watch __FILE__
-require 'benchmark'
-
-class E
-
-  Slow ||= {}
-  Errors ||= {}
-  F['log']=->c,e,x=nil{ # response code, environment, extra stuff
-    uri = ['http://', e['SERVER_NAME'], e['REQUEST_URI']].join
-    if 500 == c
-      Errors[uri] ||= {}
-      Errors[uri][:time] = Time.now
-    end
-    if x && x.class==Float && x > 1
-      s = Slow[uri] ||= {}
-      s[:time] ||= 0
-      s[:time] += x
-      s[:last] = Time.now
-      if Slow.size > 10e3
-        Slow = {}
-      end
-    end
-    $stdout.puts [e.fn,c,uri,e['HTTP_USER_AGENT'],e['HTTP_REFERER'],x].join ' '}
-
-  F['/health/GET'] = ->e,r{
-    e.pathSegment.uri.match(/^(\/|\/health)$/) &&
-    (H [{_: :h1,
-          c: {_: :a, href: '/', style: "background-color:"+E.cs, c: '/'}},
-        {c: [{_: :b, c: r['SERVER_NAME']},' storage ',`df --output=pcent /|tail -n 1`]},
-        {_: :a, href: '/slow', c: 'slow queries'},
-        {_: :A, href: '/500', c: 'broken requests'},
-        H.css('/css/health')
-       ]).hR}
-
-  F['/slow/GET'] = ->e,r{H([Slow.sort_by{|u,r|r[:time]}.reverse.html,H.css('/css/500')]).hR}
-
-end

data/infod/Th/uid.rb

@@ -1,24 +0,0 @@
-#watch __FILE__
-
-module Th
-  FingerprintKeys = %w{
-   HTTP_ACCEPT
-   HTTP_ACCEPT_CHARSET
-   HTTP_ACCEPT_LANGUAGE
-   HTTP_ACCEPT_ENCODING
-   HTTP_USER_AGENT
-   HTTP_ORIGIN_ADDR
-   REMOTE_ADDR
-}
-
-  def uid
-    ('/u/'+FingerprintKeys.map{|i|self[i]}.h.dive).E
-  end
-end
-
-class E
-
-  fn '/whoami/GET',->e,r{
-    [302,{Location: '/@'+r.uid.uri},[]]}
-
-end

data/infod/Th/util.rb

@@ -1,89 +0,0 @@
-class String
-  # parse query-string
-  def qp
-    d={}
-    split(/&/).map{|e|
-      k,v=e.split(/=/,2).map{|x|
-         CGI.unescape x}
-      d[k]=v}
-    d
-  end
-  # HTML response of string body
-  def hR
-    [200,{'Content-Type'=>'text/html; charset=utf-8'},
-     [self]]
-  end
-end
-
-module Th
-
-  # unparsed query-string
-  def qs
-    (['GET','HEAD'].member? fn) ? self['QUERY_STRING'] : self['rack.input'].read
-  end
-
-  # memoize query
-  def q
-    @q ||= (qs||'').qp.do{|q|
-      (q['?']).do{|d|
-        E::F['?'][d].do{|g| # expand aliases
-          g.merge q
-        } || q } || q}
-  end
-
-  # Accept header
-  def accept_ k=''
-    d={}
-    self['HTTP_ACCEPT'+k].do{|k|
-      k.split(/,/).map{|e|
-        f,q=e.split(/;/)
-        i=q&&q.split(/=/)[1].to_f||1
-        d[i]||=[]
-        d[i].push f}}
-    d
-  end
-
-  def format
-    @format ||= conneg
-  end
-
-  def conneg
-    # format in querystring
-    return q['format'] if q['format'] && E::F[E::Render+q['format']]
-    # format in Accept header
-    accept.sort.reverse.map{|p|p[1].map{|mime|
-     return mime if E::F[E::Render+mime]}}
-    # default
-    'text/html'
-  end
-
-  def accept; @accept ||= accept_ end
-
-  def fn
-    self['REQUEST_METHOD']
-  end
-
-end
-
-class Hash
-
-  def qs
-   '?'+map{|k,v|k.to_s+'='+(v ? (CGI.escape [*v][0].to_s) : '')}.intersperse("&").join('')
-  end
-
-  def env r # attach environment variable
-    @r = r
-    self
-  end
-
-end
-
-class E
-
-  # request environment
-  def env r=nil
-    r ? (@r = r
-         self) : @r
-  end
-
-end