</goals>
          </execution>
        </executions>
        <configuration>
          <instructions>
            <Export-Package>
              !com.google.common.base.internal,
              !com.google.common.util.concurrent.internal,
              com.google.common.*
            </Export-Package>
            <Import-Package>
              com.google.common.util.concurrent.internal,

	if errors.Is(err, syscall.EADDRINUSE) {
		return ErrPortAlreadyInUse(err).Msg("Specified port is already in use")
	} else if errors.Is(err, syscall.EACCES) || errors.Is(err, syscall.EPERM) {
		if netErr, ok := err.(*net.OpError); ok {
			return ErrPortAccess(netErr).Msg("Insufficient permissions to use specified port")
		}
	}

	// Failed to identify what type of error this, return a simple UI error

                    int port = url.getPort();
                    if (port == -1) {
                        port = "https".equalsIgnoreCase(protocol) ? 443 : 80;
                    }
                    PasswordAuthentication auth =
                            Authenticator.requestPasswordAuthentication(null,
                                    port, protocol, "", authMethod);

  loadBalancerIP: {{ default "" .Values.service.loadBalancerIP | quote }}
  {{- end }}
  ports:
    - name: {{ $scheme }}
      port: {{ .Values.service.port }}
      protocol: TCP
      {{- if (and (eq .Values.service.type "NodePort") ( .Values.service.nodePort)) }}
      nodePort: {{ .Values.service.nodePort }}
      {{- else }}

    public NameServiceClientImpl ( CIFSContext tc ) {
        this(tc.getConfig().getNetbiosLocalPort(), tc.getConfig().getNetbiosLocalAddress(), tc);
    }


    NameServiceClientImpl ( int lport, InetAddress laddr, CIFSContext tc ) {
        this.lport = lport;
        this.laddr = laddr;
        this.transportContext = tc;

        this.baddr = tc.getConfig().getBroadcastAddress();

      component: controller
  template:
    metadata:
      annotations:
        prometheus.io/port: "7472"
        prometheus.io/scrape: "true"
      labels:
        app: metallb
        component: controller
    spec:
      containers:
      - args:
        - --port=7472
        - --log-level=info
        - --tls-min-version=VersionTLS12
        env:

            false, "keyword", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnPort = cci("port", "port", null, null, Integer.class, "port", null, false, false, false, "Integer", 0,
            0, null, null, false, null, null, null, null, null, false);

		name    string
		fields  fields
		wantErr bool
	}{
		{
			name: "test1_missing_topic",
			fields: fields{
				Enable: true,
				NSQDAddress: xnet.Host{
					Name:      "127.0.0.1",
					Port:      4150,
					IsPortSet: true,
				},
				Topic: "",
			},
			wantErr: true,
		},
		{
			name: "test2_disabled",
			fields: fields{
				Enable:      false,
				NSQDAddress: xnet.Host{},

			echo "...waiting... for 5secs" && sleep 5
		done
	done

	echo "Sleeping for nginx"
	sleep 20
}

__init__() {
	sudo apt install curl -y
	export GOPATH=/tmp/gopath
	export PATH=${PATH}:${GOPATH}/bin

	go install github.com/minio/mc@latest

	## this is needed because github actions don't have
	## docker-compose on all runners
	go install github.com/docker/compose/v2/cmd@latest

  @Test
  @Throws(IOException::class)
  fun multipleDnsLookupsForSingleCall() {
    server!!.enqueue(
      MockResponse(
        code = 301,
        headers = headersOf("Location", "http://www.fakeurl:" + server!!.port),
      ),
    )
    server!!.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server!!.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server!!.hostName)
    client =