Tip: Understand Golang methods and interface

Methods:

• methods are functions with a special receiver ( a normal or define type)
• so we define a type and create a method based on this type,  so the logic is the first type  ---> define method.
• As we have lots of common types, we use a type to group all sorts of methods
• So the type is the centrepiece to think thorough

Interface:

• Golang interface is still a type, but not normal concrete type like string, int ....etc. Instead, it is an abstract type built on top of those concrete types.
•  It has two elements:  a concrete type + value of the concrete type
• According to the interface definition, which concrete types implements this interface, Golang automatically matches which concrete types are bond to this interface.
• So in the same program, the same interface type can be different concrete types and values.
• Concrete types have methods. We can call these methods like my-type.my-methods(). It is the same for the interface. We can call these methods like my-interface.my-methods()
• A method can be called by both interface and its concrete type associated.
• Use type assertion to get the value from the interface, then use the value to invoke other methods which are not defined in the interface.
• One of the reasons why we have an interface is: since we also have lots of common methods, i.e. print string, play sports... all sorts of actions are considered as methods, so the genius part is we define an interface as a common signature of methods, so the centrepiece is not a TYPE, but methods,  it uses a common method (i.e. print string)  to group all sorts of types...

Kubebuilder Controller-runtime client_go_adapter.go Error

Symptom:

   We hit below error when we build an operator via kubebuilder 3.1 + controller runtime v0.8.3 + kuberentes 1.20.2

./../../pkg/mod/sigs.k8s.io/controller-runtime@v0.8.3/pkg/metrics/client_go_adapter.go:134:3: cannot use &latencyAdapter{...} (type *latencyAdapter) as type metrics.LatencyMetric in field value:

*latencyAdapter does not implement metrics.LatencyMetric (wrong type for Observe method)

have Observe(string, url.URL, time.Duration)

want Observe(context.Context, string, url.URL, time.Duration)

../../../pkg/mod/sigs.k8s.io/controller-runtime@v0.8.3/pkg/metrics/client_go_adapter.go:135:3: cannot use &resultAdapter{...} (type *resultAdapter) as type metrics.ResultMetric in field value:

*resultAdapter does not implement metrics.ResultMetric (wrong type for Increment method)

have Increment(string, string, string)

want Increment(context.Context, string, string, string)

Solution:

 It is related to controller runtime v0.8.3 has compatible issues with Kubernetes 0.21 modules. See link

To fix it, find go.mod, change the module from 0.21 to 0.20.2

Tip: Understand Golang Channel Directions

• Channel is used to communicate among Goroutines.
• Always image a channel as a pipe in the brain. A pipe of any concrete type of Golang, like string, int..etc. This pipe connects Goroutines
• There is sending side of this pipe on one Goroutines, and there is an ending side of this pipe on another Goroutines
• main() is also a Goroutine. 
• We need to identify which Goroutine is sending side, which is the ending side.

• Sending side is like.

sends chan<- string 

the chan<- string  means there is a string on the sending side of pipe   
We use it like    sends <- "my sending string" 
Ending side is like.
ends <-chan string 
the <-chan string  means there is a string on the ending side of pipe   
We use it like    ending_message <-ends or <-ends
for range <channel name>: it's used on the ending side the pipe to fetch values
time.Ticker is a good example of ending side of pipe
type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	// contains filtered or unexported fields
}

Below is another advance example of sending / ending side
os.Signal is the sending side of channel sigs
another process or thread from OS
main() goroutines is the ending side of channel sigs
// Registering signals - INT and TERM
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
// Process blocked here and waiting for signal(term/int)
<-sigs