Error handling about notify

[rjeczalik]

3. notify.Error

const (
  Create = Event(...)
  Delete = Event(...)
  ...
  Error   = Event(...)
)

notify.Watch("/home/pknap/rottenbodies", ch, notify.Delete, notify.Error)
for ei := range ch {
  switch ei.Event() {
  case notify.Delete:
    println("the bodies are gone")
  case notify.Error:
    println("they're alive:", ei.Sys().(error))
  }
}

• notify.Watch("/path", ch) listens notify.Error by default as well
• not listening to a notify.Error means it's ignored

It's guaranteed that:

• a notify.Error is followed by a chan close
• when Event() == notify.Error, it's safe to err := ei.Sys().(error)

Plus is minimalistic API. Cons is Error is not an event... oh wait, it is. XD

Other than that I like 1).

[ppknap]

How about an implicit notify.Error event:

notify.Watch("/home/pknap/rottenbodies", ch, notify.Delete)
for ei := range ch {
  switch ei.Event() {
  case notify.Delete:
    println("the bodies are gone")
  case notify.Error:
    println("they're alive:", ei.Sys().(error))
  }
}

I`ve updated option no.1 and I like it too.

[rjeczalik]

It should be possible to say: Watch this and I don't care about the error, just close the chan. Because receiving notify.Error and not reading Sys().(error) gives the same information as !ok received by the chan close.

[ppknap]

In the other hand, how long should we keep the ch<-->error pair. Since the user may want to always call notify.Error(ch) on deleted channel?

[rjeczalik]

Yup, the problem with 1) is the lifetime of underlying map[chan<- notify]error. No idea how to deal with that. That's why I would pick 3), as eventually deleting notify.Error and introducing something else is relatively simple.

[ppknap]

Ok in this case we send ch <- zjebalosie{err: err} and then close the channel ?

[rjeczalik]

If zjebalosie implements EventInfo it's cool.

[ppknap]

👍

[rjeczalik]

• notify.Error is implicit, meaning the ch after following Watch may receive an error

notify.Watch("/path", ch, notify.Create)

• in order to ignore receiving an error user may want to use ^notify.Error:

notify.Watch("/path", ch, notify.Create, ^notify.Error)

(obviously this wouldn't work with short event declaration, like: notify.Create | ^notify.Error, only long one is supported)

[ppknap]

eg:

notify.Create == Event(0x1) // 0001b
notify.Delete == Event(0x2) // 0010b
notify.Move  == Event(0x4) // 0100b
notify.Error == Event(0x8)  // 1000b
...
notify.Create | notify.Delete | notify.Move == ^notify.Error 
.... => // the only fix?:
notify.Error == notify.Create | notify.Delete | notify.Move
...

Is it possible to implement this logic correctly?

[edit]

Hmm hopefully it is, but notify.Error needs to reserve 2 bits 👍

[ppknap]

If it has two bits reserved also your notify.Create | ^notify.Error will be possible:

notify.Create == Event(0x1) // 00001b
notify.Delete == Event(0x2) // 00010b
notify.Move  == Event(0x4) // 00100b
notify.Error == Event(0x8)  // 01000b , bit 4th ant 5th are reserved 

bit 4th == 0, bit 5th == 0 => implicit error
bit 4th == 1, bit 5th == 0 => explicit notify.Error was passed as an argument
bit 4th == 0, bit 5th == 1 => explicit ^notify.Error was passed
bit 4th == 1, bit 5th == 1 => somebody tries to cheat us

[edit]
bit 4th == 1, bit 5th == 1 => notify.Error | ^notify.Error => no-op <=> bit 4th == 0, bit 5th == 0

[ppknap]

• taken from os/signal Notify causes package signal to relay incoming signals to c. If no signals are listed, all incoming signals will be relayed to c. Otherwise, just the listed signals will. thus:

notify.Watch("dupa", ch) == notify.Watch("dupa", ch, notify.Create, notify.Delete, notify.Move, notify.Error, notify.Write) // but not system-dependent events.

;>

[ppknap]

and if we have the notify.Error event I would rather not close the channel on error.

• no need to write creepy logic which is responsible for storing errors.
• I can recover the reading loop after error occures (inotify/ReadDirectoryChanges)
• os/signal has no such logic
• the code will panic if someone receives nil EventInfo from closed channel and invokes ei.Event()