github.com/TIBCOSoftware/flogo-lib@v0.5.9/app/instances.go (about)

     1  package app
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/TIBCOSoftware/flogo-lib/app/resource"
     7  	"github.com/TIBCOSoftware/flogo-lib/core/action"
     8  	"github.com/TIBCOSoftware/flogo-lib/core/trigger"
     9  )
    10  
    11  func CreateSharedActions(actionConfigs []*action.Config) (map[string]action.Action, error) {
    12  
    13  	actions := make(map[string]action.Action)
    14  
    15  	for _, config := range actionConfigs {
    16  		actionFactory := action.GetFactory(config.Ref)
    17  		if actionFactory == nil {
    18  			return nil, fmt.Errorf("Action Factory '%s' not registered", config.Ref)
    19  		}
    20  
    21  		act, err := actionFactory.New(config)
    22  		if err != nil {
    23  			return nil, err
    24  		}
    25  
    26  		actions[config.Id] = act
    27  	}
    28  
    29  	return actions, nil
    30  }
    31  
    32  func CreateTriggers(tConfigs []*trigger.Config, actions map[string]action.Action, runner action.Runner) (map[string]trigger.Trigger, error) {
    33  
    34  	triggers := make(map[string]trigger.Trigger)
    35  	for _, tConfig := range tConfigs {
    36  
    37  		_, exists := triggers[tConfig.Id]
    38  		if exists {
    39  			return nil, fmt.Errorf("Trigger with id '%s' already registered, trigger ids have to be unique", tConfig.Id)
    40  		}
    41  
    42  		triggerFactory := trigger.GetFactory(tConfig.Ref)
    43  
    44  		if triggerFactory == nil {
    45  			return nil, fmt.Errorf("Trigger Factory '%s' not registered", tConfig.Ref)
    46  		}
    47  
    48  		trg := triggerFactory.New(tConfig)
    49  
    50  		if trg == nil {
    51  			return nil, fmt.Errorf("cannot create Trigger nil for id '%s'", tConfig.Id)
    52  		}
    53  
    54  		tConfig.FixUp(trg.Metadata())
    55  
    56  		initCtx := &initContext{handlers: make([]*trigger.Handler, 0, len(tConfig.Handlers))}
    57  
    58  		var legacyRunner *trigger.LegacyRunner
    59  
    60  		newTrg, isNew := trg.(trigger.Initializable)
    61  
    62  		if !isNew {
    63  			legacyRunner = trigger.NewLegacyRunner(runner, trg.Metadata())
    64  		}
    65  
    66  		//create handlers for that trigger and init
    67  		for _, hConfig := range tConfig.Handlers {
    68  
    69  			var act action.Action
    70  			var err error
    71  
    72  			//use action if already associated with Handler
    73  			if hConfig.Action.Act != nil {
    74  				act = hConfig.Action.Act
    75  			} else {
    76  
    77  				if hConfig.Action.Id != "" {
    78  
    79  					act, exists = actions[hConfig.Action.Id]
    80  					if act == nil {
    81  						return nil, fmt.Errorf("Shared Action '%s' does not exists", hConfig.Action.Id)
    82  					}
    83  
    84  				} else {
    85  					//create the action
    86  					actionFactory := action.GetFactory(hConfig.Action.Ref)
    87  					if actionFactory == nil {
    88  						return nil, fmt.Errorf("Action Factory '%s' not registered", hConfig.Action.Ref)
    89  					}
    90  
    91  					act, err = actionFactory.New(hConfig.Action.Config)
    92  					if err != nil {
    93  						return nil, err
    94  					}
    95  				}
    96  			}
    97  
    98  			handler := trigger.NewHandler(hConfig, act, trg.Metadata().Output, trg.Metadata().Reply, runner)
    99  			initCtx.handlers = append(initCtx.handlers, handler)
   100  
   101  			if !isNew {
   102  				action.Register(hConfig.ActionId, act)
   103  				legacyRunner.RegisterHandler(handler)
   104  			}
   105  		}
   106  
   107  		if isNew {
   108  			err := newTrg.Initialize(initCtx)
   109  			if err != nil {
   110  				return nil, err
   111  			}
   112  		} else {
   113  			oldTrg, isOld := trg.(trigger.InitOld)
   114  			if isOld {
   115  				oldTrg.Init(legacyRunner)
   116  			}
   117  		}
   118  
   119  		triggers[tConfig.Id] = trg
   120  	}
   121  
   122  	return triggers, nil
   123  }
   124  
   125  func RegisterResources(rConfigs []*resource.Config) error {
   126  
   127  	if len(rConfigs) == 0 {
   128  		return nil
   129  	}
   130  
   131  	for _, rConfig := range rConfigs {
   132  		err := resource.Load(rConfig)
   133  		if err != nil {
   134  			return err
   135  		}
   136  
   137  	}
   138  
   139  	return nil
   140  }
   141  
   142  type initContext struct {
   143  	handlers []*trigger.Handler
   144  }
   145  
   146  func (ctx *initContext) GetHandlers() []*trigger.Handler {
   147  	return ctx.handlers
   148  }