Learning Go Interface Encapsulation from K8s

type Kubelet struct{}

func (kl *Kubelet) HandlePodAdditions(pods []*Pod) {
  for _, pod := range pods {
    fmt.Printf("create pods : %s\n", pod.Status)
  }
}

func (kl *Kubelet) Run(updates <-chan Pod) {
  fmt.Println(" run kubelet")
  go kl.syncLoop(updates, kl)
}

func (kl *Kubelet) syncLoop(updates <-chan Pod, handler SyncHandler) {
  for {
    select {
    case pod := <-updates:
      handler.HandlePodAdditions([]*Pod{&pod})
    }
  }
}

type SyncHandler interface {
  HandlePodAdditions(pods []*Pod)
}

type OrderAPI interface {
  GetOrderId() string
}

type realOrderImpl struct{}

func (r *realOrderImpl) GetOrderId() string {
  return ""
}

type mockOrderImpl struct{}

func (m *mockOrderImpl) GetOrderId() string {
  return "mock"
}

func TestGetOrderId(t *testing.T) {
  orderAPI := &mockOrderImpl{} // If we need to get the order id, but it's not the focus of the test, just initialize with the mock struct
  fmt.Println(orderAPI.GetOrderId())
}

patches := gomonkey.ApplyFunc(GetOrder, func(orderId string) Order {
    return Order{
      OrderId:    orderId,
      OrderState: delivering,
    }
  })
  return func() {
    patches.Reset()
  }

// ServiceHandler is an abstract interface used for receiving notifications about service object changes.
type ServiceHandler interface {
    // OnServiceAdd is called when a new service object is observed to be created.
    OnServiceAdd(service *v1.Service)
    // OnServiceUpdate is called when an existing service object is observed to be modified.
    OnServiceUpdate(oldService, service *v1.Service)
    // OnServiceDelete is called when an existing service object is observed to be deleted.
    OnServiceDelete(service *v1.Service)
    // OnServiceSynced is called once all initial event handlers have been called and the state is fully propagated to the local cache.
    OnServiceSynced()
}

// EndpointSliceHandler is an abstract interface used for receiving notifications about endpoint slice object changes.
type EndpointSliceHandler interface {
    // OnEndpointSliceAdd is called when a new endpoint slice object is observed to be created.
    OnEndpointSliceAdd(endpointSlice *discoveryv1.EndpointSlice)
    // OnEndpointSliceUpdate is called when an existing endpoint slice object is observed to be modified.
    OnEndpointSliceUpdate(oldEndpointSlice, newEndpointSlice *discoveryv1.EndpointSlice)
    // OnEndpointSliceDelete is called when an existing endpoint slice object is observed to be deleted.
    OnEndpointSliceDelete(endpointSlice *discoveryv1.EndpointSlice)
    // OnEndpointSlicesSynced is called once all initial event handlers have been called and the state is fully propagated to the local cache.
    OnEndpointSlicesSynced()
}

type Provider interface {
  config.EndpointSliceHandler
  config.ServiceHandler
}

package runtime

var (
  ReallyCrash = true
)

// Default global Panic handler
var PanicHandlers = []func(interface{}){logPanic}

// Allows passing in extra custom panic handlers from outside
func HandleCrash(additionalHandlers ...func(interface{})) {
  if r := recover(); r != nil {
    for _, fn := range PanicHandlers {
      fn(r)
    }
    for _, fn := range additionalHandlers {
      fn(r)
    }
    if ReallyCrash {
      panic(r)
    }
  }
}

package runtime

func Go(fn func()) {
  go func() {
    defer HandleCrash()
    fn()
  }()
}

import "sync"

type Group struct {
  wg sync.WaitGroup
}

func (g *Group) Wait() {
  g.wg.Wait()
}

func (g *Group) Start(f func()) {
  g.wg.Add(1)
  go func() {
    defer g.wg.Done()
    f()
  }()
}

type BoundedFrequencyRunner struct {
  sync.Mutex

  // Actively triggered
  run chan struct{}

  // Timer limit
  timer *time.Timer

  // The actual logic to execute
  fn func()
}

func NewBoundedFrequencyRunner(fn func()) *BoundedFrequencyRunner {
  return &BoundedFrequencyRunner{
    run:   make(chan struct{}, 1),
    fn:    fn,
    timer: time.NewTimer(0),
  }
}

// Run triggers execution; only one signal can be written here, additional signals are discarded without blocking. You can increase the queue size as needed.
func (b *BoundedFrequencyRunner) Run() {
  select {
  case b.run <- struct{}{}:
    fmt.Println("Signal written successfully")
  default:
    fmt.Println("Signal already triggered once, discarding")
  }
}

func (b *BoundedFrequencyRunner) Loop() {
  b.timer.Reset(time.Second * 1)
  for {
    select {
    case <-b.run:
      fmt.Println("Run signal triggered")
      b.tryRun()
    case <-b.timer.C:
      fmt.Println("Timer triggered execution")
      b.tryRun()
    }
  }
}

func (b *BoundedFrequencyRunner) tryRun() {
  b.Lock()
  defer b.Unlock()
  // You can add logic here such as rate limiting
  b.timer.Reset(time.Second * 1)
  b.fn()
}