In this final part of the tutorial, I will present how to deploy rules to Guvnor.
As a web application (. War), Guvnor provides much of its functionality as Servlets. Recently, a feature to communicate via REST has been incorporated so we can create, update or delete content from the server. This API is known as REST API, and responds in the URL of / api. For example, create a package, the syntax used is as follows:
/ org.drools.guvnor.Guvnor / api / packages /<package name>. package
Similar to the package creation is the creation of rules, made as follows:
/ org.drools.guvnor.Guvnor / api / packages / <package name> /<rule name>. drl
As these invocations are done via REST, HTTP methods to these URLs are created as follows:
- GET -> reading
- POST -> creation
- PUT -> update
- DELETE -> delete
That is, assuming the previous examples, and in the case of my machine, reading the rule created previously could be done by making a GET to the URL http://localhost:8080/drools-guvnor/org. drools.guvnor.Guvnor / packages / seguradora/ admissaosegurado.drl
If the reader is in doubt as to how to make such a request, below is an example on how to create a rule using Apache Commons HTTP:
/**
* @param drl The rule to be created, that is, the body of the rule itself
* @param drlName The rule name
* @param packageName Guess =)
*/
public static void createDrl (String drl, String drlName, String packageName) throws HttpException, IOException {
String uri = URL_FOR_RULES_CREATION.replace("{0}", packageName).replace("{1}", drlName);
PostMethod post = new PostMethod(uri);
post.setRequestBody(drl);
sendRequest(post);
}
private static void sendRequest (HttpMethod method, String username, String password) throws HttpException, IOException {
HttpClient client = new HttpClient();
client.getState().setCredentials("users", host, new UsernamePasswordCredentials(username, password));
method.setDoAuthentication(true);
client.executeMethod(method);
int statusCode = method.getStatusCode();
String response = method.getResponseBodyAsString();
if (statusCode != 200 || !response.equals("OK")) {
throw new HttpException("Something went wrong with the invocation. Status code: " + statusCode + ". Response: " + response);
}
}
However, here is a sign of a problem with this approach: even the present version of Guvnor, the build and create a package / snapshot can not be done in an automated manner using this approach (so, it prevents the immediate consumption of these rules ). I´m not sure if a can expose my solution to this problem on this blog (due to a number of restrictions). However, if I have any appeal of the community I will be happy to check these constraints and if there are no issues, I may publish it here.
How to dynamically create the rule
Rule creation can be done through a set of classes available in the package org.drools.guvnor.client.modeldriven.brl .* , available in JAR drools-compiler- . Thus the creation of a simple rule can be made as follows:
**
* @param rule Presumably, a POJO that contains data from the the rule to be generated.
*/
public String generateRuleData(Rule rule) {
RuleModel model = new RuleModel();
model.name = rule.getName();
FieldConstraint constraint = evaluate(rule);
FactPattern fact = new FactPattern(NOME_DO_FATO);
fact.boundName = VARIABLE_THAT_REPRESENTS_THE_FACT;
fact.addConstraint(constraint);
model.lhs = new IPattern[]{fact};
model.rhs = getActions(rule);
BRLPersistence persistence = BRDRLPersistence.getInstance();
String ruleData = persistence.marshal(model);
return ruleData;
}
/**
* This method will retrieve a custom model of what will happen inside a rule´s body.
* Remeber that IAction is an interface, so, evaluate the possible implementations.
*/
protected IAction[] getActions(Rule rule) {
//In my case, the method will retrieve a representation of setting a value onto the fact.
ActionSetField actionSetField = new ActionSetField(VARIABLE_THAT_REPRESENTS_THE_FACT);
actionSetField.fieldValues = new ActionFieldValue[] {new ActionFieldValue(
"attribute", "value", "type - String, Integer, etc.")};
return new IAction[]{actionSetField};
}
protected FieldConstraint evaluate (Rule rule) {
/*Must return an implementation of the interface FieldConstraint. The available implementations (so far) are the class SingleFieldConstraint and the class CompositeFieldConstraint, that represent, respectively, a single operation on a fact definition and many operations. For particular reasons, I won´t present here this method implementation, so it´s on the reader. */
return null;
}
Where:
- FactPattern class represents the fact. In the constructor of the same, will the fact that the name will be used. In boundName attribute, you create a variable to perform the assignment.
In the method
- addConstraint are added to the clauses of fact.
In
- attributes rhs and lhs, class RuleModel are added, respectively, the definition of fact and the definition of the consequences.
This method will then return the representation of the rule as String. I won´t go into details here of how to accomplish the definition of fact, as unknown, until now, automated way of creating this in the body’s own rule. Also, since I went into detail about how the syntax for defining the first part of this tutorial, then left to the reader the automated generation ddo fact.
Once the generation is made, just synchronize it with the model presented in the first part of this tutorial and ready, we have the rule generation and creation in Guvnor presented.
solution analysis
Thereby closing the tutorial, step to the critical analysis of the solution (as I hope to do every time I post a tutorial here).
One of the most serious problems with this solution was the fact that you were referred from the party itself, ie the impossibility of creating a snapshot to enable the immediate consumption of the rules. This can cause major problems for those who want immediate solution to the problem (although, as already mentioned, I have the solution to this problem and hope to submit as soon as possible for both the community and for the team responsible for the Guvnor).
Another problem, too, is the creation of a sequence of rules. You can create sequences through the implementation of the rules attribute salience , that can be embedded in the body of rules, and by creating flows rule . However, both mechanisms add problems when it made an automatic creation of new rules, which ultimately makes the scheme impractical.
And finally, citing the problems I cite also the management of these rules is problematic when done by Guvnor, recommended, so some sort of maintaining the route database. This creates a different problem when the use of rules is achieved, because the consumer of the rules is optimized to work with URLs or files, or if consumption of rules is done via the database, it is necessary to create a REST API own (or at least a Servlet that responds by GET method). Moreover, the consumer rules only works with the built package, which can generate an additional problem generation.
That said, it must be noted that the control of an application via API rules is extremely powerful, because besides being a flexible mechanism (from the standpoint of the system operator) is also relatively easy to manage.
Furthermore, a mechanism is also extremely fast (in benchmarks that I made between two different machines and after the creation of consumer rules, the meter accused times between 1 and 10 msec).
Therefore, it is the burden of developers and / or the architect of an application to analyze the cost / benefit of this. Just leave here a reminder that the problems I mentioned occur in development time, and advantages occur with the application already put into production. That is, I believe that the benefits always overwhelm the problems, either from or in any other Drools Rules Engine.
