local service_port
  service_port=$($kubectl get service --namespace kube-system $service \
    -o jsonpath='{.spec.ports[?(@.protocol=="TCP")].port}')
  echo "curl-ing $service address from Linux pod: $service_ip:$service_port"

  # curl-ing the metrics-server service downloads 14 bytes of unprintable binary
  # data and sets a return code of success (0).
  if ! $kubectl exec "$linux_command_pod" -- \

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// As of "Mon 6 Nov 2017", run.go doesn't yet have proper
// column matching so instead match the output manually
// by exec-ing

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"strings"
)

func main() {
	f, err := ioutil.TempFile("", "issue21317.go")
	if err != nil {
		log.Fatal(err)

	}

	if obj.Spec.Type == v1.ServiceTypeLoadBalancer {
		if utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) {
			ipMode := v1.LoadBalancerIPModeVIP

			for i, ing := range obj.Status.LoadBalancer.Ingress {
				if ing.IP != "" && ing.IPMode == nil {
					obj.Status.LoadBalancer.Ingress[i].IPMode = &ipMode
				}
			}
		}
	}

}
func SetDefaults_Pod(obj *v1.Pod) {

				if g := r.Scope.Goroutine(); g != NoGoroutine {
					inGC[g] = true
				}
			}
		case EventRangeEnd:
			r := ev.Range()
			if handleSTW(r) {
				stw--
			} else if handleSweep(r) {
				ps[ev.Proc()].gc--
			} else if handleMarkAssist(r) {
				ps[ev.Proc()].gc--
				if g := r.Scope.Goroutine(); g != NoGoroutine {
					delete(inGC, g)
				}
			}
		case EventStateTransition:

The benefit of raising an exception over `return`ing a value will be more evident in the section about Dependencies and Security.

In this example, when the client requests an item by an ID that doesn't exist, raise an exception with a status code of `404`:

```Python hl_lines="11"

		Body:   io.NopCloser(strings.NewReader(postData)),
	}

	initialFormItems := map[string]string{
		"language": "Go",
		"name":     "gopher",
		"skill":    "go-ing",
		"field2":   "initial-value2",
	}

	req.Form = make(url.Values)
	for k, v := range initialFormItems {
		req.Form.Add(k, v)
	}

	err := req.ParseMultipartForm(10000)
	if err != nil {

        run 'consumer'
        then:
        executedAndNotSkipped(":producer", ":consumer")
    }

    @Issue("https://github.com/gradle/gradle/issues/16775")
    def "orElse does not cause error when map-ing a task property"() {
        buildFile """
            abstract class Producer extends DefaultTask {
                @OutputDirectory
                abstract DirectoryProperty getOutput()

                @TaskAction

      Value z_plus_index_plus_one =
          rewriter.create<AddV2Op>(loc, z_plus_index, one);
      Value incr = rewriter.create<DivOp>(loc, lanczos_coefficient,
                                          z_plus_index_plus_one);
      x = rewriter.create<AddV2Op>(loc, x, incr);
    }

    // To improve accuracy on platforms with less-precise log implementations,

	_Gcopystack // 8

	// _Gpreempted means this goroutine stopped itself for a
	// suspendG preemption. It is like _Gwaiting, but nothing is
	// yet responsible for ready()ing it. Some suspendG must CAS
	// the status to _Gwaiting to take responsibility for
	// ready()ing this G.
	_Gpreempted // 9

	// _Gscan combined with one of the above states other than
	// _Grunning indicates that GC is scanning the stack. The

	if forgetErr := sched.Cache.ForgetPod(logger, assumedPod); forgetErr != nil {
		logger.Error(forgetErr, "scheduler cache ForgetPod failed")
	} else {
		// "Forget"ing an assumed Pod in binding cycle should be treated as a PodDelete event,
		// as the assumed Pod had occupied a certain amount of resources in scheduler cache.
		//