github.com/chenbh/concourse/v6@v6.4.2/fly/commands/check_resource_type.go (about)

     1  package commands
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"strconv"
     7  	"time"
     8  
     9  	"github.com/chenbh/concourse/v6/atc"
    10  	"github.com/chenbh/concourse/v6/fly/commands/internal/flaghelpers"
    11  	"github.com/chenbh/concourse/v6/fly/rc"
    12  	"github.com/chenbh/concourse/v6/fly/ui"
    13  	"github.com/fatih/color"
    14  )
    15  
    16  type CheckResourceTypeCommand struct {
    17  	ResourceType flaghelpers.ResourceFlag `short:"r" long:"resource-type" required:"true" value-name:"PIPELINE/RESOURCE-TYPE" description:"Name of a resource-type to check"`
    18  	Version      *atc.Version             `short:"f" long:"from"                     value-name:"VERSION"           description:"Version of the resource type to check from, e.g. digest:sha256@..."`
    19  	Async        bool                     `short:"a" long:"async"                    value-name:"ASYNC"             description:"Return the check without waiting for its result"`
    20  	Shallow      bool                     `long:"shallow"                          value-name:"SHALLOW"         description:"Check the resource type itself only"`
    21  }
    22  
    23  func (command *CheckResourceTypeCommand) Execute(args []string) error {
    24  
    25  	target, err := rc.LoadTarget(Fly.Target, Fly.Verbose)
    26  	if err != nil {
    27  		return err
    28  	}
    29  
    30  	err = target.Validate()
    31  	if err != nil {
    32  		return err
    33  	}
    34  
    35  	var version atc.Version
    36  	if command.Version != nil {
    37  		version = *command.Version
    38  	}
    39  
    40  	if !command.Shallow {
    41  		err = command.checkParent(target)
    42  		if err != nil {
    43  			return err
    44  		}
    45  	}
    46  
    47  	check, found, err := target.Team().CheckResourceType(command.ResourceType.PipelineName, command.ResourceType.ResourceName, version)
    48  	if err != nil {
    49  		return err
    50  	}
    51  
    52  	if !found {
    53  		return fmt.Errorf("pipeline '%s' or resource-type '%s' not found\n", command.ResourceType.PipelineName, command.ResourceType.ResourceName)
    54  	}
    55  
    56  	var checkID = strconv.Itoa(check.ID)
    57  
    58  	if !command.Async {
    59  		for check.Status == "started" {
    60  			time.Sleep(time.Second)
    61  
    62  			check, found, err = target.Client().Check(checkID)
    63  			if err != nil {
    64  				return err
    65  			}
    66  
    67  			if !found {
    68  				return fmt.Errorf("check '%s' not found\n", checkID)
    69  			}
    70  		}
    71  	}
    72  
    73  	table := ui.Table{
    74  		Headers: ui.TableRow{
    75  			{Contents: "id", Color: color.New(color.Bold)},
    76  			{Contents: "name", Color: color.New(color.Bold)},
    77  			{Contents: "status", Color: color.New(color.Bold)},
    78  			{Contents: "check_error", Color: color.New(color.Bold)},
    79  		},
    80  	}
    81  
    82  	table.Data = append(table.Data, []ui.TableCell{
    83  		{Contents: checkID},
    84  		{Contents: command.ResourceType.ResourceName},
    85  		{Contents: check.Status},
    86  		{Contents: check.CheckError},
    87  	})
    88  
    89  	if err = table.Render(os.Stdout, Fly.PrintTableHeaders); err != nil {
    90  		return err
    91  	}
    92  
    93  	if check.Status == "errored" {
    94  		os.Exit(1)
    95  	}
    96  
    97  	return nil
    98  }
    99  
   100  func (command *CheckResourceTypeCommand) checkParent(target rc.Target) error {
   101  	resourceTypes, found, err := target.Team().VersionedResourceTypes(command.ResourceType.PipelineName)
   102  	if err != nil {
   103  		return err
   104  	}
   105  
   106  	if !found {
   107  		return fmt.Errorf("pipeline '%s' not found\n", command.ResourceType.PipelineName)
   108  	}
   109  
   110  	resourceType, found := resourceTypes.Lookup(command.ResourceType.ResourceName)
   111  	if !found {
   112  		return fmt.Errorf("resource type '%s' not found\n", command.ResourceType.ResourceName)
   113  	}
   114  
   115  	parentType, found := command.findParent(resourceType.ResourceType, resourceTypes)
   116  	if !found {
   117  		return nil
   118  	}
   119  
   120  	cmd := &CheckResourceTypeCommand{
   121  		ResourceType: flaghelpers.ResourceFlag{
   122  			ResourceName: parentType.Name,
   123  			PipelineName: command.ResourceType.PipelineName,
   124  		},
   125  	}
   126  
   127  	return cmd.Execute(nil)
   128  }
   129  
   130  func (command *CheckResourceTypeCommand) findParent(resourceType atc.ResourceType, resourceTypes atc.VersionedResourceTypes) (atc.VersionedResourceType, bool) {
   131  	for _, t := range resourceTypes {
   132  		if t.Name != resourceType.Name && t.Name == resourceType.Type {
   133  			return t, true
   134  		}
   135  	}
   136  	return atc.VersionedResourceType{}, false
   137  }