How to use ShutdownClones method of internal Package

...74type interceptorImplementation interface {75	CreateStdoutStderrClones() (*os.File, *os.File)76	ConnectPipeToStdoutStderr(*os.File)77	RestoreStdoutStderrFromClones(*os.File, *os.File)78	ShutdownClones(*os.File, *os.File)79}80type genericOutputInterceptor struct {81	intercepting bool82	stdoutClone *os.File83	stderrClone *os.File84	pipe        pipePair85	shutdown           chan interface{}86	emergencyBailout   chan interface{}87	pipeChannel        chan pipePair88	interceptedContent chan string89	forwardTo         io.Writer90	accumulatedOutput string91	implementation interceptorImplementation92}93func (interceptor *genericOutputInterceptor) StartInterceptingOutput() {94	interceptor.StartInterceptingOutputAndForwardTo(io.Discard)95}96func (interceptor *genericOutputInterceptor) StartInterceptingOutputAndForwardTo(w io.Writer) {97	if interceptor.intercepting {98		return99	}100	interceptor.accumulatedOutput = ""101	interceptor.forwardTo = w102	interceptor.ResumeIntercepting()103}104func (interceptor *genericOutputInterceptor) StopInterceptingAndReturnOutput() string {105	if interceptor.intercepting {106		interceptor.PauseIntercepting()107	}108	return interceptor.accumulatedOutput109}110func (interceptor *genericOutputInterceptor) ResumeIntercepting() {111	if interceptor.intercepting {112		return113	}114	interceptor.intercepting = true115	if interceptor.stdoutClone == nil {116		interceptor.stdoutClone, interceptor.stderrClone = interceptor.implementation.CreateStdoutStderrClones()117		interceptor.shutdown = make(chan interface{})118		go startPipeFactory(interceptor.pipeChannel, interceptor.shutdown)119	}120	// Now we make a pipe, we'll use this to redirect the input to the 1 and 2 file descriptors (this is how everything else in the world is tring to log to stdout and stderr)121	// we get the pipe from our pipe factory.  it runs in the background so we can request the next pipe while the spec being intercepted is running122	interceptor.pipe = <-interceptor.pipeChannel123	interceptor.emergencyBailout = make(chan interface{})124	//Spin up a goroutine to copy data from the pipe into a buffer, this is how we capture any output the user is emitting125	go func() {126		buffer := &bytes.Buffer{}127		destination := io.MultiWriter(buffer, interceptor.forwardTo)128		copyFinished := make(chan interface{})129		reader := interceptor.pipe.reader130		go func() {131			io.Copy(destination, reader)132			reader.Close() // close the read end of the pipe so we don't leak a file descriptor133			close(copyFinished)134		}()135		select {136		case <-copyFinished:137			interceptor.interceptedContent <- buffer.String()138		case <-interceptor.emergencyBailout:139			interceptor.interceptedContent <- ""140		}141	}()142	interceptor.implementation.ConnectPipeToStdoutStderr(interceptor.pipe.writer)143}144func (interceptor *genericOutputInterceptor) PauseIntercepting() {145	if !interceptor.intercepting {146		return147	}148	// first we have to close the write end of the pipe.  To do this we have to close all file descriptors pointing149	// to the write end.  So that would be the pipewriter itself, and FD #1 and FD #2 if we've Dup2'd them150	interceptor.pipe.writer.Close() // the pipewriter itself151	// we also need to stop intercepting. we do that by reconnecting the stdout and stderr file descriptions back to their respective #1 and #2 file descriptors;152	// this also closes #1 and #2 before it points that their original stdout and stderr file descriptions153	interceptor.implementation.RestoreStdoutStderrFromClones(interceptor.stdoutClone, interceptor.stderrClone)154	var content string155	select {156	case content = <-interceptor.interceptedContent:157	case <-time.After(BAILOUT_TIME):158		/*159			By closing all the pipe writer's file descriptors associated with the pipe writer's file description the io.Copy reading from the reader160			should eventually receive an EOF and exit.161			**However**, if the user has spun up an external process and passed in os.Stdout/os.Stderr to cmd.Stdout/cmd.Stderr then the external process162			will have a file descriptor pointing to the pipe writer's file description and it will not close until the external process exits.163			That would leave us hanging here waiting for the io.Copy to close forever.  Instead we invoke this emergency escape valve.  This returns whatever164			content we've got but leaves the io.Copy running.  This ensures the external process can continue writing without hanging at the cost of leaking a goroutine165			and file descriptor (those these will be cleaned up when the process exits).166			We tack on a message to notify the user that they've hit this edgecase and encourage them to address it.167		*/168		close(interceptor.emergencyBailout)169		content = <-interceptor.interceptedContent + BAILOUT_MESSAGE170	}171	interceptor.accumulatedOutput += content172	interceptor.intercepting = false173}174func (interceptor *genericOutputInterceptor) Shutdown() {175	interceptor.PauseIntercepting()176	if interceptor.stdoutClone != nil {177		close(interceptor.shutdown)178		interceptor.implementation.ShutdownClones(interceptor.stdoutClone, interceptor.stderrClone)179		interceptor.stdoutClone = nil180		interceptor.stderrClone = nil181	}182}183/* This is used on windows builds but included here so it can be explicitly tested on unix systems too */184func NewOSGlobalReassigningOutputInterceptor() OutputInterceptor {185	return &genericOutputInterceptor{186		interceptedContent: make(chan string),187		pipeChannel:        make(chan pipePair),188		shutdown:           make(chan interface{}),189		implementation:     &osGlobalReassigningOutputInterceptorImpl{},190	}191}192type osGlobalReassigningOutputInterceptorImpl struct{}193func (impl *osGlobalReassigningOutputInterceptorImpl) CreateStdoutStderrClones() (*os.File, *os.File) {194	return os.Stdout, os.Stderr195}196func (impl *osGlobalReassigningOutputInterceptorImpl) ConnectPipeToStdoutStderr(pipeWriter *os.File) {197	os.Stdout = pipeWriter198	os.Stderr = pipeWriter199}200func (impl *osGlobalReassigningOutputInterceptorImpl) RestoreStdoutStderrFromClones(stdoutClone *os.File, stderrClone *os.File) {201	os.Stdout = stdoutClone202	os.Stderr = stderrClone203}204func (impl *osGlobalReassigningOutputInterceptorImpl) ShutdownClones(_ *os.File, _ *os.File) {205	//noop206}...

1import (2func main() {3    flag.Parse()4    if flag.NArg() != 2 {5        fmt.Fprintf(os.Stderr, "Usage: %s [options] <vm> <timeout>6        flag.PrintDefaults()7        os.Exit(1)8    }9    ctx := context.Background()10    if err != nil {11        log.Fatal(err)12    }13    u.User = url.UserPassword("user", "pass")14    c, err := govmomi.NewClient(ctx, u, true)15    if err != nil {16        log.Fatal(err)17    }18    defer c.Logout(ctx)19    m := view.NewManager(c.Client)20    v, err := m.CreateContainerView(ctx, c.ServiceContent.RootFolder, []string{"VirtualMachine"}, true)21    if err != nil {22        log.Fatal(err)23    }24    defer v.Destroy(ctx)25    err = v.Retrieve(ctx, []string{"VirtualMachine"}, []string{"summary", "runtime"}, &vms)26    if err != nil {27        log.Fatal(err)28    }29    for _, v := range vms {30        if v.Summary.Config.Name == flag.Arg(0) {31        }32    }33    if vm == nil {34        log.Fatal("vm not found")35    }36    err = c.Properties(ctx, vm.Runtime.Host.Reference(), []string{"configManager"}, &t)37    if err != nil {38        log.Fatal(err)39    }40    err = c.Properties(ctx, t, []string{"configManager"}, &host)41    if err != nil {42        log.Fatal(err)43    }

1import (2func main() {3    session := client.NewSession()4    localProvider := local.NewDefaultApiProvider()5    remoteProvider := rest.NewDefaultApiProvider(session)6    compositeProvider := api_provider.NewCompositeApiProvider()7    compositeProvider.Register(localProvider)8    compositeProvider.Register(remoteProvider)9    client := api_provider.NewDefaultApiClient(compositeProvider)10    request := client.NewRequest("com.vmware.vcenter.vm.hardware.adapter.sata", "list")11    request.SetParam("vm", data.NewString("vm-1"))12    response, err := client.Invoke(request)13    if err != nil {14        fmt.Printf("Error occurred while invoking operation : %v", err)15    }16    fmt.Printf("Response : %s", response)17}

1import (2func main() {3    session := client.NewSession()4    localProvider := local.NewDefaultApiProvider()5    remoteProvider := rest.NewDefaultApiProvider(session)6    compositeProvider := api_provider.NewCompositeApiProvider()7    compositeProvider.Register(localProvider)8    compositeProvider.Register(remoteProvider)9    client := api_provider.NewDefaultApiClient(compositeProvider)10    request := client.NewRequest("com.vmware.vcenter.vm.hardware.adapter.sata", "list")11    request.SetParam("vm", data.NewString("vm-1"))12    response, err := client.Invoke(request)13    if err != nil {14        fmt.Printf("Error occurred while invoking operation : %v", err)15    }16    fmt.Printf("Response : %s", response)17}

1import (2func main() {3    fmt.Println("Hello, World!")4    internal.ShutdownClones()5}6import (7func main() {8    fmt.Println("Hello, World!")9    internal.ShutdownClones()10}11import (12func main() {13    fmt.Println("Hello, World!")14    internal.ShutdownClones()15}16import (17func main() {18    fmt.Println("Hello, World!")19    internal.ShutdownClones()20}21import (22func main() {23    fmtPrintln("Hello, World!")24    internal.ShutdownClones()25}26import (27func main() {28    fmt.Println("Hello, World!")29    internal.ShutdownClones()30}31import (32func main() {33    fmt.Println("Hello, World!")34    internal.ShutdownClones()35}36import (37func main() {38    fmt.Println("Hello, World!")

1import (2func main() {3    a := new(ShutDownClones)4    a.ShutDownClones()5    fmt.Println("ShutdownClones")6}

1func (c *Computer) ShutdownClones() {2type Robot struct {3}4func (r *robot.Robot) ShutdownClones() {5type Robot struct {6}

1import (2func main() {3    a := new(ShutDownClones)4    a.ShutDownClones()5    fmt.Println("ShutdownClones")6}

1import (2type Internal struct {3}4func (i *Internal) ShutdownClones() {5    fmt.Println("ShutdownClones called")6}7func main() {8    i := &Internal{Name: "internal"}9    i.ShutdownClones()10    method := reflect.ValueOf(i).MethodByName("ShutdownClones")11    if method.IsValid() {12        fmt.Println("ShutdownClones is valid")13        method.Call([]reflect.Value{})14    } else {15        fmt.Println("ShutdownClones is not valid")16    }17}

1import (2func main() {3    fmt.Println("Calling ShutdownClones")4    _ = internal.ShutdownClones()5    fmt.Println("Done")6}

1import (2func main() {3	pid := os.Getpid()4	path, _ := os.Getwd()5	process := exec.Command(name, args...)6	process.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}7	process.Start()8	c := make(chan os.Signal)9	signal.Notify(c, os.Interrupt)10	go func() {11		for sig := range c {12			if sig == os.Interrupt {13				ShutdownClones(pid, path)14			}15		}16	}()17	input := make(chan string)18	go func() {19		reader := bufio.NewReader(os.Stdin)20		for {21			text, _ := reader.ReadString('\n')22		}23	}()24	for {25		if strings.TrimSpace(text) == "shutdown" {26			ShutdownClones(pid, path)27		}28	}29}30func ShutdownClones(pid int, path string) {