vendor/github.com/hashicorp/terraform/terraform/hook.go

   1 package terraform
   2
   3 // HookAction is an enum of actions that can be taken as a result of a hook
   4 // callback. This allows you to modify the behavior of Terraform at runtime.
   5 type HookAction byte
   6
   7 const (
   8         // HookActionContinue continues with processing as usual.
   9         HookActionContinue HookAction = iota
  10
  11         // HookActionHalt halts immediately: no more hooks are processed
  12         // and the action that Terraform was about to take is cancelled.
  13         HookActionHalt
  14 )
  15
  16 // Hook is the interface that must be implemented to hook into various
  17 // parts of Terraform, allowing you to inspect or change behavior at runtime.
  18 //
  19 // There are MANY hook points into Terraform. If you only want to implement
  20 // some hook points, but not all (which is the likely case), then embed the
  21 // NilHook into your struct, which implements all of the interface but does
  22 // nothing. Then, override only the functions you want to implement.
  23 type Hook interface {
  24         // PreApply and PostApply are called before and after a single
  25         // resource is applied. The error argument in PostApply is the
  26         // error, if any, that was returned from the provider Apply call itself.
  27         PreApply(*InstanceInfo, *InstanceState, *InstanceDiff) (HookAction, error)
  28         PostApply(*InstanceInfo, *InstanceState, error) (HookAction, error)
  29
  30         // PreDiff and PostDiff are called before and after a single resource
  31         // resource is diffed.
  32         PreDiff(*InstanceInfo, *InstanceState) (HookAction, error)
  33         PostDiff(*InstanceInfo, *InstanceDiff) (HookAction, error)
  34
  35         // Provisioning hooks
  36         //
  37         // All should be self-explanatory. ProvisionOutput is called with
  38         // output sent back by the provisioners. This will be called multiple
  39         // times as output comes in, but each call should represent a line of
  40         // output. The ProvisionOutput method cannot control whether the
  41         // hook continues running.
  42         PreProvisionResource(*InstanceInfo, *InstanceState) (HookAction, error)
  43         PostProvisionResource(*InstanceInfo, *InstanceState) (HookAction, error)
  44         PreProvision(*InstanceInfo, string) (HookAction, error)
  45         PostProvision(*InstanceInfo, string, error) (HookAction, error)
  46         ProvisionOutput(*InstanceInfo, string, string)
  47
  48         // PreRefresh and PostRefresh are called before and after a single
  49         // resource state is refreshed, respectively.
  50         PreRefresh(*InstanceInfo, *InstanceState) (HookAction, error)
  51         PostRefresh(*InstanceInfo, *InstanceState) (HookAction, error)
  52
  53         // PostStateUpdate is called after the state is updated.
  54         PostStateUpdate(*State) (HookAction, error)
  55
  56         // PreImportState and PostImportState are called before and after
  57         // a single resource's state is being improted.
  58         PreImportState(*InstanceInfo, string) (HookAction, error)
  59         PostImportState(*InstanceInfo, []*InstanceState) (HookAction, error)
  60 }
  61
  62 // NilHook is a Hook implementation that does nothing. It exists only to
  63 // simplify implementing hooks. You can embed this into your Hook implementation
  64 // and only implement the functions you are interested in.
  65 type NilHook struct{}
  66
  67 func (*NilHook) PreApply(*InstanceInfo, *InstanceState, *InstanceDiff) (HookAction, error) {
  68         return HookActionContinue, nil
  69 }
  70
  71 func (*NilHook) PostApply(*InstanceInfo, *InstanceState, error) (HookAction, error) {
  72         return HookActionContinue, nil
  73 }
  74
  75 func (*NilHook) PreDiff(*InstanceInfo, *InstanceState) (HookAction, error) {
  76         return HookActionContinue, nil
  77 }
  78
  79 func (*NilHook) PostDiff(*InstanceInfo, *InstanceDiff) (HookAction, error) {
  80         return HookActionContinue, nil
  81 }
  82
  83 func (*NilHook) PreProvisionResource(*InstanceInfo, *InstanceState) (HookAction, error) {
  84         return HookActionContinue, nil
  85 }
  86
  87 func (*NilHook) PostProvisionResource(*InstanceInfo, *InstanceState) (HookAction, error) {
  88         return HookActionContinue, nil
  89 }
  90
  91 func (*NilHook) PreProvision(*InstanceInfo, string) (HookAction, error) {
  92         return HookActionContinue, nil
  93 }
  94
  95 func (*NilHook) PostProvision(*InstanceInfo, string, error) (HookAction, error) {
  96         return HookActionContinue, nil
  97 }
  98
  99 func (*NilHook) ProvisionOutput(
 100         *InstanceInfo, string, string) {
 101 }
 102
 103 func (*NilHook) PreRefresh(*InstanceInfo, *InstanceState) (HookAction, error) {
 104         return HookActionContinue, nil
 105 }
 106
 107 func (*NilHook) PostRefresh(*InstanceInfo, *InstanceState) (HookAction, error) {
 108         return HookActionContinue, nil
 109 }
 110
 111 func (*NilHook) PreImportState(*InstanceInfo, string) (HookAction, error) {
 112         return HookActionContinue, nil
 113 }
 114
 115 func (*NilHook) PostImportState(*InstanceInfo, []*InstanceState) (HookAction, error) {
 116         return HookActionContinue, nil
 117 }
 118
 119 func (*NilHook) PostStateUpdate(*State) (HookAction, error) {
 120         return HookActionContinue, nil
 121 }
 122
 123 // handleHook turns hook actions into panics. This lets you use the
 124 // panic/recover mechanism in Go as a flow control mechanism for hook
 125 // actions.
 126 func handleHook(a HookAction, err error) {
 127         if err != nil {
 128                 // TODO: handle errors
 129         }
 130
 131         switch a {
 132         case HookActionContinue:
 133                 return
 134         case HookActionHalt:
 135                 panic(HookActionHalt)
 136         }
 137 }