overlayPorts:        []*v1.ServicePort{httpsPort, httpPort},
			expectedMergedPorts: []*v1.ServicePort{istioHealthcheckPort, httpsPort, httpPort},
		},
		{
			name:                "metrics port is present",
			basePorts:           []*v1.ServicePort{istioMetricsPort, httpsPort, httpPort},
			overlayPorts:        []*v1.ServicePort{httpsPort, httpPort},

        }

        if (standalone) {
            httpPort = regexParseHttpPortStandalone(output.call(), occurrence)
        } else {
            httpPort = regexParseHttpPortFromGradle(output.call(), occurrence)
        }
        return httpPort
    }


    static int regexParseHttpPortStandalone(output, int occurrence) {

func NewJwtServer(certificate string, key string) *JWTServer {
	return &JWTServer{
		httpPort:          make(chan int, 1),
		httpsPort:         make(chan int, 1),
		serverCertificate: certificate,
		serverPrivateKey:  key,
	}
}

func main() {
	flag.Parse()
	s := NewJwtServer(*serverCert, *serverkey)
	go s.runHTTP(fmt.Sprintf(":%s", *httpPort))
	if s.serverCertificate != "" && s.serverPrivateKey != "" {

	return map[string]any{
		"httpName": s.httpName(),
		"grpcName": s.grpcName(),
		"httpHost": s.httpHost(),
		"grpcHost": s.grpcHost(),
		"httpPort": httpPort,
		"grpcPort": grpcPort,
	}
}

func (s *localServerImpl) installProviders(ctx resource.Context) error {
	// Update the mesh config extension provider for the ext-authz service.

<server description="Sample Liberty server">

    <featureManager>
        <feature>jaxrs-2.0</feature>
        <feature>jsonp-1.0</feature>
    </featureManager>

    <httpEndpoint host="*" httpPort="9080" httpsPort="-1"
                  id="defaultHttpEndpoint"/>

    <webContainer deferServletLoad="false"/>
    <applicationMonitor dropinsEnabled="false" updateTrigger="mbean"/>
    <config updateTrigger="mbean"/>

	return fmt.Sprintf("%s.%s.svc.cluster.local", serviceName, s.ns.Name())
}

func (s *serverImpl) HTTPPort() int {
	return httpPort
}

func (s *serverImpl) HTTPSPort() int {
	return httpsPort
}

func (s *serverImpl) JwksURI() string {
	uri := fmt.Sprintf("http://%s:%d/jwks", s.FQDN(), s.HTTPPort())
	return uri
}

func (s *serverImpl) ID() resource.ID {
	return s.id
}

	"istio.io/istio/pkg/util/sets"
)

const (
	httpName = "ext-authz-http"
	grpcName = "ext-authz-grpc"
	httpPort = 8000
	grpcPort = 9000

	providerTemplate = `
extensionProviders:
- name: "{{ .httpName }}"
  envoyExtAuthzHttp:
    service: "{{ .fqdn }}"
    port: {{ .httpPort }}
    headersToUpstreamOnAllow: ["x-ext-authz-*"]
    headersToDownstreamOnDeny: ["x-ext-authz-*"]

                httpPort = new ServerSocket(0).withCloseable { socket -> socket.getLocalPort() }
                integrationTestTask = 'checkContainerUp'
                servletContainer = '${grettyConfig.servletContainer}'
            }

            task checkContainerUp {
                doLast {
                    URL url = new URL("http://localhost:\${gretty.httpPort}/quickstart")

	return &ExtAuthzServer{
		grpcV2:   &extAuthzServerV2{},
		grpcV3:   &extAuthzServerV3{},
		httpPort: make(chan int, 1),
		grpcPort: make(chan int, 1),
	}
}

func main() {
	flag.Parse()
	s := NewExtAuthzServer()
	go s.run(fmt.Sprintf(":%s", *httpPort), fmt.Sprintf(":%s", *grpcPort))
	defer s.stop()

	// Wait for the process to be shutdown.
	sigs := make(chan os.Signal, 1)

	"istio.io/istio/pkg/test/framework/resource"
)

// Server for JWT tokens.
type Server interface {
	Namespace() namespace.Instance
	FQDN() string
	HTTPPort() int
	HTTPSPort() int
	JwksURI() string
}

// New creates a new JWT Server.
func New(ctx resource.Context, ns namespace.Instance) (Server, error) {
	return newKubeServer(ctx, ns)
}