PRESIDENCIA DE LA NACIÓN
SINDICATURA GENERAL DE LA NACIÓN Resolución 158/
Supporting many ways of grading inside the proposed architecture, which will be discussed in depth later, implies working with some software components arranged differently each time that a call is done. Every component inside the grading process is a program that quantifies a given metric and allows evaluating a criterion. Then, when a grading process is started, an element to control calls to every program is necessary. This new element is the orchestrator.
The orchestrator will work in every grading process, defining which programs to call, the order of calls, calling the programs, giving parameters to the programs, managing dependencies and so on. A review of which tools could work as orchestrator is helpful to avoid the building of a new one if possible. At least some features of a given tool could help to face issues if the building cannot be avoided. Thus, a brief description of some tools is presented:
• Apache Ant11. - It is a Java library that is used mostly to build Java applications. It can build applications implemented in other programming languages as well. In a general way, Ant can be used to support any process that is described as targets and tasks. The target is a set of tasks and the tasks are piece of code, which execute actions on input parameters. The process is described in a XML file called build.xml.
Other advantages include: the possibility of being called as a console program (indispensable to be integrated to VPL), working in a high level (using Java objects), the availability of a set of built-in tasks, and the possibility of extend this set with own built tasks. To build a new task, it is necessary to write a Java class which extends from a given class and so it has
10http://www.sonarsource.org/ 11
21
to implement some methods, and after that registering the new created task is necessary. The registration includes some information about the class name, the path to the class, the package name and the arguments in a XML format.
The project recommends working with Ivy12, which is a dependencies manager integrated with Ant and that has the same principles.
• Maven13.-It presents two important goals: the first one is to provide a tool which manages the building and the dependencies control in Java projects; the second one is to allow the quick comprehension about the state of a project development. A Maven project is defined in a XML representation as well. This is known as POM (Project Object Model) and the representation’s name is pom.xml.
An important feature is the extensibility through the use of plugins written in Java or scripting languages. The building of new plugins is done based on Mojos, which are the simplest Java programs for Maven. Any new Mojo has to extend from a base abstract Mojo and therefore implementing a method. After that, defining the new plugin is necessary. The definition includes information about the version, the identification, the package, the group, the name, and additionally about dependencies (group, id, and version). This information is written in a XML format.
• Gradle14. - Its official site says that it is an evolved building tool because it can automate the building, testing, publishing, deployment and more of software projects. It has been built on Ant and Maven. It supports on a DSL (Domain Specific Language) based on Groovy language and provides of declarative language elements. It can work with Java, Groovy, OSGi (Open Services Gateway Initiative), Web and Scala projects. It uses a script written in Groovy to control the process. The XML representation of Ant and Maven projects can be interpreted or converted to a Groovy representation.
There are a set of already defined tasks, but writing new ones is possible. Additionally, Gradle can be called through the command-line.
• GNU make15. –It is a program that can manage processes to generate executable programs, or another kind of files, even programs’ installation/uninstallation from a set of source files. Then, it is not a tool only to build applications and it is not limited to a specific programming language. The process is composed of a set of stages. All of them are defined 12 http://ant.apache.org/ivy/index.html 13 http://maven.apache.org/ 14 http://www.gradle.org/ 15 http://www.gnu.org/software/make/
22
in a file called makefile. Every stage defines a target, a set of dependencies and a set of shell commands to execute.
There are not defined tasks, but new of them can be defined through using command-line calls. So it would be possible to call directly other programs through these calls.
In most cases the goal is to build, deploy or install an application. Although it is not the goal of this project, it is very useful knowing about the main features of these kinds of tools, to determine if one of these features can be emulated or used. It can be seen a common fact among these tools and it is the use of a configuration file, which allows managing the process.
In the design chapter there will be deeper information about the decision of using one of these tools or building a new one.