--project "${PROJECT}" \
      --region "${REGION}" -q > /dev/null; then
      # successful operation - wait until it's visible
      start="$(date +%s)"
      while true; do
        now="$(date +%s)"
        # Timeout set to 15 minutes
        if [[ $((now - start)) -gt 900 ]]; then
          echo "Timeout while waiting for master IP visibility"
          exit 2
        fi

						}

						// For providing ranged content
						start, rangeLen, err := rs.GetOffsetLength(ci.Size)
						if err != nil {
							start, rangeLen = 0, ci.Size
						}

						// Set content length.
						w.Header().Set(xhttp.ContentLength, strconv.FormatInt(rangeLen, 10))
						if rs != nil {
							contentRange := fmt.Sprintf("bytes %d-%d/%d", start, start+rangeLen-1, ci.Size)

	data, _, err := cache.GetBytes(cache.Default(), key)
	if err == nil && len(data) > len(id) {
		stats := strings.Split(string(data[:len(data)-len(id)]), "\x00")
		if len(stats)%2 != 0 {
			goto Miss
		}
		for i := 0; i+2 <= len(stats); i++ {
			info, err := os.Stat(stats[i])
			if err != nil || statString(info) != stats[i+1] {
				goto Miss
			}
		}
		copy(id[:], data[len(data)-len(id):])
		return id, true

		ts.Config.ConnState = func(c net.Conn, state ConnState) {
			if c == nil {
				t.Errorf("nil conn seen in state %s", state)
				return
			}
			sl := <-activeLog
			if sl.active == nil && state == StateNew {
				sl.active = c
			} else if sl.active != c {
				t.Errorf("unexpected conn in state %s", state)
				activeLog <- sl
				return
			}

)

func (c *conn) setState(nc net.Conn, state ConnState, runHook bool) {
	srv := c.server
	switch state {
	case StateNew:
		srv.trackConn(c, true)
	case StateHijacked, StateClosed:
		srv.trackConn(c, false)
	}
	if state > 0xff || state < 0 {
		panic("internal error")
	}
	packedState := uint64(time.Now().Unix()<<8) | uint64(state)
	c.curState.Store(packedState)
	if !runHook {

			// so that reconciler can clean up volume when needed. However, volume resize failed,
			// we should not mark the volume as mounted to avoid pod starts using it.
			// Considering the above situations, we mark volume as uncertain here so that reconciler will trigger
			// volume tear down when pod is deleted, and also makes sure pod will not start using it.

        if (attr.list().s_size() > 0) {
          auto start = flex_builder->StartVector(key);
          for (const std::string& v : attr.list().s()) {
            flex_builder->Add(v);
          }
          flex_builder->EndVector(start, /*typed=*/true, /*fixed=*/false);
        } else if (attr.list().i_size() > 0) {
          auto start = flex_builder->StartVector(key);

		roots:         []string{startComRoot},
		currentTime:   1302726541,

		// The StartCom root is not trusted by Windows when the default
		// ServerAuth EKU is requested.
		systemSkip: true,

		expectedChains: [][]string{
			{"dnssec-exp", "StartCom Class 1", "StartCom Certification Authority"},
		},
	},
	{
		name:          "dnssec-exp/AnyEKU",
		leaf:          dnssecExpLeaf,

		},
	}, {
		name: "invalid ordinals.start",
		set: mkStatefulSet(&validPodTemplate,
			tweakReplicas(3),
			tweakOrdinalsStart(-2),
		),
		errs: field.ErrorList{
			field.Invalid(field.NewPath("spec", "ordinals.start"), nil, ""),
		},
	},
	}

    /** The key of the message: Started data update process. */
    public static final String SUCCESS_started_data_update = "{success.started_data_update}";

    /** The key of the message: Started reindexing. */
    public static final String SUCCESS_reindex_started = "{success.reindex_started}";

    /** The key of the message: Bulk process is started. */