if legacy, f := os.LookupEnv("DOCKER_ARCHITECTURES"); f {
		arch = strings.Split(legacy, ",")
	}

	hub := []string{env.Register("HUB", "localhost:5000", "").Get()}
	if hubs, f := os.LookupEnv("HUBS"); f {
		hub = strings.Split(hubs, " ")
	}
	tag := []string{env.Register("TAG", "latest", "").Get()}
	if tags, f := os.LookupEnv("TAGS"); f {
		tag = strings.Split(tags, " ")
	}

	builder := DockerBuilder

if len(yml) == 1: yml = yml[0]
json.dump(yml, sys.stdout, indent=4)
'
}

# shellcheck source=prow/lib.sh
source "${ROOT}/prow/lib.sh"
buildx-create

HUBS="${HUBS:?specify a space separated list of hubs}"
TAG="${TAG:?specify a tag}"
defaultTargets="$(< "${ROOT}/tools/docker.yaml" toJson | toJson | jq '[.images[] | select(.base) | .name] | join(",")' -r)"
DOCKER_TARGETS="${DOCKER_TARGETS:-${defaultTargets}}"

        hubs=()
        images=()
        tags=()

        for hub in ${HUB}; do
          hubs+=( "$hub" );
        done

        for img in ${IMAGE}; do
          images+=( "$img" );
        done

        for tag in ${TAG}; do
          tags+=( "$tag" );
        done

        for i in "${!hubs[@]}"; do
          if [ -z "${images[$i]}" ]

// limitations under the License.

package main

import (
	"fmt"
	"strings"
)

func extractTags(a Args, target, variant string, hasDoubleDefault bool) []string {
	tags := []string{}
	for _, h := range a.Hubs {
		for _, tg := range a.Tags {
			if variant == DefaultVariant {
				// For default, we have no suffix
				tags = append(tags, fmt.Sprintf("%s/%s:%s%s", h, target, tg, a.suffix))
			} else {

	testenv "istio.io/istio/pkg/test/env"
	"istio.io/istio/pkg/tracing"
	"istio.io/istio/pkg/util/sets"
	pkgversion "istio.io/istio/pkg/version"
)

func main() {
	rootCmd.Flags().StringSliceVar(&globalArgs.Hubs, "hub", globalArgs.Hubs, "docker hub(s)")
	rootCmd.Flags().StringSliceVar(&globalArgs.Tags, "tag", globalArgs.Tags, "docker tag(s)")

import java.util.concurrent.LinkedBlockingQueue

@Timeout(60)
class MessageHubIntegrationTest extends ConcurrentSpec {
    final Action<Throwable> errorHandler = Mock()

    def "can wire two hubs together"() {
        Dispatch<String> clientHandler = Mock()
        Dispatch<String> serverHandler = Mock()
        def server = new Participant()
        def client = new Participant()
        client.connectTo(server)

$(TARGET_OUT):
	@mkdir -p $@

# If the hub is not explicitly set, use default to istio.
HUB ?=istio
ifeq ($(HUB),)
  $(error "HUB cannot be empty")
endif

# For dockerx builds, allow HUBS which is a space separated list of hubs. Default to HUB.
HUBS ?= $(HUB)

# If tag not explicitly set in users' .istiorc.mk or command line, default to the git sha.
TAG ?= $(shell git rev-parse --verify HEAD)
ifeq ($(TAG),)

			if wg != nil {
				wg.Done()
			}
			// Clean up and de-register the subscriber
			ps.Lock()
			defer ps.Unlock()
			var remainTypes Mask
			for i, s := range ps.subs {
				if s == sub {
					ps.subs = append(ps.subs[:i], ps.subs[i+1:]...)
				} else {
					remainTypes.Merge(s.types)
				}
			}
			atomic.StoreUint64(&ps.types, uint64(remainTypes))
			atomic.AddInt32(&ps.numSubscribers, -1)
		}()

	eventtype := s.u.eventtype()
	switch mode {
	case 'r':
		*eventtype = eventtypeFdRead
		ridx = len(subs)
	case 'w':
		*eventtype = eventtypeFdWrite
		widx = len(subs)
	}

	if len(subs) == disarmed {
		throw("overflow")
	}

	pd.user = uint32(ridx)<<16 | uint32(widx)

	subs = append(subs, s)
	evts = append(evts, event{})

	unlock(&mtx)
}

	var bucketURL, urlSuffix string
	subs := kubeBucketPrefixes.FindAllStringSubmatch(version, 1)
	if len(subs) != 1 || len(subs[0]) != 4 {
		return "", "", errors.Errorf("invalid version %q", version)
	}

	switch {
	case strings.HasPrefix(subs[0][2], "ci"):
		// Just use whichever the user specified
		urlSuffix = subs[0][2]
		bucketURL = kubeCIBucketURL
	default:
		urlSuffix = "release"