/*
Copyright 2018 The Kubernetes Authors.

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 lua

import (
	"crypto/tls"
	"fmt"
	"net/http"
	"strings"
	"time"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"github.com/parnurzeal/gorequest"

	networking "k8s.io/api/networking/v1beta1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"k8s.io/ingress-nginx/internal/nginx"
	"k8s.io/ingress-nginx/test/e2e/framework"
)

const (
	logDynamicConfigSuccess = "Dynamic reconfiguration succeeded"
	logDynamicConfigFailure = "Dynamic reconfiguration failed"
	logRequireBackendReload = "Configuration changes detected, backend reload required"
	logBackendReloadSuccess = "Backend successfully reloaded"
	logInitialConfigSync    = "Initial synchronization of the NGINX configuration"
	waitForLuaSync          = 5 * time.Second
)

var _ = framework.IngressNginxDescribe("Dynamic Configuration", func() {
	f := framework.NewDefaultFramework("dynamic-configuration")

	BeforeEach(func() {
		f.NewEchoDeploymentWithReplicas(1)
		ensureIngress(f, "foo.com", framework.EchoService)
	})

	It("configures balancer Lua middleware correctly", func() {
		f.WaitForNginxConfiguration(func(cfg string) bool {
			return strings.Contains(cfg, "balancer.init_worker()") && strings.Contains(cfg, "balancer.balance()")
		})

		host := "foo.com"
		f.WaitForNginxServer(host, func(server string) bool {
			return strings.Contains(server, "balancer.rewrite()") && strings.Contains(server, "balancer.log()")
		})
	})

	Context("when only backends change", func() {
		It("handles endpoints only changes", func() {
			var nginxConfig string
			f.WaitForNginxConfiguration(func(cfg string) bool {
				nginxConfig = cfg
				return true
			})

			replicas := 2
			err := framework.UpdateDeployment(f.KubeClientSet, f.Namespace, framework.EchoService, replicas, nil)
			Expect(err).NotTo(HaveOccurred())

			ensureRequest(f, "foo.com")

			var newNginxConfig string
			f.WaitForNginxConfiguration(func(cfg string) bool {
				newNginxConfig = cfg
				return true
			})
			Expect(nginxConfig).Should(Equal(newNginxConfig))
		})

		It("handles endpoints only changes (down scaling of replicas)", func() {
			var nginxConfig string
			f.WaitForNginxConfiguration(func(cfg string) bool {
				nginxConfig = cfg
				return true
			})

			replicas := 2
			err := framework.UpdateDeployment(f.KubeClientSet, f.Namespace, framework.EchoService, replicas, nil)
			Expect(err).NotTo(HaveOccurred())
			time.Sleep(waitForLuaSync * 2)

			ensureRequest(f, "foo.com")

			var newNginxConfig string
			f.WaitForNginxConfiguration(func(cfg string) bool {
				newNginxConfig = cfg
				return true
			})
			Expect(nginxConfig).Should(Equal(newNginxConfig))

			err = framework.UpdateDeployment(f.KubeClientSet, f.Namespace, framework.EchoService, 0, nil)

			Expect(err).NotTo(HaveOccurred())
			time.Sleep(waitForLuaSync * 2)

			ensureRequestWithStatus(f, "foo.com", 503)
		})

		It("handles endpoints only changes consistently (down scaling of replicas vs. empty service)", func() {
			deploymentName := "scalingecho"
			f.NewEchoDeploymentWithNameAndReplicas(deploymentName, 0)
			createIngress(f, "scaling.foo.com", deploymentName)
			originalResponseCode := runRequest(f, "scaling.foo.com")

			replicas := 2
			err := framework.UpdateDeployment(f.KubeClientSet, f.Namespace, deploymentName, replicas, nil)
			Expect(err).NotTo(HaveOccurred())
			time.Sleep(waitForLuaSync * 2)

			expectedSuccessResponseCode := runRequest(f, "scaling.foo.com")

			replicas = 0
			err = framework.UpdateDeployment(f.KubeClientSet, f.Namespace, deploymentName, replicas, nil)
			Expect(err).NotTo(HaveOccurred())
			time.Sleep(waitForLuaSync * 2)

			expectedFailureResponseCode := runRequest(f, "scaling.foo.com")

			Expect(originalResponseCode).To(Equal(503), "Expected empty service to return 503 response.")
			Expect(expectedFailureResponseCode).To(Equal(503), "Expected downscaled replicaset to return 503 response.")
			Expect(expectedSuccessResponseCode).To(Equal(200), "Expected intermediate scaled replicaset to return a 200 response.")
		})

		It("handles an annotation change", func() {
			var nginxConfig string
			f.WaitForNginxConfiguration(func(cfg string) bool {
				nginxConfig = cfg
				return true
			})

			ingress, err := f.KubeClientSet.NetworkingV1beta1().Ingresses(f.Namespace).Get("foo.com", metav1.GetOptions{})
			Expect(err).ToNot(HaveOccurred())

			ingress.ObjectMeta.Annotations["nginx.ingress.kubernetes.io/load-balance"] = "round_robin"
			_, err = f.KubeClientSet.NetworkingV1beta1().Ingresses(f.Namespace).Update(ingress)
			Expect(err).ToNot(HaveOccurred())

			ensureRequest(f, "foo.com")

			var newNginxConfig string
			f.WaitForNginxConfiguration(func(cfg string) bool {
				newNginxConfig = cfg
				return true
			})

			Expect(nginxConfig).Should(Equal(newNginxConfig))
		})
	})

	It("sets controllerPodsCount in Lua general configuration", func() {
		// https://github.com/curl/curl/issues/936
		curlCmd := fmt.Sprintf("curl --fail --silent http://localhost:%v/configuration/general", nginx.StatusPort)

		output, err := f.ExecIngressPod(curlCmd)
		Expect(err).ToNot(HaveOccurred())
		Expect(output).Should(Equal(`{"controllerPodsCount":1}`))

		err = framework.UpdateDeployment(f.KubeClientSet, f.Namespace, "nginx-ingress-controller", 3, nil)
		Expect(err).ToNot(HaveOccurred())

		output, err = f.ExecIngressPod(curlCmd)
		Expect(err).ToNot(HaveOccurred())
		Expect(output).Should(Equal(`{"controllerPodsCount":3}`))
	})
})

func ensureIngress(f *framework.Framework, host string, deploymentName string) *networking.Ingress {
	ing := createIngress(f, host, deploymentName)

	ensureRequest(f, host)

	return ing
}

func createIngress(f *framework.Framework, host string, deploymentName string) *networking.Ingress {
	ing := f.EnsureIngress(framework.NewSingleIngress(host, "/", host, f.Namespace, deploymentName, 80,
		map[string]string{
			"nginx.ingress.kubernetes.io/load-balance": "ewma",
		},
	))

	f.WaitForNginxServer(host,
		func(server string) bool {
			return strings.Contains(server, fmt.Sprintf("server_name %s ;", host)) &&
				strings.Contains(server, "proxy_pass http://upstream_balancer;")
		})

	return ing
}

func ensureRequest(f *framework.Framework, host string) {
	resp, _, errs := gorequest.New().
		Get(f.GetURL(framework.HTTP)).
		Set("Host", host).
		End()
	Expect(errs).Should(BeEmpty())
	Expect(resp.StatusCode).Should(Equal(http.StatusOK))
}

func ensureRequestWithStatus(f *framework.Framework, host string, statusCode int) {
	resp, _, errs := gorequest.New().
		Get(f.GetURL(framework.HTTP)).
		Set("Host", host).
		End()
	Expect(errs).Should(BeEmpty())
	Expect(resp.StatusCode).Should(Equal(statusCode))
}

func runRequest(f *framework.Framework, host string) int {
	resp, _, errs := gorequest.New().
		Get(f.GetURL(framework.HTTP)).
		Set("Host", host).
		End()
	Expect(errs).Should(BeEmpty())
	return resp.StatusCode
}

func ensureHTTPSRequest(url string, host string, expectedDNSName string) {
	resp, _, errs := gorequest.New().
		Get(url).
		Set("Host", host).
		TLSClientConfig(&tls.Config{
			InsecureSkipVerify: true,
			ServerName:         host,
		}).
		End()
	Expect(errs).Should(BeEmpty())
	Expect(resp.StatusCode).Should(Equal(http.StatusOK))
	Expect(len(resp.TLS.PeerCertificates)).Should(BeNumerically("==", 1))
	Expect(resp.TLS.PeerCertificates[0].DNSNames[0]).Should(Equal(expectedDNSName))
}
