github.com/rothwerx/packer@v0.9.0/post-processor/vagrant-cloud/step_verify_upload.go (about)

     1  package vagrantcloud
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/mitchellh/multistep"
     6  	"github.com/mitchellh/packer/packer"
     7  	"log"
     8  	"time"
     9  )
    10  
    11  type stepVerifyUpload struct {
    12  }
    13  
    14  func (s *stepVerifyUpload) Run(state multistep.StateBag) multistep.StepAction {
    15  	client := state.Get("client").(*VagrantCloudClient)
    16  	ui := state.Get("ui").(packer.Ui)
    17  	box := state.Get("box").(*Box)
    18  	version := state.Get("version").(*Version)
    19  	upload := state.Get("upload").(*Upload)
    20  	provider := state.Get("provider").(*Provider)
    21  
    22  	path := fmt.Sprintf("box/%s/version/%v/provider/%s", box.Tag, version.Version, provider.Name)
    23  
    24  	providerCheck := &Provider{}
    25  
    26  	ui.Say(fmt.Sprintf("Verifying provider upload: %s", provider.Name))
    27  
    28  	done := make(chan struct{})
    29  	defer close(done)
    30  
    31  	result := make(chan error, 1)
    32  
    33  	go func() {
    34  		attempts := 0
    35  		for {
    36  			attempts += 1
    37  
    38  			log.Printf("Checking token match for provider.. (attempt: %d)", attempts)
    39  
    40  			resp, err := client.Get(path)
    41  
    42  			if err != nil || (resp.StatusCode != 200) {
    43  				cloudErrors := &VagrantCloudErrors{}
    44  				err = decodeBody(resp, cloudErrors)
    45  				err = fmt.Errorf("Error retrieving provider: %s", cloudErrors.FormatErrors())
    46  				result <- err
    47  				return
    48  			}
    49  
    50  			if err = decodeBody(resp, providerCheck); err != nil {
    51  				err = fmt.Errorf("Error parsing provider response: %s", err)
    52  				result <- err
    53  				return
    54  			}
    55  
    56  			if err != nil {
    57  				result <- err
    58  				return
    59  			}
    60  
    61  			if upload.Token == providerCheck.HostedToken {
    62  				// success!
    63  				result <- nil
    64  				return
    65  			}
    66  
    67  			// Wait 3 seconds in between
    68  			time.Sleep(3 * time.Second)
    69  
    70  			// Verify we shouldn't exit
    71  			select {
    72  			case <-done:
    73  				// We finished, so just exit the goroutine
    74  				return
    75  			default:
    76  				// Keep going
    77  			}
    78  		}
    79  	}()
    80  
    81  	ui.Message("Waiting for upload token match")
    82  	log.Printf("Waiting for up to 600 seconds for provider hosted token to match %s", upload.Token)
    83  
    84  	select {
    85  	case err := <-result:
    86  		if err != nil {
    87  			state.Put("error", err)
    88  			return multistep.ActionHalt
    89  		}
    90  
    91  		ui.Message(fmt.Sprintf("Upload succesfully verified with token %s", providerCheck.HostedToken))
    92  		log.Printf("Box succesfully verified %s == %s", upload.Token, providerCheck.HostedToken)
    93  
    94  		return multistep.ActionContinue
    95  	case <-time.After(600 * time.Second):
    96  		state.Put("error", fmt.Errorf("Timeout while waiting to for upload to verify token '%s'", upload.Token))
    97  		return multistep.ActionHalt
    98  	}
    99  }
   100  
   101  func (s *stepVerifyUpload) Cleanup(state multistep.StateBag) {
   102  	// No cleanup
   103  }