mirror of https://github.com/portainer/portainer
298 lines
10 KiB
Go
298 lines
10 KiB
Go
package stacks
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/asaskevich/govalidator"
|
|
"github.com/pkg/errors"
|
|
|
|
httperror "github.com/portainer/libhttp/error"
|
|
"github.com/portainer/libhttp/request"
|
|
"github.com/portainer/libhttp/response"
|
|
portainer "github.com/portainer/portainer/api"
|
|
"github.com/portainer/portainer/api/git/update"
|
|
k "github.com/portainer/portainer/api/kubernetes"
|
|
"github.com/portainer/portainer/api/stacks/deployments"
|
|
"github.com/portainer/portainer/api/stacks/stackbuilders"
|
|
"github.com/portainer/portainer/api/stacks/stackutils"
|
|
)
|
|
|
|
type kubernetesStringDeploymentPayload struct {
|
|
StackName string
|
|
ComposeFormat bool
|
|
Namespace string
|
|
StackFileContent string
|
|
// Whether the stack is from a app template
|
|
FromAppTemplate bool `example:"false"`
|
|
}
|
|
|
|
func createStackPayloadFromK8sFileContentPayload(name, namespace, fileContent string, composeFormat, fromAppTemplate bool) stackbuilders.StackPayload {
|
|
return stackbuilders.StackPayload{
|
|
StackName: name,
|
|
Namespace: namespace,
|
|
StackFileContent: fileContent,
|
|
ComposeFormat: composeFormat,
|
|
FromAppTemplate: fromAppTemplate,
|
|
}
|
|
}
|
|
|
|
type kubernetesGitDeploymentPayload struct {
|
|
StackName string
|
|
ComposeFormat bool
|
|
Namespace string
|
|
RepositoryURL string
|
|
RepositoryReferenceName string
|
|
RepositoryAuthentication bool
|
|
RepositoryUsername string
|
|
RepositoryPassword string
|
|
ManifestFile string
|
|
AdditionalFiles []string
|
|
AutoUpdate *portainer.AutoUpdateSettings
|
|
// TLSSkipVerify skips SSL verification when cloning the Git repository
|
|
TLSSkipVerify bool `example:"false"`
|
|
}
|
|
|
|
func createStackPayloadFromK8sGitPayload(name, repoUrl, repoReference, repoUsername, repoPassword string, repoAuthentication, composeFormat bool, namespace, manifest string, additionalFiles []string, autoUpdate *portainer.AutoUpdateSettings, repoSkipSSLVerify bool) stackbuilders.StackPayload {
|
|
return stackbuilders.StackPayload{
|
|
StackName: name,
|
|
RepositoryConfigPayload: stackbuilders.RepositoryConfigPayload{
|
|
URL: repoUrl,
|
|
ReferenceName: repoReference,
|
|
Authentication: repoAuthentication,
|
|
Username: repoUsername,
|
|
Password: repoPassword,
|
|
TLSSkipVerify: repoSkipSSLVerify,
|
|
},
|
|
Namespace: namespace,
|
|
ComposeFormat: composeFormat,
|
|
ManifestFile: manifest,
|
|
AdditionalFiles: additionalFiles,
|
|
AutoUpdate: autoUpdate,
|
|
}
|
|
}
|
|
|
|
type kubernetesManifestURLDeploymentPayload struct {
|
|
StackName string
|
|
Namespace string
|
|
ComposeFormat bool
|
|
ManifestURL string
|
|
}
|
|
|
|
func createStackPayloadFromK8sUrlPayload(name, namespace, manifestUrl string, composeFormat bool) stackbuilders.StackPayload {
|
|
return stackbuilders.StackPayload{
|
|
StackName: name,
|
|
Namespace: namespace,
|
|
ManifestURL: manifestUrl,
|
|
ComposeFormat: composeFormat,
|
|
}
|
|
}
|
|
|
|
func (payload *kubernetesStringDeploymentPayload) Validate(r *http.Request) error {
|
|
if govalidator.IsNull(payload.StackFileContent) {
|
|
return errors.New("Invalid stack file content")
|
|
}
|
|
if govalidator.IsNull(payload.StackName) {
|
|
return errors.New("Invalid stack name")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (payload *kubernetesGitDeploymentPayload) Validate(r *http.Request) error {
|
|
if govalidator.IsNull(payload.RepositoryURL) || !govalidator.IsURL(payload.RepositoryURL) {
|
|
return errors.New("Invalid repository URL. Must correspond to a valid URL format")
|
|
}
|
|
if payload.RepositoryAuthentication && govalidator.IsNull(payload.RepositoryPassword) {
|
|
return errors.New("Invalid repository credentials. Password must be specified when authentication is enabled")
|
|
}
|
|
if govalidator.IsNull(payload.ManifestFile) {
|
|
return errors.New("Invalid manifest file in repository")
|
|
}
|
|
if err := update.ValidateAutoUpdateSettings(payload.AutoUpdate); err != nil {
|
|
return err
|
|
}
|
|
if govalidator.IsNull(payload.StackName) {
|
|
return errors.New("Invalid stack name")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (payload *kubernetesManifestURLDeploymentPayload) Validate(r *http.Request) error {
|
|
if govalidator.IsNull(payload.ManifestURL) || !govalidator.IsURL(payload.ManifestURL) {
|
|
return errors.New("Invalid manifest URL")
|
|
}
|
|
if govalidator.IsNull(payload.StackName) {
|
|
return errors.New("Invalid stack name")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type createKubernetesStackResponse struct {
|
|
Output string `json:"Output"`
|
|
}
|
|
|
|
func (handler *Handler) createKubernetesStackFromFileContent(w http.ResponseWriter, r *http.Request, endpoint *portainer.Endpoint, userID portainer.UserID) *httperror.HandlerError {
|
|
var payload kubernetesStringDeploymentPayload
|
|
if err := request.DecodeAndValidateJSONPayload(r, &payload); err != nil {
|
|
return httperror.BadRequest("Invalid request payload", err)
|
|
}
|
|
|
|
user, err := handler.DataStore.User().User(userID)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to load user information from the database", err)
|
|
}
|
|
isUnique, err := handler.checkUniqueStackNameInKubernetes(endpoint, payload.StackName, 0, payload.Namespace)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to check for name collision", err)
|
|
}
|
|
if !isUnique {
|
|
return &httperror.HandlerError{StatusCode: http.StatusConflict, Message: fmt.Sprintf("A stack with the name '%s' already exists", payload.StackName), Err: stackutils.ErrStackAlreadyExists}
|
|
}
|
|
|
|
stackPayload := createStackPayloadFromK8sFileContentPayload(payload.StackName, payload.Namespace, payload.StackFileContent, payload.ComposeFormat, payload.FromAppTemplate)
|
|
|
|
k8sStackBuilder := stackbuilders.CreateK8sStackFileContentBuilder(handler.DataStore,
|
|
handler.FileService,
|
|
handler.StackDeployer,
|
|
handler.KubernetesDeployer,
|
|
user)
|
|
|
|
stackBuilderDirector := stackbuilders.NewStackBuilderDirector(k8sStackBuilder)
|
|
_, httpErr := stackBuilderDirector.Build(&stackPayload, endpoint)
|
|
if httpErr != nil {
|
|
return httpErr
|
|
}
|
|
|
|
resp := &createKubernetesStackResponse{
|
|
Output: k8sStackBuilder.GetResponse(),
|
|
}
|
|
|
|
return response.JSON(w, resp)
|
|
}
|
|
|
|
func (handler *Handler) createKubernetesStackFromGitRepository(w http.ResponseWriter, r *http.Request, endpoint *portainer.Endpoint, userID portainer.UserID) *httperror.HandlerError {
|
|
var payload kubernetesGitDeploymentPayload
|
|
if err := request.DecodeAndValidateJSONPayload(r, &payload); err != nil {
|
|
return httperror.BadRequest("Invalid request payload", err)
|
|
}
|
|
|
|
user, err := handler.DataStore.User().User(userID)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to load user information from the database", err)
|
|
}
|
|
isUnique, err := handler.checkUniqueStackNameInKubernetes(endpoint, payload.StackName, 0, payload.Namespace)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to check for name collision", err)
|
|
}
|
|
if !isUnique {
|
|
return &httperror.HandlerError{StatusCode: http.StatusConflict, Message: fmt.Sprintf("A stack with the name '%s' already exists", payload.StackName), Err: stackutils.ErrStackAlreadyExists}
|
|
}
|
|
|
|
//make sure the webhook ID is unique
|
|
if payload.AutoUpdate != nil && payload.AutoUpdate.Webhook != "" {
|
|
isUnique, err := handler.checkUniqueWebhookID(payload.AutoUpdate.Webhook)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to check for webhook ID collision", err)
|
|
}
|
|
if !isUnique {
|
|
return &httperror.HandlerError{StatusCode: http.StatusConflict, Message: fmt.Sprintf("Webhook ID: %s already exists", payload.AutoUpdate.Webhook), Err: stackutils.ErrWebhookIDAlreadyExists}
|
|
}
|
|
}
|
|
|
|
stackPayload := createStackPayloadFromK8sGitPayload(payload.StackName,
|
|
payload.RepositoryURL,
|
|
payload.RepositoryReferenceName,
|
|
payload.RepositoryUsername,
|
|
payload.RepositoryPassword,
|
|
payload.RepositoryAuthentication,
|
|
payload.ComposeFormat,
|
|
payload.Namespace,
|
|
payload.ManifestFile,
|
|
payload.AdditionalFiles,
|
|
payload.AutoUpdate,
|
|
payload.TLSSkipVerify,
|
|
)
|
|
|
|
k8sStackBuilder := stackbuilders.CreateKubernetesStackGitBuilder(handler.DataStore,
|
|
handler.FileService,
|
|
handler.GitService,
|
|
handler.Scheduler,
|
|
handler.StackDeployer,
|
|
handler.KubernetesDeployer,
|
|
user)
|
|
|
|
stackBuilderDirector := stackbuilders.NewStackBuilderDirector(k8sStackBuilder)
|
|
_, httpErr := stackBuilderDirector.Build(&stackPayload, endpoint)
|
|
if httpErr != nil {
|
|
return httpErr
|
|
}
|
|
|
|
resp := &createKubernetesStackResponse{
|
|
Output: k8sStackBuilder.GetResponse(),
|
|
}
|
|
|
|
return response.JSON(w, resp)
|
|
}
|
|
|
|
func (handler *Handler) createKubernetesStackFromManifestURL(w http.ResponseWriter, r *http.Request, endpoint *portainer.Endpoint, userID portainer.UserID) *httperror.HandlerError {
|
|
var payload kubernetesManifestURLDeploymentPayload
|
|
if err := request.DecodeAndValidateJSONPayload(r, &payload); err != nil {
|
|
return httperror.BadRequest("Invalid request payload", err)
|
|
}
|
|
|
|
user, err := handler.DataStore.User().User(userID)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to load user information from the database", err)
|
|
}
|
|
isUnique, err := handler.checkUniqueStackNameInKubernetes(endpoint, payload.StackName, 0, payload.Namespace)
|
|
if err != nil {
|
|
return httperror.InternalServerError("Unable to check for name collision", err)
|
|
}
|
|
if !isUnique {
|
|
return &httperror.HandlerError{StatusCode: http.StatusConflict, Message: fmt.Sprintf("A stack with the name '%s' already exists", payload.StackName), Err: stackutils.ErrStackAlreadyExists}
|
|
}
|
|
|
|
stackPayload := createStackPayloadFromK8sUrlPayload(payload.StackName,
|
|
payload.Namespace,
|
|
payload.ManifestURL,
|
|
payload.ComposeFormat)
|
|
|
|
k8sStackBuilder := stackbuilders.CreateKubernetesStackUrlBuilder(handler.DataStore,
|
|
handler.FileService,
|
|
handler.StackDeployer,
|
|
handler.KubernetesDeployer,
|
|
user)
|
|
|
|
stackBuilderDirector := stackbuilders.NewStackBuilderDirector(k8sStackBuilder)
|
|
_, httpErr := stackBuilderDirector.Build(&stackPayload, endpoint)
|
|
if httpErr != nil {
|
|
return httpErr
|
|
}
|
|
|
|
resp := &createKubernetesStackResponse{
|
|
Output: k8sStackBuilder.GetResponse(),
|
|
}
|
|
|
|
return response.JSON(w, resp)
|
|
}
|
|
|
|
func (handler *Handler) deployKubernetesStack(userID portainer.UserID, endpoint *portainer.Endpoint, stack *portainer.Stack, appLabels k.KubeAppLabels) (string, error) {
|
|
handler.stackCreationMutex.Lock()
|
|
defer handler.stackCreationMutex.Unlock()
|
|
|
|
user := &portainer.User{
|
|
ID: userID,
|
|
}
|
|
k8sDeploymentConfig, err := deployments.CreateKubernetesStackDeploymentConfig(stack, handler.KubernetesDeployer, appLabels, user, endpoint)
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "failed to create temp kub deployment files")
|
|
}
|
|
|
|
err = k8sDeploymentConfig.Deploy()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return k8sDeploymentConfig.GetResponse(), nil
|
|
}
|