a set of fixes

config/rbac/rbac_role.yaml

@@ -24,6 +24,7 @@ rules:
   - machinedeployments
   - machinesets
   - machines
+  - machines/status
   verbs:
   - get
   - list
@@ -50,6 +51,7 @@ rules:
   resources:
   - secrets
   verbs:
+  - create
   - get
   - list
   - watch

pkg/apis/openstackproviderconfig/v1alpha1/register.go

@@ -138,3 +138,21 @@ func EncodeClusterStatus(status *OpenstackClusterProviderStatus) (*runtime.RawEx
 		Raw: rawBytes,
 	}, nil
 }
+
+func EncodeMachineStatus(status *OpenstackMachineProviderStatus) (*runtime.RawExtension, error) {
+	if status == nil {
+		return &runtime.RawExtension{}, nil
+	}
+
+	var rawBytes []byte
+	var err error
+
+	//  TODO: use apimachinery conversion https://godoc.org/k8s.io/apimachinery/pkg/runtime#Convert_runtime_Object_To_runtime_RawExtension
+	if rawBytes, err = json.Marshal(status); err != nil {
+		return nil, err
+	}
+
+	return &runtime.RawExtension{
+		Raw: rawBytes,
+	}, nil
+}

pkg/apis/openstackproviderconfig/v1alpha1/types.go

@@ -261,6 +261,19 @@ type OpenstackClusterProviderStatus struct {
 	GlobalSecurityGroup *SecurityGroup `json:"globalSecurityGroup,omitempty"`
 }
 
+// +genclient
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// OpenstackClusterProviderStatus contains the status fields
+// relevant to OpenStack in the cluster object.
+// +k8s:openapi-gen=true
+type OpenstackMachineProviderStatus struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	//TODO: add provider status
+}
+
 // Network represents basic information about the associated OpenStach Neutron Network
 type Network struct {
 	Name string `json:"name"`
@@ -288,4 +301,5 @@ func init() {
 	SchemeBuilder.Register(&OpenstackProviderSpec{})
 	SchemeBuilder.Register(&OpenstackClusterProviderSpec{})
 	SchemeBuilder.Register(&OpenstackClusterProviderStatus{})
+	SchemeBuilder.Register(&OpenstackMachineProviderStatus{})
 }

pkg/cloud/openstack/cluster/actuator.go

@@ -4,6 +4,9 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/pkg/errors"
+	apiv1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/kubernetes"
@@ -17,6 +20,7 @@ import (
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/deployer"
 	clusterv1 "sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha1"
 	clientclusterv1 "sigs.k8s.io/cluster-api/pkg/client/clientset_generated/clientset/typed/cluster/v1alpha1"
+	"sigs.k8s.io/cluster-api/pkg/controller/remote"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/patch"
 )
@@ -106,29 +110,28 @@ func (a *Actuator) Reconcile(cluster *clusterv1.Cluster) error {
 	}
 
 	// Store KubeConfig for Cluster API NodeRef controller to use.
-        kubeConfigSecretName := remote.KubeConfigSecretName(cluster.Name)
-        secretClient := a.coreClient.Secrets(cluster.Namespace)
-        if _, err := secretClient.Get(kubeConfigSecretName, metav1.GetOptions{}); err != nil && apierrors.IsNotFound(err) {
-                kubeConfig, err := a.Deployer.GetKubeConfig(cluster, nil)
-                if err != nil {
-                        return errors.Wrapf(err, "failed to get kubeconfig for cluster %q", cluster.Name)
-                }
-
-                kubeConfigSecret := &apiv1.Secret{
-                        ObjectMeta: metav1.ObjectMeta{
-                                Name: kubeConfigSecretName,
-                        },
-                        StringData: map[string]string{
-                                "value": kubeConfig,
-                        },
-                }
-
-                if _, err := secretClient.Create(kubeConfigSecret); err != nil {
-                        return errors.Wrapf(err, "failed to create kubeconfig secret for cluster %q", cluster.Name)
-                }
-        } else if err != nil {
-                return errors.Wrapf(err, "failed to get kubeconfig secret for cluster %q", cluster.Name)
-
+	kubeConfigSecretName := remote.KubeConfigSecretName(cluster.Name)
+	if _, err := a.params.KubeClient.CoreV1().Secrets(cluster.Namespace).Get(kubeConfigSecretName, metav1.GetOptions{}); err != nil && apierrors.IsNotFound(err) {
+		kubeConfig, err := a.Deployer.GetKubeConfig(cluster, nil)
+		if err != nil {
+			return errors.Wrapf(err, "failed to get kubeconfig for cluster %q", cluster.Name)
+		}
+
+		kubeConfigSecret := &apiv1.Secret{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: kubeConfigSecretName,
+			},
+			StringData: map[string]string{
+				"value": kubeConfig,
+			},
+		}
+
+		if _, err := a.params.KubeClient.CoreV1().Secrets(cluster.Namespace).Create(kubeConfigSecret); err != nil {
+			return errors.Wrapf(err, "failed to create kubeconfig secret for cluster %q", cluster.Name)
+		}
+	} else if err != nil {
+		return errors.Wrapf(err, "failed to get kubeconfig secret for cluster %q", cluster.Name)
+	}
 
 	err = networkingService.ReconcileSecurityGroups(clusterName, *clusterProviderSpec, clusterProviderStatus)
 	if err != nil {

pkg/cloud/openstack/machine/actuator.go

@@ -160,10 +160,24 @@ func (a *Actuator) Create(ctx context.Context, cluster *clusterv1.Cluster, machi
 	providerID := fmt.Sprintf("openstack:////%s", instance.ID)
 	machine.Spec.ProviderID = &providerID
 
+	klog.Infof("updated status of machine of %s", machine.Name)
+	ext, _ := providerv1.EncodeMachineStatus(&providerv1.OpenstackMachineProviderStatus{})
+	machine.Status.ProviderStatus = ext
+	err = a.updateMachine(cluster, machine)
+	if err != nil {
+		klog.Infof("updated status of machine %v", err)
+	}
+
 	record.Eventf(machine, "CreatedInstance", "Created new instance with id: %s", instance.ID)
 	return a.updateAnnotation(machine, instance.ID)
 }
 
+func (a *Actuator) updateMachine(cluster *clusterv1.Cluster, machine *clusterv1.Machine) error {
+	machineClient := a.params.ClusterClient.Machines(cluster.Namespace)
+	_, err := machineClient.UpdateStatus(machine)
+	return err
+}
+
 func (a *Actuator) Delete(ctx context.Context, cluster *clusterv1.Cluster, machine *clusterv1.Machine) error {
 
 	if cluster == nil {
@@ -208,6 +222,13 @@ func (a *Actuator) Update(ctx context.Context, cluster *clusterv1.Cluster, machi
 	}
 	klog.Infof("Updating Machine %s/%s: %s", cluster.Namespace, cluster.Name, machine.Name)
 
+	ext, _ := providerv1.EncodeMachineStatus(&providerv1.OpenstackMachineProviderStatus{})
+	machine.Status.ProviderStatus = ext
+	err := a.updateMachine(cluster, machine)
+	if err != nil {
+		klog.Infof("updated status of machine %v", err)
+	}
+
 	status, err := a.instanceStatus(machine)
 	if err != nil {
 		return err

pkg/deployer/deployer.go

@@ -55,9 +55,14 @@ func (d *Deployer) GetKubeConfig(cluster *clusterv1.Cluster, master *clusterv1.M
 		return "", errors.New("key not found in status")
 	}
 
-	ip, err := d.GetIP(cluster, master)
-	if err != nil {
-		return "", err
+	var ip string
+	if master != nil {
+		ip, err = d.GetIP(cluster, master)
+		if err != nil {
+			return "", err
+		}
+	} else {
+		ip = "1.2.3.4"
 	}
 
 	server := fmt.Sprintf("https://%s:443", ip)