$ mkdir -p $GOPATH/src/github.com/kaitoy/zundoko-operator
$ cd $GOPATH/src/github.com/kaitoy/zundoko-operator
$ kubebuilder init --owner kaitoy

 version: "1"
-domain: k8s.io
+domain: kaitoy.github.com
 repo: github.com/kaitoy/zundoko-operator

$ kubebuilder create api --group zundokokiyoshi --version v1beta1 --kind Hikawa
$ kubebuilder create api --group zundokokiyoshi --version v1beta1 --kind Zundoko
$ kubebuilder create api --group zundokokiyoshi --version v1beta1 --kind Kiyoshi

package v1beta1

import (
	"time"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// HikawaSpec defines the desired state of Hikawa
type HikawaSpec struct {
	IntervalMillis time.Duration `json:"intervalMillis"`
	NumZundokos    int           `json:"numZundokos,omitempty"`
	SayKiyoshi     bool          `json:"sayKiyoshi,omitempty"`
}

// HikawaStatus defines the observed state of Hikawa
type HikawaStatus struct {
	NumZundokosSaid int  `json:"numZundokosSaid"`
	Kiyoshied       bool `json:"kiyoshied"`
}

// +genclient
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// Hikawa is the Schema for the hikawas API
// +k8s:openapi-gen=true
type Hikawa struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   HikawaSpec   `json:"spec,omitempty"`
	Status HikawaStatus `json:"status,omitempty"`
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// HikawaList contains a list of Hikawa
type HikawaList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Hikawa `json:"items"`
}

func init() {
	SchemeBuilder.Register(&Hikawa{}, &HikawaList{})
}

func add(mgr manager.Manager, r reconcile.Reconciler) error {
	// Create a new controller
	c, err := controller.New("hikawa-controller", mgr, controller.Options{Reconciler: r})
	if err != nil {
		return err
	}

	// Watch for changes to Hikawa
	err = c.Watch(&source.Kind{Type: &zundokokiyoshiv1beta1.Hikawa{}}, &handler.EnqueueRequestForObject{})
	if err != nil {
		return err
	}

	err = c.Watch(&source.Kind{Type: &zundokokiyoshiv1beta1.Zundoko{}}, &handler.EnqueueRequestForOwner{
		IsController: true,
		OwnerType:    &zundokokiyoshiv1beta1.Hikawa{},
	})
	if err != nil {
		return err
	}

	return nil
}

// +kubebuilder:rbac:groups=zundokokiyoshi.kaitoy.github.com,resources=hikawas,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=zundokokiyoshi.kaitoy.github.com,resources=hikawas/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=zundokokiyoshi.kaitoy.github.com,resources=zundokos,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=zundokokiyoshi.kaitoy.github.com,resources=zundokos/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=zundokokiyoshi.kaitoy.github.com,resources=kiyoshis,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=zundokokiyoshi.kaitoy.github.com,resources=kiyoshis/status,verbs=get;update;patch
func (r *ReconcileHikawa) Reconcile(request reconcile.Request) (reconcile.Result, error) {
	instanceName := request.NamespacedName.String()
	log.Info("Reconciling a Hikawa: " + instanceName)

	// Fetch the Hikawa instance
	instance := &zundokokiyoshiv1beta1.Hikawa{}
	err := r.Get(context.TODO(), request.NamespacedName, instance)
	if err != nil {
		if errors.IsNotFound(err) {
			// Object not found, return.  Created objects are automatically garbage collected.
			// For additional cleanup logic use finalizers.
			return reconcile.Result{}, nil
		}
		// Error reading the object - requeue the request.
		return reconcile.Result{}, err
	}

	if instance.Status.Kiyoshied {
		log.Info(instanceName + " has kiyoshied.")
		return reconcile.Result{}, nil
	}

	zundokoList := &zundokokiyoshiv1beta1.ZundokoList{}
	if err := r.List(context.TODO(), &client.ListOptions{Namespace: instance.Namespace}, zundokoList); err != nil {
		log.Error(err, "Failed to list zundokos for: ", instanceName)
		return reconcile.Result{}, err
	}

	var dependents []zundokokiyoshiv1beta1.Zundoko
	for _, zundoko := range zundokoList.Items {
		for _, owner := range zundoko.GetOwnerReferences() {
			if owner.Name == instance.Name {
				dependents = append(dependents, zundoko)
			}
		}
	}
	numZundokosSaid := len(dependents)

	if instance.Spec.NumZundokos > numZundokosSaid {
		log.Info(instanceName + " wants " + strconv.Itoa(instance.Spec.NumZundokos-numZundokosSaid) + " more zundoko(s).")
		time.Sleep(instance.Spec.IntervalMillis * time.Millisecond)
		word := getZundoko()
		if err := createZundoko(instance, r, fmt.Sprintf("-zundoko-%03d", numZundokosSaid+1), word); err != nil {
			return reconcile.Result{}, err
		}
	} else if instance.Status.NumZundokosSaid != numZundokosSaid {
		log.Info(instanceName + " has said " + strconv.Itoa(numZundokosSaid) + " zundoko(s). Updating the status.")
		instance.Status.NumZundokosSaid = numZundokosSaid
		if err := r.Update(context.Background(), instance); err != nil {
			log.Error(err, "Failed to update "+instanceName)
			return reconcile.Result{}, err
		}
	} else if instance.Spec.SayKiyoshi {
		log.Info(instanceName + " is going to say " + wordKiyoshi)
		time.Sleep(instance.Spec.IntervalMillis * time.Millisecond)
		if err := createKiyoshi(instance, r); err != nil {
			return reconcile.Result{}, err
		}

		instance.Status.Kiyoshied = true
		if err := r.Update(context.Background(), instance); err != nil {
			log.Error(err, "Failed to update "+instanceName)
			return reconcile.Result{}, err
		}
	} else if isReadyToKiyoshi(dependents) {
		log.Info(instanceName + " is ready to say " + wordKiyoshi)
		instance.Spec.SayKiyoshi = true
		if err := r.Update(context.Background(), instance); err != nil {
			log.Error(err, "Failed to update "+instanceName)
			return reconcile.Result{}, err
		}
	} else {
		log.Info(instanceName + " keeps going on ZUNDOKO.")
		instance.Spec.NumZundokos++
		if err := r.Update(context.Background(), instance); err != nil {
			log.Error(err, "Failed to update "+instanceName)
			return reconcile.Result{}, err
		}
	}

	return reconcile.Result{}, nil
}

func createZundoko(instance *zundokokiyoshiv1beta1.Hikawa, r *ReconcileHikawa, nameSuffix, word string) error {
	zundoko := &zundokokiyoshiv1beta1.Zundoko{
		ObjectMeta: metav1.ObjectMeta{
			Name:      instance.Name + nameSuffix,
			Namespace: instance.Namespace,
		},
		Spec: zundokokiyoshiv1beta1.ZundokoSpec{
			Say: word,
		},
	}
	if err := controllerutil.SetControllerReference(instance, zundoko, r.scheme); err != nil {
		log.Error(err, "An error occurred in SetControllerReference", "instance", instance.Name, "namespace", zundoko.Namespace, "name", zundoko.Name)
		return err
	}

	log.Info("Creating Zundoko", "namespace", zundoko.Namespace, "name", zundoko.Name)
	if err := r.Create(context.TODO(), zundoko); err != nil {
		log.Error(err, "Failed to create Zundoko", "namespace", zundoko.Namespace, "name", zundoko.Name)
		return err
	}

	return nil
}

$ make generate
$ make manifest

$ docker build -t kaitoy/zundoko-operator:latest .

 apiVersion: apps/v1
 kind: StatefulSet
 metadata:
   name: controller-manager
   namespace: system
 spec:
   template:
     spec:
       containers:
       # Change the value of image field below to your controller image URL
-     - image: IMAGE_URL
+     - image: kaitoy/zundoko-operator:latest
         name: manager

$ kustomize build config/default > zundoko-operator.yaml

$ kubectl apply -f zundoko-operator/config/crds/zundokokiyoshi_v1beta1_hikawa.yaml
$ kubectl apply -f zundoko-operator/config/crds/zundokokiyoshi_v1beta1_kiyoshi.yaml
$ kubectl apply -f zundoko-operator/config/crds/zundokokiyoshi_v1beta1_zundoko.yaml
$ kubectl apply -f zundoko-operator/zundoko-operator.yaml

$ cat <<EOF | kubectl create -f -
apiVersion: zundokokiyoshi.kaitoy.github.com/v1beta1
kind: Hikawa
metadata:
  labels:
    controller-tools.k8s.io: "1.0"
  name: hikawa-sample
spec:
  intervalMillis: 500
EOF