hive: Reimplement on top of dig

[joamaki]

This reimplements hive directly on top of the uber/dig library. This simplifies
dealing with lifecycles and logging, and most importantly allows implementing
the configuration flag registration in a straightforward way with an invoke.

The usage is also simplified as now there's only one library to learn. The
API is very similar to uber/fx, but has support for configs. At "hive" creation
time the config command-line flags are registered, but object graph instantiation
is deferred to start time. This allows supporting command-line applications with
many commands (with each their own object graph) and only instantiating when
we know which command to run.

Usage looks like this now:

type ExampleConfig struct { ... }
func (def ExampleConfig) Flags(flags *pflag.FlagSet) {
  flags.String("foo", def.Foo, "usage of foo")
  ...
}
var defaultConfig = ExampleConfig{...}

var Example = cell.Module(
  "example",
  
  cell.Config(defaultConfig), // Provides `ExampleConfig` and registers the flags

  cell.Provide(newExample, newSomethingElse),
  cell.Invoke(func(ex *Example, se *SomethingElse) error { ...}),

  cell.Decorate(
    func(thing *Thing) *Thing { /* return some augmented Thing */ },
    // Constructor gets augmented Thing:
    cell.Provide(newUserOfThing),
  )  
)

• fx.Option is no longer used, so there's now just one library to learn and should be less confusing to users.
• Using dig directly allows more fine-grained control of what gets instantiated when. This allows for way simpler implementation for configs.
• Provide, Invoke and Module has the same API as Fx does. Decorate instead wraps a set of cells to "decorate" rather than to decorate in the scope of a Module.
• Lifecycle is now implemented in pkg/hive, which allows more complicated uses like nested lifecycles that we need for the operator.
• hive.New no longer takes flags and viper instance. Rather there's now RegisterFlags() and Viper().

[joamaki]

/test

[joamaki]

Revamped PrintObjects:

$ ./cilium-agent objects                                                                                                     
Cells:                                                                                                                                                                                    
                                                                                                                                                                                          
  gops:                                                                                                                                                                                   
    ⚙️  gops.GopsConfig:                                                                                                                                                                   
      gops-port[uint16]=9890                                                                                                                                                              
                                                                                                                                                                                          
    🛠️  pkg/gops.registerGopsHooks (cell.go:38) (func(hive.Lifecycle, logrus.FieldLogger, gops.GopsConfig))                                                                                
                                                                                                                                                                                          
                                                                                                                                                                                          
  k8s-client:                                                                                                                                                                             
    ⚙️  client.Config:                                                                                                                                                                     
      enable-k8s-api-discovery[bool]=false                                                                                                                                                
      k8s-api-server[string]=                                                                                                                                                             
      k8s-client-burst[int]=0                                                                                                                                                             
      k8s-client-qps[float32]=0                                                                                                                                                           
      k8s-heartbeat-timeout[duration]=30s                                                                                                                                                 
      k8s-kubeconfig-path[string]=                                                                                                                                                        
                                                                                                                                                                                          
    🚧️ pkg/k8s/client.newClientset (cell.go:106): func(hive.Lifecycle, logrus.FieldLogger, client.Config) (client.Clientset, error)                                                       
                                                                                                                                                                                          
                                                                                                                                                                                          
                                                                                                                                                                                          
  ⚙️  cmd.DaemonCellConfig:                                                                                                                                                                
    skip-daemon[bool]=false                                                                                                                                                               
                                                                                                                                                                                          
  🛠️  daemon/cmd.registerDaemonHooks (daemon_main.go:1570) (func(cmd.daemonParams) error)                                                                                                  
                                                                                                                                                                                          
  🚧️ pkg/node.newLocalNodeStore (local_node_store.go:71): func(node.LocalNodeStoreParams) (node.LocalNodeStore, error)                                                                    
                                                                                                                                                                                          
                                                                                                                                                                                          
Start hooks:                                                                                                                                                                              
                                                                                                                                                                                          
  • pkg/gops.registerGopsHooks.func1 (cell.go:43)                                                                                                                                         
  • pkg/node.newLocalNodeStore.func1 (local_node_store.go:80)                                                                                                                             
  • daemon/cmd.registerDaemonHooks.func1 (daemon_main.go:1591)                                                                                                                            
                                                                                                                                                                                          
Stop hooks:                                                                                                                                                                               
                                                                                                                                                                                          
  • daemon/cmd.registerDaemonHooks.func2 (daemon_main.go:1607)                               
  • pkg/node.newLocalNodeStore.func2 (local_node_store.go:95)                                
  • pkg/gops.registerGopsHooks.func2 (cell.go:50)                                            

Could still improve the config flag printing, but I think this is enough for now.

[glibsm]

This is awesome!! Especially the printing of the objects that you've set up by implementing a different vision on top of dig (that's the reason the two were kept separate)

[glibsm]

Just wanted to double check that dig.Export here is explicit and to stay forever. On first glance this seems like it eliminates scoping from hive entirely, is that correct?

[joamaki]

Yep all that scope right now does is give a name to a group of cells. Afaik exactly same as fx? I was thinking of adding something like ProvidePrivate or possible change to Provide(ctor, opts…) form, so you’d do Provide(newPrivateThing, cell.Private).

I was a bit puzzled that fx doesn’t have this. Wasn’t needed?

[joamaki]

Added ProvidePrivate. It's nice that Provide takes ctor... so didn't go with optional.

[glibsm]

Are decorators scoped out purely for logging and bookkeeping purposes?

[joamaki]

To me it seemed to make more sense to wrap things with a decorator rather than having the decorator be associated with a module and it’s scope. That’s why I ended up with this. Name of the scope could be better.

Hmm need to check what this ends up looking like in dot graph. Might not look quite right.

EDIT: dot-graph looks fine. Fixed up cilium-agent objects a bit for Decorate:

  🔀 daemon/cmd.init.0.func1 (root.go:92): func(cmd.DaemonCellConfig) cmd.DaemonCellConfig:
    🛠️ daemon/cmd.init.0.func2 (root.go:94): func(cmd.DaemonCellConfig)

You read the above as: there's a decorator (emoji conveying "swapping") that takes DaemonCellConfig and returns an augmented DaemonCellConfig, and it's wrapping an Invoke function.

[joamaki]

/test

[dylandreimerink]

LGTM!