go-ipfs: github.com/ipfs/go-ipfs/thirdparty/notifier Index | Files

package notifier

import "github.com/ipfs/go-ipfs/thirdparty/notifier"

Package notifier provides a simple notification dispatcher meant to be embedded in larger structres who wish to allow clients to sign up for event notifications.


Package Files


type Notifiee Uses

type Notifiee interface{}

Notifiee is a generic interface. Clients implement their own Notifiee interfaces to ensure type-safety of notifications:

type RocketNotifiee interface{
  Countdown(r Rocket, countdown time.Duration)
  Detached(Rocket, Capsule)

type Notifier Uses

type Notifier struct {
    // contains filtered or unexported fields

Notifier is a notification dispatcher. It's meant to be composed, and its zero-value is ready to be used.

type Rocket struct {
  notifier notifier.Notifier

func RateLimited Uses

func RateLimited(limit int) *Notifier

RateLimited returns a rate limited Notifier. only limit goroutines will be spawned. If limit is zero, no rate limiting happens. This is the same as `Notifier{}`.

func (*Notifier) Notify Uses

func (n *Notifier) Notify(e Notifiee)

Notify signs up Notifiee e for notifications. This function is meant to be called behind your own type-safe function(s):

// generic function for pattern-following
func (r *Rocket) Notify(n Notifiee) {

// or as part of other functions
func (r *Rocket) Onboard(a Astronaut) {
  r.astronauts = append(r.austronauts, a)

func (*Notifier) NotifyAll Uses

func (n *Notifier) NotifyAll(notify func(Notifiee))

NotifyAll messages the notifier's notifiees with a given notification. This is done by calling the given function with each notifiee. It is meant to be called with your own type-safe notification functions:

func (r *Rocket) Launch() {
  r.notifyAll(func(n Notifiee) {

// make it private so only you can use it. This function is necessary
// to make sure you only up-cast in one place. You control who you added
// to be a notifiee. If Go adds generics, maybe we can get rid of this
// method but for now it is like wrapping a type-less container with
// a type safe interface.
func (r *Rocket) notifyAll(notify func(Notifiee)) {
  r.notifier.NotifyAll(func(n notifier.Notifiee) {

Note well: each notification is launched in its own goroutine, so they can be processed concurrently, and so that whatever the notification does it _never_ blocks out the client. This is so that consumers _cannot_ add hooks into your object that block you accidentally.

func (*Notifier) StopNotify Uses

func (n *Notifier) StopNotify(e Notifiee)

StopNotify stops notifying Notifiee e. This function is meant to be called behind your own type-safe function(s):

// generic function for pattern-following
func (r *Rocket) StopNotify(n Notifiee) {

// or as part of other functions
func (r *Rocket) Detach(c Capsule) {
  r.capsule = nil

Package notifier imports 3 packages (graph) and is imported by 13 packages. Updated 2019-03-14. Refresh now. Tools for package owners.