Add GitHub Enterprise support

apiserver/controllers/enterprises.go

@@ -0,0 +1,282 @@
+// Copyright 2022 Cloudbase Solutions SRL
+//
+//    Licensed under the Apache License, Version 2.0 (the "License"); you may
+//    not use this file except in compliance with the License. You may obtain
+//    a copy of the License at
+//
+//         http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+//    License for the specific language governing permissions and limitations
+//    under the License.
+
+package controllers
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"garm/apiserver/params"
+	gErrors "garm/errors"
+	runnerParams "garm/params"
+
+	"github.com/gorilla/mux"
+)
+
+func (a *APIController) CreateEnterpriseHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	var enterpriseData runnerParams.CreateEnterpriseParams
+	if err := json.NewDecoder(r.Body).Decode(&enterpriseData); err != nil {
+		handleError(w, gErrors.ErrBadRequest)
+		return
+	}
+
+	enterprise, err := a.r.CreateEnterprise(ctx, enterpriseData)
+	if err != nil {
+		log.Printf("error creating enterprise: %+v", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(enterprise)
+}
+
+func (a *APIController) ListEnterprisesHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	enterprise, err := a.r.ListEnterprises(ctx)
+	if err != nil {
+		log.Printf("listing enterprise: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(enterprise)
+}
+
+func (a *APIController) GetEnterpriseByIDHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	vars := mux.Vars(r)
+	enterpriseID, ok := vars["enterpriseID"]
+	if !ok {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise ID specified",
+		})
+		return
+	}
+
+	enterprise, err := a.r.GetEnterpriseByID(ctx, enterpriseID)
+	if err != nil {
+		log.Printf("fetching enterprise: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(enterprise)
+}
+
+func (a *APIController) DeleteEnterpriseHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	vars := mux.Vars(r)
+	enterpriseID, ok := vars["enterpriseID"]
+	if !ok {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise ID specified",
+		})
+		return
+	}
+
+	if err := a.r.DeleteEnterprise(ctx, enterpriseID); err != nil {
+		log.Printf("removing enterprise: %+v", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+
+}
+
+func (a *APIController) UpdateEnterpriseHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	vars := mux.Vars(r)
+	enterpriseID, ok := vars["enterpriseID"]
+	if !ok {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise ID specified",
+		})
+		return
+	}
+
+	var updatePayload runnerParams.UpdateRepositoryParams
+	if err := json.NewDecoder(r.Body).Decode(&updatePayload); err != nil {
+		handleError(w, gErrors.ErrBadRequest)
+		return
+	}
+
+	enterprise, err := a.r.UpdateEnterprise(ctx, enterpriseID, updatePayload)
+	if err != nil {
+		log.Printf("error updating enterprise: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(enterprise)
+}
+
+func (a *APIController) CreateEnterprisePoolHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	vars := mux.Vars(r)
+	enterpriseID, ok := vars["enterpriseID"]
+	if !ok {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise ID specified",
+		})
+		return
+	}
+
+	var poolData runnerParams.CreatePoolParams
+	if err := json.NewDecoder(r.Body).Decode(&poolData); err != nil {
+		log.Printf("failed to decode: %s", err)
+		handleError(w, gErrors.ErrBadRequest)
+		return
+	}
+
+	pool, err := a.r.CreateEnterprisePool(ctx, enterpriseID, poolData)
+	if err != nil {
+		log.Printf("error creating enterprise pool: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(pool)
+}
+
+func (a *APIController) ListEnterprisePoolsHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	vars := mux.Vars(r)
+	enterpriseID, ok := vars["enterpriseID"]
+	if !ok {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise ID specified",
+		})
+		return
+	}
+
+	pools, err := a.r.ListEnterprisePools(ctx, enterpriseID)
+	if err != nil {
+		log.Printf("listing pools: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(pools)
+}
+
+func (a *APIController) GetEnterprisePoolHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	vars := mux.Vars(r)
+	enterpriseID, enterpriseOk := vars["enterpriseID"]
+	poolID, poolOk := vars["poolID"]
+	if !enterpriseOk || !poolOk {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise or pool ID specified",
+		})
+		return
+	}
+
+	pool, err := a.r.GetEnterprisePoolByID(ctx, enterpriseID, poolID)
+	if err != nil {
+		log.Printf("listing pools: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(pool)
+}
+
+func (a *APIController) DeleteEnterprisePoolHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	vars := mux.Vars(r)
+	enterpriseID, enterpriseOk := vars["enterpriseID"]
+	poolID, poolOk := vars["poolID"]
+	if !enterpriseOk || !poolOk {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise or pool ID specified",
+		})
+		return
+	}
+
+	if err := a.r.DeleteEnterprisePool(ctx, enterpriseID, poolID); err != nil {
+		log.Printf("removing pool: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+
+}
+
+func (a *APIController) UpdateEnterprisePoolHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	vars := mux.Vars(r)
+	enterpriseID, enterpriseOk := vars["enterpriseID"]
+	poolID, poolOk := vars["poolID"]
+	if !enterpriseOk || !poolOk {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise or pool ID specified",
+		})
+		return
+	}
+
+	var poolData runnerParams.UpdatePoolParams
+	if err := json.NewDecoder(r.Body).Decode(&poolData); err != nil {
+		log.Printf("failed to decode: %s", err)
+		handleError(w, gErrors.ErrBadRequest)
+		return
+	}
+
+	pool, err := a.r.UpdateEnterprisePool(ctx, enterpriseID, poolID, poolData)
+	if err != nil {
+		log.Printf("error creating enterprise pool: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(pool)
+}

apiserver/controllers/instances.go

@@ -136,7 +136,31 @@ func (a *APIController) ListOrgInstancesHandler(w http.ResponseWriter, r *http.R
 
 	instances, err := a.r.ListOrgInstances(ctx, orgID)
 	if err != nil {
-		log.Printf("listing pools: %s", err)
+		log.Printf("listing instances: %s", err)
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(instances)
+}
+
+func (a *APIController) ListEnterpriseInstancesHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	vars := mux.Vars(r)
+	enterpriseID, ok := vars["enterpriseID"]
+	if !ok {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(params.APIErrorResponse{
+			Error:   "Bad Request",
+			Details: "No enterprise ID specified",
+		})
+		return
+	}
+
+	instances, err := a.r.ListEnterpriseInstances(ctx, enterpriseID)
+	if err != nil {
+		log.Printf("listing instances: %s", err)
 		handleError(w, err)
 		return
 	}

apiserver/routers/routers.go

@@ -165,6 +165,45 @@ func NewAPIRouter(han *controllers.APIController, logWriter io.Writer, authMiddl
 	apiRouter.Handle("/organizations/", log(logWriter, http.HandlerFunc(han.CreateOrgHandler))).Methods("POST", "OPTIONS")
 	apiRouter.Handle("/organizations", log(logWriter, http.HandlerFunc(han.CreateOrgHandler))).Methods("POST", "OPTIONS")
 
+	/////////////////////////////
+	//  Enterprises and pools  //
+	/////////////////////////////
+	// Get pool
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/{poolID}/", log(logWriter, http.HandlerFunc(han.GetEnterprisePoolHandler))).Methods("GET", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/{poolID}", log(logWriter, http.HandlerFunc(han.GetEnterprisePoolHandler))).Methods("GET", "OPTIONS")
+	// Delete pool
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/{poolID}/", log(logWriter, http.HandlerFunc(han.DeleteEnterprisePoolHandler))).Methods("DELETE", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/{poolID}", log(logWriter, http.HandlerFunc(han.DeleteEnterprisePoolHandler))).Methods("DELETE", "OPTIONS")
+	// Update pool
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/{poolID}/", log(logWriter, http.HandlerFunc(han.UpdateEnterprisePoolHandler))).Methods("PUT", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/{poolID}", log(logWriter, http.HandlerFunc(han.UpdateEnterprisePoolHandler))).Methods("PUT", "OPTIONS")
+	// List pools
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/", log(logWriter, http.HandlerFunc(han.ListEnterprisePoolsHandler))).Methods("GET", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools", log(logWriter, http.HandlerFunc(han.ListEnterprisePoolsHandler))).Methods("GET", "OPTIONS")
+	// Create pool
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools/", log(logWriter, http.HandlerFunc(han.CreateEnterprisePoolHandler))).Methods("POST", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}/pools", log(logWriter, http.HandlerFunc(han.CreateEnterprisePoolHandler))).Methods("POST", "OPTIONS")
+
+	// Repo instances list
+	apiRouter.Handle("/enterprises/{enterpriseID}/instances/", log(logWriter, http.HandlerFunc(han.ListEnterpriseInstancesHandler))).Methods("GET", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}/instances", log(logWriter, http.HandlerFunc(han.ListEnterpriseInstancesHandler))).Methods("GET", "OPTIONS")
+
+	// Get org
+	apiRouter.Handle("/enterprises/{enterpriseID}/", log(logWriter, http.HandlerFunc(han.GetEnterpriseByIDHandler))).Methods("GET", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}", log(logWriter, http.HandlerFunc(han.GetEnterpriseByIDHandler))).Methods("GET", "OPTIONS")
+	// Update org
+	apiRouter.Handle("/enterprises/{enterpriseID}/", log(logWriter, http.HandlerFunc(han.UpdateEnterpriseHandler))).Methods("PUT", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}", log(logWriter, http.HandlerFunc(han.UpdateEnterpriseHandler))).Methods("PUT", "OPTIONS")
+	// Delete org
+	apiRouter.Handle("/enterprises/{enterpriseID}/", log(logWriter, http.HandlerFunc(han.DeleteEnterpriseHandler))).Methods("DELETE", "OPTIONS")
+	apiRouter.Handle("/enterprises/{enterpriseID}", log(logWriter, http.HandlerFunc(han.DeleteEnterpriseHandler))).Methods("DELETE", "OPTIONS")
+	// List orgs
+	apiRouter.Handle("/enterprises/", log(logWriter, http.HandlerFunc(han.ListEnterprisesHandler))).Methods("GET", "OPTIONS")
+	apiRouter.Handle("/enterprises", log(logWriter, http.HandlerFunc(han.ListEnterprisesHandler))).Methods("GET", "OPTIONS")
+	// Create org
+	apiRouter.Handle("/enterprises/", log(logWriter, http.HandlerFunc(han.CreateEnterpriseHandler))).Methods("POST", "OPTIONS")
+	apiRouter.Handle("/enterprises", log(logWriter, http.HandlerFunc(han.CreateEnterpriseHandler))).Methods("POST", "OPTIONS")
+
 	// Credentials and providers
 	apiRouter.Handle("/credentials/", log(logWriter, http.HandlerFunc(han.ListCredentials))).Methods("GET", "OPTIONS")
 	apiRouter.Handle("/credentials", log(logWriter, http.HandlerFunc(han.ListCredentials))).Methods("GET", "OPTIONS")

cloudconfig/cloudconfig.go

@@ -15,6 +15,7 @@
 package cloudconfig
 
 import (
+	"crypto/x509"
 	"encoding/base64"
 	"fmt"
 	"garm/config"
@@ -73,6 +74,29 @@ type CloudInit struct {
 	SystemInfo        *SystemInfo `yaml:"system_info,omitempty"`
 	RunCmd            []string    `yaml:"runcmd,omitempty"`
 	WriteFiles        []File      `yaml:"write_files,omitempty"`
+	CACerts           CACerts     `yaml:"ca-certs,omitempty"`
+}
+
+type CACerts struct {
+	RemoveDefaults bool     `yaml:"remove-defaults"`
+	Trusted        []string `yaml:"trusted"`
+}
+
+func (c *CloudInit) AddCACert(cert []byte) error {
+	c.mux.Lock()
+	defer c.mux.Unlock()
+
+	if cert == nil {
+		return nil
+	}
+
+	roots := x509.NewCertPool()
+	if ok := roots.AppendCertsFromPEM(cert); !ok {
+		return fmt.Errorf("failed to parse CA cert bundle")
+	}
+	c.CACerts.Trusted = append(c.CACerts.Trusted, string(cert))
+
+	return nil
 }
 
 func (c *CloudInit) AddSSHKey(keys ...string) {