func (p *ProcessPlugin) performScriptTask(j *job.Job) (string, error) {
if len(p.args) > 0 {
j.Debugf("Executing `%s` with arguments %#v", p.path, p.args)
} else {
j.Debugf("Executing `%s` with no arguments", p.path)
}
out, err := exec.Command(p.path, p.args...).Output()
return string(out), err
}
func (p *ProcessPlugin) performHTTPTask(j *job.Job) (string, error) {
j.Debugf("Retrieving expression from URL `%s`", p.url)
r, err := http.Get(p.url)
if err != nil {
return "", err
}
defer r.Body.Close()
out, err := ioutil.ReadAll(r.Body)
if r.StatusCode > 399 {
return string(out), gotelemetry.NewErrorWithFormat(r.StatusCode, "HTTP request failed with status %d", nil, r.StatusCode)
}
return string(out), nil
}
func (p *ProcessPlugin) performDataUpdate(j *job.Job, flowTag string, isReplace bool, data map[string]interface{}) {
if config.CLIConfig.DebugMode == true {
// Debug Mode. Print data dump. Do not send API update
jsonOutput, err := json.MarshalIndent(data, "", " ")
if err != nil {
return
}
fmt.Printf("\nPrinting the output results of \"%s\":\n", flowTag)
fmt.Println(string(jsonOutput))
return
}
if isReplace {
if p.expiration > 0 {
newExpiration := time.Now().Add(p.expiration)
newUnixExpiration := newExpiration.Unix()
j.Debugf("Forcing expiration to %d (%s)", newUnixExpiration, newExpiration)
data["expires_at"] = newUnixExpiration
}
j.QueueDataUpdate(flowTag, data, gotelemetry.BatchTypePOST)
} else {
if p.expiration > 0 {
newExpiration := time.Now().Add(p.expiration)
newUnixExpiration := newExpiration.Unix()
j.Debugf("Forcing expiration to %d (%s)", newUnixExpiration, newExpiration)
data["expires_at"] = newUnixExpiration
}
j.QueueDataUpdate(flowTag, data, gotelemetry.BatchTypePATCH)
}
}
func (p *ProcessPlugin) performAllTasks(j *job.Job) {
j.Debugf("Starting process plugin...")
defer p.PluginHelper.TrackTime(j, time.Now(), "Process plugin completed in %s.")
var response string
var err error
if p.path != "" {
response, err = p.performScriptTask(j)
} else if p.templateFile != "" {
response, err = p.performTemplateTask(j)
} else if p.url != "" {
response, err = p.performHTTPTask(j)
} else {
err = errors.New("Nothing to do!")
}
if err != nil {
if p.flowTag != "" {
res := err.Error() + " : " + strings.TrimSpace(string(response))
if res == "" {
res = "No output detected."
}
j.SetFlowError(p.flowTag, map[string]interface{}{"message": res})
}
j.ReportError(err)
return
}
j.Debugf("Process output: %s", strings.Replace(response, "\n", "\\n", -1))
if p.flowTag != "" {
j.Debugf("Posting flow %s", p.flowTag)
}
if err := p.analyzeAndSubmitProcessResponse(j, response); err != nil {
j.ReportError(errors.New("Unable to analyze process output: " + err.Error()))
}
}
func (p *ProcessPlugin) Init(job *job.Job) error {
c := job.Config()
job.Debugf("The configuration is %#v", c)
var ok bool
p.flowTag, ok = c["flow_tag"].(string)
if !ok {
p.flowTag, _ = c["tag"].(string)
}
p.batch, ok = c["batch"].(bool)
if ok && p.flowTag != "" {
return errors.New("You cannot specify both `flow_tag` and `batch` properties.")
}
exec, _ := c["exec"].(string)
script, _ := c["script"].(string)
if exec != "" && script != "" {
return errors.New("You cannot specify both `script` and `exec` properties.")
}
if exec != "" {
p.path = exec
} else if script != "" {
p.path = script
}
p.url, _ = c["url"].(string)
if p.path == "" && p.url == "" {
return errors.New("You must specify a `script`, `exec`, or `url` property.")
}
if p.path != "" && p.url != "" {
return errors.New("You cannot provide both `script` or `exec` and `url` properties.")
}
p.args = []string{}
p.scriptArgs = map[string]interface{}{}
if args, ok := c["args"].([]interface{}); ok {
for _, arg := range args {
if a, ok := arg.(string); ok {
p.args = append(p.args, a)
} else {
p.args = append(p.args, fmt.Sprintf("%#v", arg))
}
}
} else if args, ok := c["args"].(map[interface{}]interface{}); ok {
p.scriptArgs = config.MapTemplate(args).(map[string]interface{})
} else if args, ok := c["args"].(map[string]interface{}); ok {
p.scriptArgs = args
}
if p.path != "" {
if _, err := os.Stat(p.path); os.IsNotExist(err) {
return errors.New("File " + p.path + " does not exist.")
}
if path.Ext(p.path) == ".lua" {
p.url = "tpl://" + p.path
p.path = ""
} else {
if len(p.scriptArgs) != 0 {
return errors.New("You cannot specify an key/value hash of arguments when executing an external process. Provide an array of arguments instead.")
}
}
}
if p.url != "" {
if len(p.args) != 0 {
return errors.New("You cannot specify an array of arguments when executing a template. Provide a key/value hash instead.")
}
if strings.HasPrefix(p.url, "tpl://") {
URL, err := url.Parse(p.url)
if err != nil {
return err
}
p.templateFile = URL.Host + URL.Path
if _, err := os.Stat(p.templateFile); os.IsNotExist(err) {
return errors.New("Template " + p.templateFile + " does not exist.")
}
}
}
template, templateOK := c["template"]
variant, variantOK := c["variant"].(string)
if variantOK && templateOK {
if p.flowTag == "" {
return errors.New("The required `flow_tag` property (`string`) is either missing or of the wrong type.")
}
if f, err := job.GetOrCreateFlow(p.flowTag, variant, template); err != nil {
return err
} else {
p.flow = f
}
}
if interval, ok := c["interval"].(int); ok {
p.expiration = time.Duration(interval*3) * time.Second
p.PluginHelper.AddTaskWithClosure(p.performAllTasks, time.Duration(interval)*time.Second)
} else if interval, ok := c["interval"].(string); ok {
if timeInterval, err := config.ParseTimeInterval(interval); err == nil {
if p.expiration == 0 {
p.expiration = timeInterval * 3.0
}
p.PluginHelper.AddTaskWithClosure(p.performAllTasks, timeInterval)
} else {
return err
}
} else {
p.PluginHelper.AddTaskWithClosure(p.performAllTasks, 0)
}
if p.expiration > 0 && p.expiration < time.Second*60 {
p.expiration = time.Second * 60
}
switch c["expiration"].(type) {
case int:
p.expiration = time.Duration(c["expiration"].(int)) * time.Second
case int64:
p.expiration = time.Duration(c["expiration"].(int64)) * time.Second
case string:
if timeInterval, err := config.ParseTimeInterval(c["expiration"].(string)); err == nil {
p.expiration = timeInterval
} else {
return errors.New("Invalid expiration value. Must be either a number of seconds or a time interval string.")
}
}
if p.expiration < 0 {
return errors.New("Invalid expiration time")
}
if p.expiration > 0 {
job.Debugf("Expiration is set to %dµs", p.expiration)
} else {
job.Debugf("Expiration is off.")
}
return nil
}
