rule$1.java

package org.graylog.plugins.pipelineprocessor.$dynamic.rules;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import org.graylog.plugins.pipelineprocessor.EvaluationContext;
import org.graylog.plugins.pipelineprocessor.ast.functions.FunctionArgs;
import org.graylog.plugins.pipelineprocessor.codegen.GeneratedRule;
import org.graylog.plugins.pipelineprocessor.functions.conversion.StringConversion;
import org.graylog.plugins.pipelineprocessor.functions.messages.HasField;
import org.graylog.plugins.pipelineprocessor.functions.messages.SetFields;
import org.graylog.plugins.pipelineprocessor.functions.strings.RegexMatch;
import org.graylog.plugins.pipelineprocessor.parser.FunctionRegistry;
import org.graylog2.plugin.Message;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.regex.Pattern;

@SuppressWarnings("unchecked")
public final class rule$1 implements GeneratedRule {
  private Func$to_string$args func$to_string$im$1;

  private Func$to_string$args func$to_string$im$4;

  private Func$regex$args func$regex$im$6;

  private Func$has_field$args func$has_field$im$9;

  private Func$set_fields$args func$set_fields$im$13;

  private final StringConversion func$to_string;

  private final RegexMatch func$regex;

  private final SetFields func$set_fields;

  private final HasField func$has_field;

  private String var$string;

  private Long var$number;

  private final List arrayLiteral$im$11;

  private final Map mapLiteral$im$10;

  private Map var$fields;

  private List var$ary;

  public rule$1(FunctionRegistry functionRegistry) {
    // resolve used functions;
    func$set_fields = (SetFields) functionRegistry.resolve("set_fields");
    func$regex = (RegexMatch) functionRegistry.resolve("regex");
    func$to_string = (StringConversion) functionRegistry.resolve("to_string");
    func$has_field = (HasField) functionRegistry.resolve("has_field");
    // function parameters;
    func$to_string$im$1 = new Func$to_string$args();
    func$to_string$im$4 = new Func$to_string$args();
    func$regex$im$6 = new Func$regex$args();
    func$has_field$im$9 = new Func$has_field$args();
    func$set_fields$im$13 = new Func$set_fields$args();
    // constant expressions;
    func$regex$im$6.setAndTransform$pattern("#\\d+");
    func$has_field$im$9.setAndTransform$field("something_that_doesnt_exist");
    var$number = 1L;
    var$string = "sadfasdf";
    mapLiteral$im$10 = Maps.newHashMap();
    mapLiteral$im$10.put("something with spaces", "some expression");
    mapLiteral$im$10.put("some_identifier", 1);
    var$fields = mapLiteral$im$10;
    arrayLiteral$im$11 = Lists.newArrayList(1, 3, 4, 5, "object", var$string);
    var$ary = arrayLiteral$im$11;
    func$set_fields$im$13.setAndTransform$fields(var$fields);
  }

  @Override
  public String name() {
    return "grok jenkins extraction";
  }

  @Override
  public boolean when(final EvaluationContext context) {
    func$to_string$im$1.setAndTransform$value(context.currentMessage().getField("source"));
    String im$0 = func$to_string.evaluate(func$to_string$im$1, context);
    boolean im$2 = Objects.equals(im$0, "jenkins.torch.sh");
    func$to_string$im$4.setAndTransform$value(context.currentMessage().getField("message"));
    String im$3 = func$to_string.evaluate(func$to_string$im$4, context);
    func$regex$im$6.setAndTransform$value(im$3);
    RegexMatch.RegexMatchResult im$5 = func$regex.evaluate(func$regex$im$6, context);
    boolean im$7 = Objects.equals(im$5.isMatches(), true);
    Boolean im$8 = func$has_field.evaluate(func$has_field$im$9, context);
    return (im$2 && (im$7 || !im$8));
  }

  @Override
  public void then(final EvaluationContext context) {
    func$set_fields.evaluate(func$set_fields$im$13, context);
  }

  private class Func$set_fields$args extends FunctionArgs {
    private final Function<Map, Map> transformer$fields;

    Map transformed$fields;

    private final Function<String, String> transformer$prefix;

    String transformed$prefix;

    private final Function<String, String> transformer$suffix;

    String transformed$suffix;

    private final Function<Message, Message> transformer$message;

    Message transformed$message;

    Func$set_fields$args() {
      super(func$set_fields, Collections.emptyMap());
      transformer$fields = (Function<Map, Map>) func$set_fields.descriptor().param("fields").transform();
      transformer$prefix = (Function<String, String>) func$set_fields.descriptor().param("prefix").transform();
      transformer$suffix = (Function<String, String>) func$set_fields.descriptor().param("suffix").transform();
      transformer$message = (Function<Message, Message>) func$set_fields.descriptor().param("message").transform();
    }

    void setAndTransform$fields(Map arg$fields) {
      transformed$fields = transformer$fields.apply(arg$fields);
    }

    void setAndTransform$prefix(String arg$prefix) {
      transformed$prefix = transformer$prefix.apply(arg$prefix);
    }

    void setAndTransform$suffix(String arg$suffix) {
      transformed$suffix = transformer$suffix.apply(arg$suffix);
    }

    void setAndTransform$message(Message arg$message) {
      transformed$message = transformer$message.apply(arg$message);
    }

    @Override
    public Object getPreComputedValue(String name) {
      switch (name) {
        case "fields": {
          return transformed$fields;
        }
        case "prefix": {
          return transformed$prefix;
        }
        case "suffix": {
          return transformed$suffix;
        }
        case "message": {
          return transformed$message;
        }
      }
      return null;
    }
  }

  private class Func$has_field$args extends FunctionArgs {
    private final Function<String, String> transformer$field;

    String transformed$field;

    private final Function<Message, Message> transformer$message;

    Message transformed$message;

    Func$has_field$args() {
      super(func$has_field, Collections.emptyMap());
      transformer$field = (Function<String, String>) func$has_field.descriptor().param("field").transform();
      transformer$message = (Function<Message, Message>) func$has_field.descriptor().param("message").transform();
    }

    void setAndTransform$field(String arg$field) {
      transformed$field = transformer$field.apply(arg$field);
    }

    void setAndTransform$message(Message arg$message) {
      transformed$message = transformer$message.apply(arg$message);
    }

    @Override
    public Object getPreComputedValue(String name) {
      switch (name) {
        case "field": {
          return transformed$field;
        }
        case "message": {
          return transformed$message;
        }
      }
      return null;
    }
  }

  private class Func$regex$args extends FunctionArgs {
    private final Function<String, Pattern> transformer$pattern;

    Pattern transformed$pattern;

    private final Function<String, String> transformer$value;

    String transformed$value;

    private final Function<List, List> transformer$group_names;

    List transformed$group_names;

    Func$regex$args() {
      super(func$regex, Collections.emptyMap());
      transformer$pattern = (Function<String, Pattern>) func$regex.descriptor().param("pattern").transform();
      transformer$value = (Function<String, String>) func$regex.descriptor().param("value").transform();
      transformer$group_names = (Function<List, List>) func$regex.descriptor().param("group_names").transform();
    }

    void setAndTransform$pattern(String arg$pattern) {
      transformed$pattern = transformer$pattern.apply(arg$pattern);
    }

    void setAndTransform$value(String arg$value) {
      transformed$value = transformer$value.apply(arg$value);
    }

    void setAndTransform$group_names(List arg$group_names) {
      transformed$group_names = transformer$group_names.apply(arg$group_names);
    }

    @Override
    public Object getPreComputedValue(String name) {
      switch (name) {
        case "pattern": {
          return transformed$pattern;
        }
        case "value": {
          return transformed$value;
        }
        case "group_names": {
          return transformed$group_names;
        }
      }
      return null;
    }
  }

  private class Func$to_string$args extends FunctionArgs {
    private final Function<Object, Object> transformer$value;

    Object transformed$value;

    private final Function<String, String> transformer$default;

    String transformed$default;

    Func$to_string$args() {
      super(func$to_string, Collections.emptyMap());
      transformer$value = (Function<Object, Object>) func$to_string.descriptor().param("value").transform();
      transformer$default = (Function<String, String>) func$to_string.descriptor().param("default").transform();
    }

    void setAndTransform$value(Object arg$value) {
      transformed$value = transformer$value.apply(arg$value);
    }

    void setAndTransform$default(String arg$default) {
      transformed$default = transformer$default.apply(arg$default);
    }

    @Override
    public Object getPreComputedValue(String name) {
      switch (name) {
        case "value": {
          return transformed$value;
        }
        case "default": {
          return transformed$default;
        }
      }
      return null;
    }
  }
}