Feat/external api

api/v1alpha1/ipfscluster_types.go

@@ -35,13 +35,18 @@ const (
 
 type ReproviderStrategy string
 
+type ExternalStrategy string
+
 const (
 	// ReproviderStrategyAll Announces the CID of every stored block.
 	ReproviderStrategyAll ReproviderStrategy = "all"
 	// ReproviderStrategyPinned Only announces the pinned CIDs recursively.
 	ReproviderStrategyPinned ReproviderStrategy = "pinned"
 	// ReproviderStrategyRoots Only announces the root block of explicitly pinned CIDs.
-	ReproviderStrategyRoots ReproviderStrategy = "roots"
+	ReproviderStrategyRoots      ReproviderStrategy = "roots"
+	ExternalStrategyNone         ExternalStrategy   = "none"
+	ExternalStrategyIngress      ExternalStrategy   = "ingress"
+	ExternalStrategyLoadBalancer ExternalStrategy   = "loadbalancer"
 )
 
 type ReprovideSettings struct {
@@ -55,6 +60,14 @@ type ReprovideSettings struct {
 	Interval string `json:"interval,omitempty"`
 }
 
+type ExternalSettings struct {
+	// +kubebuilder:validation:Enum={ingress,loadbalancer,none}
+	// +optional
+	Strategy ExternalStrategy `json:"strategy,omitempty"`
+	// +optional
+	Annotations map[string]string `json:"interval,omitempty"`
+}
+
 type followParams struct {
 	Name     string `json:"name"`
 	Template string `json:"template"`
@@ -69,6 +82,7 @@ type networkConfig struct {
 type IpfsClusterSpec struct {
 	// url defines the URL to be using as an ingress controller.
 	// +kubebuilder:validation:Optional
+	// Reprovider Describes the settings that each IPFS node
 	URL string `json:"url"`
 	// public determines whether or not we should be exposing this IPFS Cluster to the public.
 	Public bool `json:"public"`
@@ -91,6 +105,8 @@ type IpfsClusterSpec struct {
 	// should use when reproviding content.
 	// +optional
 	Reprovider ReprovideSettings `json:"reprovider,omitempty"`
+	Gateway    ExternalSettings  `json:"gateway"`
+	ClusterAPI ExternalSettings  `json:"clusterApi"`
 }
 
 type IpfsClusterStatus struct {

config/crd/bases/cluster.ipfs.io_ipfsclusters.yaml

@@ -35,6 +35,19 @@ spec:
           spec:
             description: IpfsClusterSpec defines the desired state of the IpfsCluster.
             properties:
+              clusterApi:
+                properties:
+                  interval:
+                    additionalProperties:
+                      type: string
+                    type: object
+                  strategy:
+                    enum:
+                    - ingress
+                    - loadbalancer
+                    - none
+                    type: string
+                type: object
               clusterStorage:
                 anyOf:
                 - type: integer
@@ -57,6 +70,19 @@ spec:
                   - template
                   type: object
                 type: array
+              gateway:
+                properties:
+                  interval:
+                    additionalProperties:
+                      type: string
+                    type: object
+                  strategy:
+                    enum:
+                    - ingress
+                    - loadbalancer
+                    - none
+                    type: string
+                type: object
               ipfsResources:
                 description: ipfsResources specifies the resource requirements for
                   each IPFS container. If this value is omitted, then the operator
@@ -131,10 +157,13 @@ spec:
                 type: object
               url:
                 description: url defines the URL to be using as an ingress controller.
+                  Reprovider Describes the settings that each IPFS node
                 type: string
             required:
+            - clusterApi
             - clusterStorage
             - follows
+            - gateway
             - ipfsStorage
             - networking
             - public

controllers/circuitrelay_controller.go

@@ -214,7 +214,7 @@ func (r *CircuitRelayReconciler) serviceRelay(
 				{
 					Name:       "swarm",
 					Protocol:   corev1.ProtocolTCP,
-					Port:       portSwarm,
+					Port:       portIpfsSwarm,
 					TargetPort: intstr.FromString("swarm"),
 				},
 				// Commented out because some load balancers don't support TCP+UDP:(
@@ -420,18 +420,18 @@ func (r *CircuitRelayReconciler) deploymentRelay(
 							Ports: []corev1.ContainerPort{
 								{
 									Name:          "swarm",
-									ContainerPort: portSwarm,
+									ContainerPort: portIpfsSwarm,
 									Protocol:      "TCP",
 								},
 								{
 									// Should this port number be the same as portSwarm or should it be a different one?
 									Name:          "swarm-udp",
-									ContainerPort: portSwarmUDP,
+									ContainerPort: portIpfsSwarmUDP,
 									Protocol:      "UDP",
 								},
 								{
 									Name:          "pprof",
-									ContainerPort: portPprof,
+									ContainerPort: portIpfsPprof,
 									Protocol:      "UDP",
 								},
 							},

controllers/ipfscluster_controller.go

@@ -136,21 +136,26 @@ func (r *IpfsClusterReconciler) createTrackedObjects(
 ) map[client.Object]controllerutil.MutateFn {
 	sa := corev1.ServiceAccount{}
 	svc := corev1.Service{}
+	gwsvc := corev1.Service{}
+	apisvc := corev1.Service{}
 	cmScripts := corev1.ConfigMap{}
 	secConfig := corev1.Secret{}
 	sts := appsv1.StatefulSet{}
 
 	mutsa := r.serviceAccount(instance, &sa)
 	mutsvc, svcName := r.serviceCluster(instance, &svc)
 
+	mutgwsvc, _ := r.serviceGateway(instance, &gwsvc)
+	mutapisvc, _ := r.serviceAPI(instance, &apisvc)
+
 	mutCmScripts, cmScriptName := r.ConfigMapScripts(ctx, instance, &cmScripts)
 	mutSecConfig, secConfigName := r.SecretConfig(
 		ctx,
 		instance,
 		&secConfig,
 		[]byte(clusterSecret),
+		[]byte(peerID.String()),
 		[]byte(privateString),
-		peerID.String(),
 	)
 	mutSts := r.StatefulSet(instance, &sts, svcName, secConfigName, cmScriptName)
 
@@ -161,6 +166,13 @@ func (r *IpfsClusterReconciler) createTrackedObjects(
 		&secConfig: mutSecConfig,
 		&sts:       mutSts,
 	}
+
+	if instance.Spec.Gateway.Strategy == clusterv1alpha1.ExternalStrategyLoadBalancer {
+		trackedObjects[&gwsvc] = mutgwsvc
+	}
+	if instance.Spec.ClusterAPI.Strategy == clusterv1alpha1.ExternalStrategyLoadBalancer {
+		trackedObjects[&apisvc] = mutapisvc
+	}
 	return trackedObjects
 }
 

controllers/ipfscluster_controller_test.go

@@ -85,15 +85,15 @@ var _ = Describe("IPFS Reconciler", func() {
 		})
 		It("creates a new peer ids", func() {
 			secretConfig := &v1.Secret{}
-			fn, _ := ipfsReconciler.SecretConfig(ctx, ipfs, secretConfig, clusterSec, bootstrapKey, clusterPeerID)
+			fn, _ := ipfsReconciler.SecretConfig(ctx, ipfs, secretConfig, clusterSec, bootstrapKey, []byte(clusterPeerID))
 			Expect(fn()).To(BeNil())
 			secretStringToData(secretConfig)
 			expectedKeys := int(replicas)*2 + alwaysKeys
 			Expect(len(secretConfig.Data)).To(Equal(expectedKeys))
 
 			// increase the replica count. Expect to see new keys generated.
 			ipfs.Spec.Replicas++
-			fn, _ = ipfsReconciler.SecretConfig(ctx, ipfs, secretConfig, clusterSec, bootstrapKey, clusterPeerID)
+			fn, _ = ipfsReconciler.SecretConfig(ctx, ipfs, secretConfig, clusterSec, bootstrapKey, []byte(clusterPeerID))
 			Expect(fn()).To(BeNil())
 			secretStringToData(secretConfig)
 			Expect(len(secretConfig.Data)).To(Equal(expectedKeys + 2))

controllers/secret.go

@@ -33,8 +33,8 @@ func (r *IpfsClusterReconciler) SecretConfig(
 	m *clusterv1alpha1.IpfsCluster,
 	sec *corev1.Secret,
 	clusterSecret,
+	bootstrapPeerID,
 	bootstrapPrivateKey []byte,
-	peerID string,
 ) (controllerutil.MutateFn, string) {
 	secName := "ipfs-cluster-" + m.Name
 
@@ -60,7 +60,7 @@ func (r *IpfsClusterReconciler) SecretConfig(
 		}
 		expectedSecret.Data["CLUSTER_SECRET"] = clusterSecret
 		expectedSecret.Data["BOOTSTRAP_PEER_PRIV_KEY"] = bootstrapPrivateKey
-		expectedSecret.StringData["BOOTSTRAP_PEER_ID"] = peerID
+		expectedSecret.Data["BOOTSTRAP_PEER_ID"] = bootstrapPeerID
 	} else {
 		// secret exists.
 		// test if we need to add more identieis