github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/fly/commands/check_resource.go (about)

     1  package commands
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"strconv"
     7  
     8  	"github.com/pf-qiu/concourse/v6/atc"
     9  	"github.com/pf-qiu/concourse/v6/fly/commands/internal/flaghelpers"
    10  	"github.com/pf-qiu/concourse/v6/fly/eventstream"
    11  	"github.com/pf-qiu/concourse/v6/fly/rc"
    12  	"github.com/pf-qiu/concourse/v6/fly/ui"
    13  )
    14  
    15  type CheckResourceCommand struct {
    16  	Resource flaghelpers.ResourceFlag `short:"r" long:"resource" required:"true" value-name:"PIPELINE/RESOURCE" description:"Name of a resource to check version for"`
    17  	Version  *atc.Version             `short:"f" long:"from"                     value-name:"VERSION"           description:"Version of the resource to check from, e.g. ref:abcd or path:thing-1.2.3.tgz"`
    18  	Async    bool                     `short:"a" long:"async"                    value-name:"ASYNC"             description:"Return the check without waiting for its result"`
    19  	Shallow  bool                     `long:"shallow"                          value-name:"SHALLOW"         description:"Check the resource itself only"`
    20  }
    21  
    22  func (command *CheckResourceCommand) Execute(args []string) error {
    23  	target, err := rc.LoadTarget(Fly.Target, Fly.Verbose)
    24  	if err != nil {
    25  		return err
    26  	}
    27  
    28  	err = target.Validate()
    29  	if err != nil {
    30  		return err
    31  	}
    32  
    33  	var version atc.Version
    34  	if command.Version != nil {
    35  		version = *command.Version
    36  	}
    37  
    38  	if !command.Shallow {
    39  		err = command.checkParent(target)
    40  		if err != nil {
    41  			return err
    42  		}
    43  	}
    44  
    45  	build, found, err := target.Team().CheckResource(command.Resource.PipelineRef, command.Resource.ResourceName, version)
    46  	if err != nil {
    47  		return err
    48  	}
    49  
    50  	if !found {
    51  		return fmt.Errorf("pipeline '%s' or resource '%s' not found\n", command.Resource.PipelineRef.String(), command.Resource.ResourceName)
    52  	}
    53  
    54  	fmt.Printf("checking %s in build %d\n", ui.Embolden(command.Resource.String()), build.ID)
    55  
    56  	if command.Async {
    57  		return nil
    58  	}
    59  
    60  	eventSource, err := target.Client().BuildEvents(strconv.Itoa(build.ID))
    61  	if err != nil {
    62  		return err
    63  	}
    64  
    65  	renderOptions := eventstream.RenderOptions{}
    66  
    67  	exitCode := eventstream.Render(os.Stdout, eventSource, renderOptions)
    68  	eventSource.Close()
    69  
    70  	if exitCode != 0 {
    71  		os.Exit(exitCode)
    72  	}
    73  
    74  	return nil
    75  }
    76  
    77  func (command *CheckResourceCommand) checkParent(target rc.Target) error {
    78  	resource, found, err := target.Team().Resource(command.Resource.PipelineRef, command.Resource.ResourceName)
    79  	if err != nil {
    80  		return err
    81  	}
    82  
    83  	if !found {
    84  		return fmt.Errorf("resource '%s' not found\n", command.Resource.ResourceName)
    85  	}
    86  
    87  	resourceTypes, found, err := target.Team().VersionedResourceTypes(command.Resource.PipelineRef)
    88  	if err != nil {
    89  		return err
    90  	}
    91  
    92  	if !found {
    93  		return fmt.Errorf("pipeline '%s' not found\n", command.Resource.PipelineRef.String())
    94  	}
    95  
    96  	parentType, found := command.findParent(resource, resourceTypes)
    97  	if !found {
    98  		return nil
    99  	}
   100  
   101  	cmd := &CheckResourceTypeCommand{
   102  		ResourceType: flaghelpers.ResourceFlag{
   103  			ResourceName: parentType.Name,
   104  			PipelineRef:  command.Resource.PipelineRef,
   105  		},
   106  	}
   107  
   108  	err = cmd.Execute(nil)
   109  	if err != nil {
   110  		return err
   111  	}
   112  
   113  	fmt.Println()
   114  
   115  	return nil
   116  }
   117  
   118  func (command *CheckResourceCommand) findParent(resource atc.Resource, resourceTypes atc.VersionedResourceTypes) (atc.VersionedResourceType, bool) {
   119  	for _, t := range resourceTypes {
   120  		if t.Name != resource.Name && t.Name == resource.Type {
   121  			return t, true
   122  		}
   123  	}
   124  	return atc.VersionedResourceType{}, false
   125  }