// execPipeline executes the sepcified pipeline query.
func execPipeline(context interface{}, db *db.DB, q *query.Query, vars map[string]string, data map[string]interface{}, explain bool) (docs, []map[string]interface{}, error) {
// I am returning commands as the second return value because if there
// is an error I need to send how far we got back to the client. If not,
// the user will not understand the error message.
// We need to check to see if the last command is the extended $save command.
commands := q.Commands
l := len(q.Commands) - 1
// Validate we have scripts to run.
if l < 0 {
return docs{}, commands, errors.New("Invalid pipeline script")
}
// If the last command is a $save, capture its value and remove
// it from the pipeline.
var save map[string]interface{}
if v, exists := q.Commands[l]["$save"]; exists {
if cmd, ok := v.(map[string]interface{}); ok {
save = cmd
}
commands = q.Commands[0:l]
}
var agg string
var pipeline []bson.M
// Iterate over the commands and build the pipeline.
for _, command := range commands {
// Do we have variables to be substitued.
if vars != nil {
if err := ProcessVariables(context, command, vars, data); err != nil {
return docs{}, commands, err
}
}
// Add the operation to the slice for the pipeline.
pipeline = append(pipeline, command)
// Build a logable version of this pipeline.
agg += mongo.Query(command) + ",\n"
}
// Are we being asked to execute the query on a view.
if q.Collection == "view" {
// Materialize the view for the query.
viewCol, err := materializeView(context, db, q, vars)
if err != nil {
return docs{}, commands, err
}
// Defer clean up of the temporary collection.
defer cleanupView(context, db, viewCol)
}
// Do we want the explain output.
if explain {
// Build the pipeline function for the execution for explain.
var m bson.M
f := func(c *mgo.Collection) error {
log.Dev(context, "executePipeline", "MGO Explain :\ndb.%s.aggregate([\n%s])", c.Name, agg)
return c.Pipe(pipeline).Explain(&m)
}
// Execute the pipeline.
if err := db.ExecuteMGO(context, q.Collection, f); err != nil {
return docs{}, commands, err
}
return docs{q.Name, []bson.M{m}}, commands, nil
}
// Set the default timeout for the session.
timeout := 25 * time.Second
if q.Timeout != "" {
if d, err := time.ParseDuration(q.Timeout); err != nil {
log.Dev(context, "executePipeline", "WARNING : Unable to Set Timeout[%s], using default.", q.Timeout)
} else {
timeout = d
}
}
log.Dev(context, "executePipeline", "MGO Timeout Set[%s]", timeout)
// Build the pipeline function for the execution.
var results []bson.M
f := func(c *mgo.Collection) error {
log.Dev(context, "executePipeline", "MGO Started\ndb.%s.aggregate([\n%s])", c.Name, agg)
err := c.Pipe(pipeline).All(&results)
return err
}
// Set the channel to one because we might not be around
// waiting for the result on timeouts.
wait := make(chan error, 1)
// Execute the pipeline.
go func() {
defer func() {
if r := recover(); r != nil {
log.Dev(context, "executePipeline", "******> Recovered from timing out")
}
log.Dev(context, "executePipeline", "MGO Response Complete")
}()
wait <- db.ExecuteMGOTimeout(context, timeout, q.Collection, f)
}()
// Did any errors occur.
select {
// Wait for the response from executing the pipeline.
case err := <-wait:
if err != nil {
if _, ok := err.(*net.OpError); ok {
log.Error(context, "executePipeline", err, "Timed out Network")
return docs{}, commands, errors.New("Completed : Timed out executing commands")
}
log.Error(context, "executePipeline", err, "Completed")
return docs{}, commands, err
}
// Wait to timeout the entire operation.
case <-time.After(timeout):
err := errors.New("Timedout executing commands")
log.Error(context, "executePipeline", err, "Completed : Timed out Processing")
return docs{}, commands, err
}
log.Dev(context, "executePipeline", "Completed")
// If there were no results, return an empty array.
if results == nil {
return docs{q.Name, []bson.M{}}, commands, nil
}
// Perform any masking that is required.
if err := processMasks(context, db, q.Collection, results); err != nil {
return docs{}, commands, err
}
// Do we need to save the result.
if save != nil {
if err := saveResult(context, save, results, data); err != nil {
return docs{}, commands, err
}
}
return docs{q.Name, results}, commands, nil
}