glutenfree/ArgumentGenerator.coffee

A profiler/loganalyzer for nginx/Cetrea Aw.

Q = require("q")
http = require("http")
url = require("url")
fs = require("fs")
xml2js = require("xml2js")
_ = require("underscore")
winston = require("winston")
util = require("util")

class ArgumentGenerator

  # @server is server
  # @cache is a type.prop, values cache, e.g. BedPlace.Oid: [BedPlace.1, BedPlace.2]
  # @premapped is a map of readymade conversions
  # @mappers is a list of mappers, if none are provide auto-discovery is set in motion
  constructor: (@server, @lookupConfiguration, @cache = {}, @premapped = {}, @mappers, @targeting) ->
    @version = "0.2.1"

    # find available mappers
    @parser = new xml2js.Parser({ ignoreAttrs: true })

    # if empty mappers list is supplied
    winston.info "loading mappers"
    if not @mappers?
      @mappers = {}
      for file in fs.readdirSync("ArgumentMappers") when file.match(/.*\.js/)
        do (file) =>
          m = require("./ArgumentMappers/#{file}").mapper
          @mappers[m.identifier] = m
          winston.info "installed mapper for '#{m.identifier}'"
            

    winston.info "loading targeting"
    if not @targeting?
      @targeting = {}
      for file in fs.readdirSync("ProfilerTargeting") when file.match(/.*\.js/)
        do (file) =>
          t = require("./ProfilerTargeting/#{file}").targeting
          @targeting[t.name] = t
          winston.info "installed targeting '#{t.name}'"
    

  # map from given arguments to ones matching the given server
  map: (method, action, component, componentVersion, endpoint, fun, args) ->

    cached = @premapped["#{method}.#{component}.#{componentVersion}.#{endpoint}.#{fun}.#{args}"]
    if cached? then return Q.fcall(->cached)

    # retrieve mapper for endpoint
    mapperId = [component, componentVersion, endpoint].filter((c) -> c?).join("/")
    mapper = @mappers[mapperId]

    # if no mapper for endpoint is found simple return url
    if not mapper? 
      winston.warn "No mapper for #{mapperId} found. Original args returned."
      return Q.fcall(->args)

    # get schema for function
    schema = mapper.schema(method, endpoint, action, fun, decodeURI(args))

    if not schema?
      winston.warn "No schema returned for '#{method} #{action} (#{component}/#{componentVersion}) #{endpoint}/#{fun}/#{args}'. Original args returned."
      return Q.fcall(->args)

    #  walk through schema and find arguments from 1) cache, 2) server
    promises = _.map(
      _.flatten(schema),
      (arg) =>
        switch arg.origin
          when "mapi"

            cached = @cache["#{arg.type}.#{arg.hql}.#{arg.depth}"] 
            value = if cached? then cached
            if not value?
              deferred = Q.defer()
              #deferred.promise.then (values) -> arg.newvalue = values
              #@cache["#{arg.type}.#{arg.hql}.#{arg.depth}"] = deferred.promise
              options =   
                host: @server
                port: 8080
                path: "/#{arg.type}?depth=#{arg.depth}&limit=200&hql=active=true" + (if arg.hql? then " AND "+arg.hql else "")
                auth: "spider:spider"
                headers: {
                  "User-Agent": "GLUTENFREE (AG-#{@version})"
                }
  
              # go through server
              http.get(options, (res) =>
                chunks = ""
                res.on("data", (chunk) -> 
                  chunks += chunk
                )
                res.on("end", () =>
                  console.log "get", options
                  # xml2js the shit out of this chunked mofo
                  @parser.parseString(
                    chunks, 
                    (err, data) =>
  
                      values = _.flatten(_.values(data.Collection))
  
                      # console.log "values", values
  
                      # save result in @cache
                      @cache["#{arg.type}.#{arg.hql}.#{arg.depth}"] = values
  
                      #  save result in arg.newval
                      arg.newvalue = values 
  
                      # done, resolve
                      deferred.resolve(arg)
                  )                  
                )
              ).on("error", (e) => 
                winston.error e
                deferred.reject("error when getting #{arg.type}.#{arg.hql}.#{arg.depth}")
              )
              # return
              return deferred.promise
            else # argument was cached
              arg.newvalue = value
              arg
          when "configuration", "conf"
            # load and match from configuration
            if @lookupConfiguration?
              newvalue = []
              for currentvalue in arg.currentvalue
                do (currentvalue) =>
                  v = @lookupConfiguration[arg.type][currentvalue]
                  if not v? # if no explicit mapping then pick random value 
                    v = _.first(_.shuffle(_.values(@lookupConfiguration[arg.type])))
                  newvalue.push(v)
              arg.newvalue = newvalue
            else
              arg.newvalue = arg.currentvalue
            # return arg
            arg
          when "fixed" # origin is not mapi
            arg.newvalue = arg.currentvalue
            arg
      )

    # wait for all promises to be fullfulled then let mapper generate url
    Q.allSettled(promises).then(
      =>
        # run through all resolved and pluck property
        for schematic in _.flatten(schema)
          do (schematic) ->
            if schematic.origin is "mapi"
              candidates = if schematic.filter? then _.filter(schematic.newvalue, (t) -> schematic.filter(t, schema)) else schematic.newvalue
              schematic.newvalue = _.first(_.shuffle(_.flatten(_.pluck(candidates,schematic.property))),schematic.currentvalue.length)

        url = mapper.applySchema(method, action, endpoint, fun, schema)
        @premapped["#{method}.#{component}.#{componentVersion}.#{endpoint}.#{fun}.#{args}"] = url
        console.log "url (pre-encode)", url
        encodeURI(url)
    )

exports.AG = ArgumentGenerator

# if run as main module
if require.main is module 

  argv = require('optimist')
    .usage("Usage: $0 -i [inputfile] -o [outputfile] -s [server] -t [targeting] -c [configuration]")
    .alias("s", "server")
    .demand(["i","o","s"])
    .alias("c", "configiration")
    .argv

  statsFile = if argv.i[0] is "/" then argv.i else "./#{argv.i}"
  stats = require(statsFile)


  lookupConf = 
    if argv.c? 
     if argv.c[0] is "/" then require(argv.c) else require("./#{argv.c}")
    else {}

  winston.info "creating ag"

  ag = new ArgumentGenerator(argv.s, lookupConf)

  winston.info "looping stats"

  # deep loop
  promises = []

  for id, info of stats.uniques
    do (id, info) ->
      info.newArgs = []
      promises.push(
        ag.map(info.method, info.action, info.component, info.componentVersion, info.endpoint, info.fun, info.args)
        .then(((newarg) -> info.newArgs.push newarg))
      )


  Q.all(promises)
  .then(
    -> 
      # targeting
      targeting = ag.targeting[argv.t]
      if not targeting?
        fs.writeFile(
          argv.o, 
          JSON.stringify(stats), 
          (err) -> if not err? then winston.info "raw output written to #{argv.o}" else winston.warn "error writing to #{argv.o}"
        )
      else
        targets = targeting.generate(stats)
        fs.writeFile(
          argv.o, 
          JSON.stringify(targets), 
          (err) -> if not err? then winston.info "targeting (#{targeting.name}) output written to #{argv.o}" else winston.warn "error writing to #{argv.o}"
        )
  )