data-bs-toggle="collapse"> <c:if test="${empty lang}">
						<la:message key="labels.searchoptions_all" />
					</c:if> <c:if test="${!empty lang}">
						<c:forEach var="sLang" items="${lang}">
							<c:forEach var="item" items="${langItems}">
								<c:if test="${item.value==sLang}">${f:h(item.label)}</c:if>
							</c:forEach>
						</c:forEach>
					</c:if>
			</a></li>

  }

  companion object {
    internal var certA1: HeldCertificate =
      HeldCertificate
        .Builder()
        .serialNumber(100L)
        .build()
    internal var certA1Sha256Pin = CertificatePinner.pin(certA1.certificate)

    private var certB1 =
      HeldCertificate
        .Builder()
        .serialNumber(200L)
        .build()

	genkey      = flag.Bool("genkey", false, "generate key pair")
)

func main() {
	flag.Parse()

	if *genkey {
		generateKeys()
		os.Exit(0)
	}
	var privateKeys [][]byte
	if *keyHex == "" {
		// Attempt to load private key(s)
		n := 1
		var base, ext string
		base = *privKeyPath
		if idx := strings.LastIndexByte(base, '.'); idx != -1 {
			ext = base[idx:]
			base = base[:idx]
		}
		for {

// of MinIO server.
func isValidLocation(location string) bool {
	region := globalSite.Region()
	return region == "" || region == location
}

// Supported headers that needs to be extracted.
var supportedHeaders = []string{
	"content-type",
	"cache-control",
	"content-language",
	"content-encoding",
	"content-disposition",
	"x-amz-storage-class",
	xhttp.AmzStorageClass,
	xhttp.AmzObjectTagging,

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  4096;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '

   * This means that if you are doing synchronous calls the network layer will not truly be idle
   * until every returned [Response] has been closed.
   */
  @get:Synchronized
  @set:Synchronized
  var idleCallback: Runnable? = null

  private var executorServiceOrNull: ExecutorService? = null

  @get:JvmName("executorService")
  @get:Synchronized
  val executorService: ExecutorService
    get() {
      if (executorServiceOrNull == null) {

	tobj, _, _, err := core.GetObject(context.Background(), targetBucket, tgtCtnt.Key, opts)
	if err != nil {
		fmt.Printf("unreadable on target: %s (%s)\n", tgtCtnt.Key, err)
		return false
	}

	var sourceFailed, targetFailed bool
	var wg sync.WaitGroup

	wg.Add(2)
	go func() {
		defer wg.Done()
		srcSize, err := io.Copy(srcSha256, sobj)
		if err != nil {
			fmt.Printf("unreadable on source: %s (%s)\n", srcCtnt.Key, err)

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
)

var port int

func init() {
	flag.IntVar(&port, "port", 8080, "Port to listen on")
}

func mainHandler(w http.ResponseWriter, r *http.Request) {
	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()

# Fess
################################

# Fess Path
FESS_TEMP_PATH=${packaging.fess.temp.dir}
FESS_LOG_PATH=${packaging.fess.log.dir}
FESS_CONF_PATH=${packaging.fess.conf.dir}
FESS_VAR_PATH=${packaging.fess.var.dir}

FESS_DICTIONARY_PATH=/var/lib/opensearch/config/

# Port
FESS_PORT=8080

# Heap Memory
FESS_HEAP_SIZE=512m

# Elasticsearch Path
SEARCH_ENGINE_HOME=/usr/share/opensearch/

# Elasticsearch URL

	for _, endpoint := range endpoints.Endpoints {
		if _, ok := erasureLockers[endpoint.Host]; !ok {
			erasureLockers[endpoint.Host] = newLockAPI(endpoint)
		}
	}

	var wg sync.WaitGroup
	var lk sync.Mutex
	for i := range setCount {
		lockerEpSet := set.NewStringSet()
		for j := range setDriveCount {
			wg.Add(1)
			go func(i int, endpoint Endpoint) {
				defer wg.Done()