11package net .lag .kestrel
22
3- import java .nio .ByteBuffer
4- import java .util .concurrent .ConcurrentLinkedQueue
53import com .twitter .conversions .time ._
4+ import com .twitter .ostrich .stats .Stats
65import com .twitter .util ._
76import java .io .{IOException , FileOutputStream , File }
7+ import java .nio .ByteBuffer
8+ import java .util .concurrent .{ConcurrentLinkedQueue , ScheduledExecutorService , ScheduledFuture , TimeUnit }
9+
10+ abstract class PeriodicSyncTask (val scheduler : ScheduledExecutorService , initialDelay : Duration , period : Duration )
11+ extends Runnable {
12+ @ volatile private [this ] var scheduledFsync : Option [ScheduledFuture [_]] = None
13+
14+ def start () {
15+ synchronized {
16+ if (scheduledFsync.isEmpty && period > 0 .seconds) {
17+ val handle = scheduler.scheduleWithFixedDelay(this , initialDelay.inMilliseconds, period.inMilliseconds,
18+ TimeUnit .MILLISECONDS )
19+ scheduledFsync = Some (handle)
20+ }
21+ }
22+ }
23+
24+ def stop () {
25+ synchronized { _stop() }
26+ }
27+
28+ def stopIf (f : => Boolean ) {
29+ synchronized {
30+ if (f) _stop()
31+ }
32+ }
33+
34+ private [this ] def _stop () {
35+ scheduledFsync.foreach { _.cancel(false ) }
36+ scheduledFsync = None
37+ }
38+ }
839
940/**
1041 * Open a file for writing, and fsync it on a schedule. The period may be 0 to force an fsync
1142 * after every write, or `Duration.MaxValue` to never fsync.
1243 */
13- class PeriodicSyncFile (file : File , timer : Timer , period : Duration ) {
44+ class PeriodicSyncFile (file : File , scheduler : ScheduledExecutorService , period : Duration ) {
1445 // pre-completed future for writers who are behaving synchronously.
1546 private final val DONE = Future (())
1647
17- val writer = new FileOutputStream (file, true ).getChannel
18- val promises = new ConcurrentLinkedQueue [Promise [Unit ]]()
19-
20- @ volatile var closed = false
48+ case class TimestampedPromise (val promise : Promise [Unit ], val time : Time )
2149
22- if (period > 0 .seconds && period < Duration .MaxValue ) {
23- timer.schedule(Time .now, period) {
50+ val writer = new FileOutputStream (file, true ).getChannel
51+ val promises = new ConcurrentLinkedQueue [TimestampedPromise ]()
52+ val periodicSyncTask = new PeriodicSyncTask (scheduler, period, period) {
53+ override def run () {
2454 if (! closed && ! promises.isEmpty) fsync()
2555 }
2656 }
2757
58+ @ volatile var closed = false
59+
2860 private def fsync () {
2961 synchronized {
3062 // race: we could underestimate the number of completed writes. that's okay.
3163 val completed = promises.size
64+ val fsyncStart = Time .now
3265 try {
3366 writer.force(false )
3467 } catch {
3568 case e : IOException =>
3669 for (i <- 0 until completed) {
37- promises.poll().setException(e)
70+ promises.poll().promise. setException(e)
3871 }
3972 return ;
4073 }
4174
4275 for (i <- 0 until completed) {
43- promises.poll().setValue(())
76+ val timestampedPromise = promises.poll()
77+ timestampedPromise.promise.setValue(())
78+ val delaySinceWrite = fsyncStart - timestampedPromise.time
79+ val durationBehind = if (delaySinceWrite > period) delaySinceWrite - period else 0 .seconds
80+ Stats .addMetric(" fsync_delay_usec"
4481 }
82+
83+ periodicSyncTask.stopIf { promises.isEmpty }
4584 }
4685 }
4786
@@ -62,7 +101,8 @@ class PeriodicSyncFile(file: File, timer: Timer, period: Duration) {
62101 DONE
63102 } else {
64103 val promise = new Promise [Unit ]()
65- promises.add(promise)
104+ promises.add(TimestampedPromise (promise, Time .now))
105+ periodicSyncTask.start()
66106 promise
67107 }
68108 }
@@ -73,6 +113,7 @@ class PeriodicSyncFile(file: File, timer: Timer, period: Duration) {
73113 */
74114 def close () {
75115 closed = true
116+ periodicSyncTask.stop()
76117 fsync()
77118 writer.close()
78119 }
0 commit comments