implement disk syncing via scheduler

class Metric(key: MetricKey) {

  var flush_interest : Long = 0

  var next_disk_sync : Long = 0

  val bucket = BucketFactory.new_bucket(key.mode)

  val swap = new SwapFile(key)

      // use, we need to flush some. this flushes as much data to disk as

      // possible and marks it as "ready for removal"

      if (rbuf_seek_pos < 1)

        flush_rbuf

        flush_rbuf()

      // exit if we couldn't free up any slots (this should never happen)

      if (rbuf_seek_pos < 1)

  // tries to persist as much data from the in memory ring buffer to disk

  // as possible but doesnt remove it from the buffer yet

  def flush_rbuf = this.synchronized {

  def flush_rbuf(force_sync: Boolean = false) = this.synchronized {

    val flush_range = rbuf.size - rbuf_seek_pos

    // copy the flushable items from the rbuf to the swapfile

    for (sample <- rbuf.tail(flush_range))

      swap.put(sample._1, sample._2)

    // mark the range as "read to be overwritten

    // mark the range as "ready to be overwritten"

    rbuf_seek_pos += flush_range

    // force syncing the data to disk if requested

    if (force_sync)

      swap.flush

  }

  // returns this metrics value at time0 if a value was recorded at that

  val TICK = 10

  // sync metric data to disk every N ms

  val SYNC_EVERY = 10000

  // this runs in the background and tries to invoke some flushes. it

  // is not neccessary for the liveliness of the application that each

  // iteration of the loop finishes in a fixed time interval. even if

  private def next : Unit = {

    val now = FnordMetric.now

    for (metric <- MetricFactory.metric_map) {

      // search for metrics with a pending flush interest and flush them

    // if the now > flush_interest

    for (metric <- MetricFactory.metric_map)

      // if now > flush_interest

      if (metric._2.flush_interest > 0 && metric._2.flush_interest <= now)

        metric._2.flush_bucket

      // search for metrics with a pending disk sync and flush them

      if (metric._2.next_disk_sync <= now) {

        metric._2.next_disk_sync = now + SYNC_EVERY

        metric._2.flush_rbuf(true)

      }

    }

    // to avoid burning CPU we sleep for a few ms

    Thread.sleep(TICK)

  }