summaryrefslogtreecommitdiffstats
path: root/framework/src/onos/tools/package/maven-plugin
diff options
context:
space:
mode:
Diffstat (limited to 'framework/src/onos/tools/package/maven-plugin')
-rw-r--r--framework/src/onos/tools/package/maven-plugin/pom.xml122
-rw-r--r--framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosAppMojo.java372
-rw-r--r--framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosCfgMojo.java141
-rw-r--r--framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosSwaggerMojo.java451
-rw-r--r--framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/app.xml22
-rw-r--r--framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/features.xml24
-rw-r--r--framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/registrator.javat31
7 files changed, 1163 insertions, 0 deletions
diff --git a/framework/src/onos/tools/package/maven-plugin/pom.xml b/framework/src/onos/tools/package/maven-plugin/pom.xml
new file mode 100644
index 00000000..54839b11
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/pom.xml
@@ -0,0 +1,122 @@
+<!--
+ ~ Copyright 2015 Open Networking Laboratory
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<project>
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-base</artifactId>
+ <version>1</version>
+ <relativePath>../../build/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>onos-maven-plugin</artifactId>
+ <version>1.6-SNAPSHOT</version>
+ <packaging>maven-plugin</packaging>
+
+ <description>Maven plugin for packaging ONOS applications or generating
+ component configuration resources
+ </description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-plugin-api</artifactId>
+ <version>2.0</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-project</artifactId>
+ <version>2.0</version>
+ </dependency>
+
+ <dependency>
+ <groupId>com.thoughtworks.qdox</groupId>
+ <artifactId>qdox</artifactId>
+ <version>2.0-M3</version>
+ </dependency>
+
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ <version>18.0</version>
+ </dependency>
+
+ <dependency>
+ <groupId>commons-collections</groupId>
+ <artifactId>commons-collections</artifactId>
+ <version>3.2.1</version>
+ </dependency>
+
+ <dependency>
+ <groupId>commons-configuration</groupId>
+ <artifactId>commons-configuration</artifactId>
+ <version>1.10</version>
+ </dependency>
+
+ <!-- dependencies to annotations -->
+ <dependency>
+ <groupId>org.apache.maven.plugin-tools</groupId>
+ <artifactId>maven-plugin-annotations</artifactId>
+ <version>3.4</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.core</groupId>
+ <artifactId>jackson-databind</artifactId>
+ <version>2.4.2</version>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.core</groupId>
+ <artifactId>jackson-annotations</artifactId>
+ <version>2.4.2</version>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>2.5.1</version>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-plugin-plugin</artifactId>
+ <version>3.4</version>
+ <executions>
+ <execution>
+ <id>default-descriptor</id>
+ <phase>process-classes</phase>
+ </execution>
+ <!-- if you want to generate help goal -->
+ <execution>
+ <id>help-goal</id>
+ <goals>
+ <goal>helpmojo</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosAppMojo.java b/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosAppMojo.java
new file mode 100644
index 00000000..bfc6127a
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosAppMojo.java
@@ -0,0 +1,372 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.maven;
+
+import com.google.common.collect.ImmutableList;
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.commons.configuration.XMLConfiguration;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugins.annotations.Component;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
+import org.apache.maven.project.MavenProjectHelper;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import static com.google.common.io.ByteStreams.toByteArray;
+import static org.codehaus.plexus.util.FileUtils.*;
+
+/**
+ * Produces ONOS application archive using the app.xml file information.
+ */
+@Mojo(name = "app", defaultPhase = LifecyclePhase.PACKAGE)
+public class OnosAppMojo extends AbstractMojo {
+
+ private static final String APP = "app";
+ private static final String NAME = "[@name]";
+ private static final String VERSION = "[@version]";
+ private static final String FEATURES_REPO = "[@featuresRepo]";
+ private static final String ARTIFACT = "artifact";
+
+ private static final String APP_XML = "app.xml";
+ private static final String FEATURES_XML = "features.xml";
+
+ private static final String MVN_URL = "mvn:";
+ private static final String M2_PREFIX = "m2";
+
+ private static final String ONOS_APP_NAME = "onos.app.name";
+ private static final String ONOS_APP_ORIGIN = "onos.app.origin";
+
+ private static final String JAR = "jar";
+ private static final String XML = "xml";
+ private static final String APP_ZIP = "oar";
+ private static final String PACKAGE_DIR = "oar";
+
+ private static final String DEFAULT_ORIGIN = "ON.Lab";
+ private static final String DEFAULT_VERSION = "${project.version}";
+
+ private static final String DEFAULT_FEATURES_REPO =
+ "mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features";
+ private static final String DEFAULT_ARTIFACT =
+ "mvn:${project.groupId}/${project.artifactId}/${project.version}";
+
+ private static final int BUFFER_SIZE = 8192;
+
+ private String name;
+ private String origin;
+ private String version = DEFAULT_VERSION;
+ private String featuresRepo = DEFAULT_FEATURES_REPO;
+ private List<String> artifacts;
+
+ /**
+ * The project base directory.
+ */
+ @Parameter(defaultValue = "${basedir}")
+ protected File baseDir;
+
+ /**
+ * The directory where the generated catalogue file will be put.
+ */
+ @Parameter(defaultValue = "${project.build.directory}")
+ protected File dstDirectory;
+
+ /**
+ * The project group ID.
+ */
+ @Parameter(defaultValue = "${project.groupId}")
+ protected String projectGroupId;
+
+ /**
+ * The project artifact ID.
+ */
+ @Parameter(defaultValue = "${project.artifactId}")
+ protected String projectArtifactId;
+
+ /**
+ * The project version.
+ */
+ @Parameter(defaultValue = "${project.version}")
+ protected String projectVersion;
+
+ /**
+ * The project version.
+ */
+ @Parameter(defaultValue = "${project.description}")
+ protected String projectDescription;
+
+ @Parameter(defaultValue = "${localRepository}")
+ protected ArtifactRepository localRepository;
+
+ /**
+ * Maven project
+ */
+ @Parameter(defaultValue = "${project}")
+ protected MavenProject project;
+
+ /**
+ * Maven project helper.
+ */
+ @Component
+ protected MavenProjectHelper projectHelper;
+
+
+ private File m2Directory;
+ protected File stageDirectory;
+ protected String projectPath;
+
+ @Override
+ public void execute() throws MojoExecutionException {
+ File appFile = new File(baseDir, APP_XML);
+ File featuresFile = new File(baseDir, FEATURES_XML);
+
+ name = (String) project.getProperties().get(ONOS_APP_NAME);
+
+ // If neither the app.xml file exists, nor the onos.app.name property
+ // is defined, there is nothing for this Mojo to do, so bail.
+ if (!appFile.exists() && name == null) {
+ return;
+ }
+
+ m2Directory = new File(localRepository.getBasedir());
+ stageDirectory = new File(dstDirectory, PACKAGE_DIR);
+ projectPath = M2_PREFIX + "/" + artifactDir(projectGroupId, projectArtifactId, projectVersion);
+
+ origin = (String) project.getProperties().get(ONOS_APP_ORIGIN);
+ origin = origin != null ? origin : DEFAULT_ORIGIN;
+
+ if (appFile.exists()) {
+ loadAppFile(appFile);
+ } else {
+ artifacts = ImmutableList.of(eval(DEFAULT_ARTIFACT));
+ }
+
+ // If there are any artifacts, stage the
+ if (!artifacts.isEmpty()) {
+ getLog().info("Building ONOS application package for " + name + " (v" + eval(version) + ")");
+ artifacts.forEach(a -> getLog().debug("Including artifact: " + a));
+
+ if (stageDirectory.exists() || stageDirectory.mkdirs()) {
+ processAppXml(appFile);
+ processFeaturesXml(featuresFile);
+ processArtifacts();
+ generateAppPackage();
+ } else {
+ throw new MojoExecutionException("Unable to create directory: " + stageDirectory);
+ }
+ }
+ }
+
+ // Loads the app.xml file.
+ private void loadAppFile(File appFile) throws MojoExecutionException {
+ XMLConfiguration xml = new XMLConfiguration();
+ xml.setRootElementName(APP);
+
+ try (FileInputStream stream = new FileInputStream(appFile)) {
+ xml.load(stream);
+ xml.setAttributeSplittingDisabled(true);
+ xml.setDelimiterParsingDisabled(true);
+
+ name = xml.getString(NAME);
+ version = eval(xml.getString(VERSION));
+ featuresRepo = eval(xml.getString(FEATURES_REPO));
+
+ artifacts = xml.configurationsAt(ARTIFACT).stream()
+ .map(cfg -> eval(cfg.getRootNode().getValue().toString()))
+ .collect(Collectors.toList());
+
+ } catch (ConfigurationException e) {
+ throw new MojoExecutionException("Unable to parse app.xml file", e);
+ } catch (FileNotFoundException e) {
+ throw new MojoExecutionException("Unable to find app.xml file", e);
+ } catch (IOException e) {
+ throw new MojoExecutionException("Unable to read app.xml file", e);
+ }
+ }
+
+ // Processes and stages the app.xml file.
+ private void processAppXml(File appFile) throws MojoExecutionException {
+ try {
+ File file = new File(stageDirectory, APP_XML);
+ forceMkdir(stageDirectory);
+ String contents;
+
+ if (appFile.exists()) {
+ contents = fileRead(appFile);
+ } else {
+ byte[] bytes = toByteArray(getClass().getResourceAsStream(APP_XML));
+ contents = new String(bytes);
+ }
+ fileWrite(file.getAbsolutePath(), eval(contents));
+ } catch (IOException e) {
+ throw new MojoExecutionException("Unable to process app.xml", e);
+ }
+ }
+
+ private void processFeaturesXml(File featuresFile) throws MojoExecutionException {
+ boolean specified = featuresRepo != null && featuresRepo.length() > 0;
+
+ // If featuresRepo attribute is specified and there is a features.xml
+ // file present, add the features repo as an artifact
+ try {
+ if (specified && featuresFile.exists()) {
+ processFeaturesXml(new FileInputStream(featuresFile));
+ } else if (specified) {
+ processFeaturesXml(getClass().getResourceAsStream(FEATURES_XML));
+ }
+ } catch (FileNotFoundException e) {
+ throw new MojoExecutionException("Unable to find features.xml file", e);
+ } catch (IOException e) {
+ throw new MojoExecutionException("Unable to process features.xml file", e);
+ }
+ }
+
+ // Processes and stages the features.xml file.
+ private void processFeaturesXml(InputStream stream) throws IOException {
+ String featuresArtifact =
+ artifactFile(projectArtifactId, projectVersion, XML, "features");
+ File dstDir = new File(stageDirectory, projectPath);
+ forceMkdir(dstDir);
+ String s = eval(new String(toByteArray(stream)));
+ fileWrite(new File(dstDir, featuresArtifact).getAbsolutePath(), s);
+ }
+
+ // Stages all artifacts.
+ private void processArtifacts() throws MojoExecutionException {
+ for (String artifact : artifacts) {
+ processArtifact(artifact);
+ }
+ }
+
+ // Stages the specified artifact.
+ private void processArtifact(String artifact) throws MojoExecutionException {
+ if (!artifact.startsWith(MVN_URL)) {
+ throw new MojoExecutionException("Unsupported artifact URL:" + artifact);
+ }
+
+ String[] fields = artifact.substring(4).split("/");
+ if (fields.length < 3) {
+ throw new MojoExecutionException("Illegal artifact URL:" + artifact);
+ }
+
+ try {
+ String file = artifactFile(fields);
+
+ if (projectGroupId.equals(fields[0]) && projectArtifactId.equals(fields[1])) {
+ // Local artifact is not installed yet, package it from target directory.
+ File dstDir = new File(stageDirectory, projectPath);
+ forceMkdir(dstDir);
+ copyFile(new File(dstDirectory, file), new File(dstDir, file));
+ } else {
+ // Other artifacts are packaged from ~/.m2/repository directory.
+ String m2Path = artifactDir(fields);
+ File srcDir = new File(m2Directory, m2Path);
+ File dstDir = new File(stageDirectory, M2_PREFIX + "/" + m2Path);
+ forceMkdir(dstDir);
+ copyFile(new File(srcDir, file), new File(dstDir, file));
+ }
+ } catch (IOException e) {
+ throw new MojoExecutionException("Unable to stage artifact " + artifact, e);
+ }
+ }
+
+ // Generates the ONOS package ZIP file.
+ private void generateAppPackage() throws MojoExecutionException {
+ File appZip = new File(dstDirectory, artifactFile(projectArtifactId, projectVersion,
+ APP_ZIP, null));
+ try (FileOutputStream fos = new FileOutputStream(appZip);
+ ZipOutputStream zos = new ZipOutputStream(fos)) {
+ zipDirectory("", stageDirectory, zos);
+ projectHelper.attachArtifact(this.project, APP_ZIP, null, appZip);
+ } catch (IOException e) {
+ throw new MojoExecutionException("Unable to compress application package", e);
+ }
+ }
+
+ // Generates artifact directory name from the specified fields.
+ private String artifactDir(String[] fields) {
+ return artifactDir(fields[0], fields[1], fields[2]);
+ }
+
+ // Generates artifact directory name from the specified elements.
+ private String artifactDir(String gid, String aid, String version) {
+ return gid.replace('.', '/') + "/" + aid.replace('.', '/') + "/" + version;
+ }
+
+ // Generates artifact file name from the specified fields.
+ private String artifactFile(String[] fields) {
+ return fields.length < 5 ?
+ artifactFile(fields[1], fields[2],
+ (fields.length < 4 ? JAR : fields[3]), null) :
+ artifactFile(fields[1], fields[2], fields[3], fields[4]);
+ }
+
+ // Generates artifact file name from the specified elements.
+ private String artifactFile(String aid, String version, String type,
+ String classifier) {
+ return classifier == null ? aid + "-" + version + "." + type :
+ aid + "-" + version + "-" + classifier + "." + type;
+ }
+
+ // Returns the given string with project variable substitutions.
+ private String eval(String string) {
+ return string == null ? null :
+ string.replaceAll("\\$\\{onos.app.name\\}", name)
+ .replaceAll("\\$\\{onos.app.origin\\}", origin)
+ .replaceAll("\\$\\{project.groupId\\}", projectGroupId)
+ .replaceAll("\\$\\{project.artifactId\\}", projectArtifactId)
+ .replaceAll("\\$\\{project.version\\}", projectVersion)
+ .replaceAll("\\$\\{project.description\\}", projectDescription);
+ }
+
+ // Recursively archives the specified directory into a given ZIP stream.
+ private void zipDirectory(String root, File dir, ZipOutputStream zos)
+ throws IOException {
+ byte[] buffer = new byte[BUFFER_SIZE];
+ File[] files = dir.listFiles();
+ if (files != null && files.length > 0) {
+ for (File file : files) {
+ if (file.isDirectory()) {
+ String path = root + file.getName() + "/";
+ zos.putNextEntry(new ZipEntry(path));
+ zipDirectory(path, file, zos);
+ zos.closeEntry();
+ } else {
+ FileInputStream fin = new FileInputStream(file);
+ zos.putNextEntry(new ZipEntry(root + file.getName()));
+ int length;
+ while ((length = fin.read(buffer)) > 0) {
+ zos.write(buffer, 0, length);
+ }
+ zos.closeEntry();
+ fin.close();
+ }
+ }
+ }
+ }
+}
diff --git a/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosCfgMojo.java b/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosCfgMojo.java
new file mode 100644
index 00000000..3e3e17a0
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosCfgMojo.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.maven;
+
+import com.thoughtworks.qdox.JavaProjectBuilder;
+import com.thoughtworks.qdox.model.JavaAnnotation;
+import com.thoughtworks.qdox.model.JavaClass;
+import com.thoughtworks.qdox.model.JavaField;
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Produces ONOS component configuration catalogue resources.
+ */
+@Mojo(name = "cfg", defaultPhase = LifecyclePhase.GENERATE_RESOURCES)
+public class OnosCfgMojo extends AbstractMojo {
+
+ private static final String COMPONENT = "org.apache.felix.scr.annotations.Component";
+ private static final String PROPERTY = "org.apache.felix.scr.annotations.Property";
+ private static final String SEP = "|";
+
+ /**
+ * The directory where the generated catalogue file will be put.
+ */
+ @Parameter(defaultValue = "${basedir}")
+ protected File srcDirectory;
+
+ /**
+ * The directory where the generated catalogue file will be put.
+ */
+ @Parameter(defaultValue = "${project.build.outputDirectory}")
+ protected File dstDirectory;
+
+ @Override
+ public void execute() throws MojoExecutionException {
+ getLog().info("Generating ONOS component configuration catalogues...");
+ try {
+ JavaProjectBuilder builder = new JavaProjectBuilder();
+ builder.addSourceTree(new File(srcDirectory, "src/main/java"));
+ builder.getClasses().forEach(this::processClass);
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ private void processClass(JavaClass javaClass) {
+ boolean isComponent = javaClass.getAnnotations().stream()
+ .map(ja -> ja.getType().getName().equals(COMPONENT))
+ .findFirst().isPresent();
+ if (isComponent) {
+ List<String> lines = new ArrayList<>();
+ javaClass.getFields().forEach(field -> processField(lines, javaClass, field));
+ if (!lines.isEmpty()) {
+ writeCatalog(javaClass, lines);
+ }
+ }
+ }
+
+ private void writeCatalog(JavaClass javaClass, List<String> lines) {
+ File dir = new File(dstDirectory, javaClass.getPackageName().replace('.', '/'));
+ dir.mkdirs();
+
+ File cfgDef = new File(dir, javaClass.getName().replace('.', '/') + ".cfgdef");
+ try (FileWriter fw = new FileWriter(cfgDef);
+ PrintWriter pw = new PrintWriter(fw)) {
+ pw.println("# This file is auto-generated by onos-maven-plugin");
+ lines.forEach(pw::println);
+ } catch (IOException e) {
+ System.err.println("Unable to write catalog for " + javaClass.getName());
+ e.printStackTrace();
+ }
+ }
+
+ private void processField(List<String> lines, JavaClass javaClass, JavaField field) {
+ field.getAnnotations().forEach(ja -> {
+ if (ja.getType().getName().equals(PROPERTY)) {
+ lines.add(expand(javaClass, ja.getNamedParameter("name").toString()) +
+ SEP + type(field) +
+ SEP + defaultValue(javaClass, field, ja) +
+ SEP + description(ja));
+ }
+ });
+ }
+
+ // TODO: Stuff below is very much hack-ish and should be redone; it works for now though.
+
+ private String description(JavaAnnotation annotation) {
+ String description = (String) annotation.getNamedParameter("label");
+ return description.replaceAll("\" \\+ \"", "")
+ .replaceFirst("^[^\"]*\"", "").replaceFirst("\"$", "");
+ }
+
+ private String type(JavaField field) {
+ String ft = field.getType().getName().toUpperCase();
+ return ft.equals("INT") ? "INTEGER" : ft;
+ }
+
+ private String defaultValue(JavaClass javaClass, JavaField field,
+ JavaAnnotation annotation) {
+ String ft = field.getType().getName().toLowerCase();
+ String defValueName = ft.equals("boolean") ? "boolValue" :
+ ft.equals("string") ? "value" : ft + "Value";
+ Object dv = annotation.getNamedParameter(defValueName);
+ return dv == null ? "" : expand(javaClass, dv.toString());
+ }
+
+ private String stripQuotes(String string) {
+ return string.trim().replaceFirst("^[^\"]*\"", "").replaceFirst("\"$", "");
+ }
+
+ private String expand(JavaClass javaClass, String value) {
+ JavaField field = javaClass.getFieldByName(value);
+ return field == null ? stripQuotes(value) :
+ stripQuotes(field.getCodeBlock().replaceFirst(".*=", "").replaceFirst(";$", ""));
+ }
+
+}
diff --git a/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosSwaggerMojo.java b/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosSwaggerMojo.java
new file mode 100644
index 00000000..ea847459
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/src/main/java/org/onosproject/maven/OnosSwaggerMojo.java
@@ -0,0 +1,451 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.maven;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.io.ByteStreams;
+import com.google.common.io.Files;
+import com.thoughtworks.qdox.JavaProjectBuilder;
+import com.thoughtworks.qdox.model.DocletTag;
+import com.thoughtworks.qdox.model.JavaAnnotation;
+import com.thoughtworks.qdox.model.JavaClass;
+import com.thoughtworks.qdox.model.JavaMethod;
+import com.thoughtworks.qdox.model.JavaParameter;
+import com.thoughtworks.qdox.model.JavaType;
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import static com.google.common.base.Strings.isNullOrEmpty;
+
+/**
+ * Produces ONOS Swagger api-doc.
+ */
+@Mojo(name = "swagger", defaultPhase = LifecyclePhase.GENERATE_SOURCES)
+public class OnosSwaggerMojo extends AbstractMojo {
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ private static final String JSON_FILE = "swagger.json";
+ private static final String GEN_SRC = "generated-sources";
+ private static final String REG_SRC = "registrator.javat";
+
+ private static final String PATH = "javax.ws.rs.Path";
+ private static final String PATH_PARAM = "javax.ws.rs.PathParam";
+ private static final String QUERY_PARAM = "javax.ws.rs.QueryParam";
+ private static final String POST = "javax.ws.rs.POST";
+ private static final String GET = "javax.ws.rs.GET";
+ private static final String PUT = "javax.ws.rs.PUT";
+ private static final String DELETE = "javax.ws.rs.DELETE";
+ private static final String PRODUCES = "javax.ws.rs.Produces";
+ private static final String CONSUMES = "javax.ws.rs.Consumes";
+ private static final String JSON = "MediaType.APPLICATION_JSON";
+
+ /**
+ * The directory where the generated catalogue file will be put.
+ */
+ @Parameter(defaultValue = "${basedir}")
+ protected File srcDirectory;
+
+ /**
+ * The directory where the generated catalogue file will be put.
+ */
+ @Parameter(defaultValue = "${project.build.directory}")
+ protected File dstDirectory;
+
+ /**
+ * REST API web-context
+ */
+ @Parameter(defaultValue = "${web.context}")
+ protected String webContext;
+
+ /**
+ * REST API version
+ */
+ @Parameter(defaultValue = "${api.version}")
+ protected String apiVersion;
+
+ /**
+ * REST API description
+ */
+ @Parameter(defaultValue = "${api.description}")
+ protected String apiDescription;
+
+ /**
+ * REST API title
+ */
+ @Parameter(defaultValue = "${api.title}")
+ protected String apiTitle;
+
+ /**
+ * REST API title
+ */
+ @Parameter(defaultValue = "${api.package}")
+ protected String apiPackage;
+
+ /**
+ * Maven project
+ */
+ @Parameter(defaultValue = "${project}")
+ protected MavenProject project;
+
+
+ @Override
+ public void execute() throws MojoExecutionException {
+ try {
+ JavaProjectBuilder builder = new JavaProjectBuilder();
+ builder.addSourceTree(new File(srcDirectory, "src/main/java"));
+
+ ObjectNode root = initializeRoot();
+ ArrayNode tags = mapper.createArrayNode();
+ ObjectNode paths = mapper.createObjectNode();
+
+ root.set("tags", tags);
+ root.set("paths", paths);
+
+ builder.getClasses().forEach(jc -> processClass(jc, paths, tags));
+
+ if (paths.size() > 0) {
+ getLog().info("Generating ONOS REST API documentation...");
+ genCatalog(root);
+
+ if (!isNullOrEmpty(apiPackage)) {
+ genRegistrator();
+ }
+ }
+
+ project.addCompileSourceRoot(new File(dstDirectory, GEN_SRC).getPath());
+
+ } catch (Exception e) {
+ getLog().warn("Unable to generate ONOS REST API documentation", e);
+ throw e;
+ }
+ }
+
+ // initializes top level root with Swagger required specifications
+ private ObjectNode initializeRoot() {
+ ObjectNode root = mapper.createObjectNode();
+ root.put("swagger", "2.0");
+ ObjectNode info = mapper.createObjectNode();
+ root.set("info", info);
+
+ root.put("basePath", webContext);
+ info.put("version", apiVersion);
+ info.put("title", apiTitle);
+ info.put("description", apiDescription);
+
+ ArrayNode produces = mapper.createArrayNode();
+ produces.add("application/json");
+ root.set("produces", produces);
+
+ ArrayNode consumes = mapper.createArrayNode();
+ consumes.add("application/json");
+ root.set("consumes", consumes);
+
+ return root;
+ }
+
+ // Checks whether javaClass has a path tag associated with it and if it does
+ // processes its methods and creates a tag for the class on the root
+ void processClass(JavaClass javaClass, ObjectNode paths, ArrayNode tags) {
+ // If the class does not have a Path tag then ignore it
+ JavaAnnotation annotation = getPathAnnotation(javaClass);
+ if (annotation == null) {
+ return;
+ }
+
+ String path = getPath(annotation);
+ if (path == null) {
+ return;
+ }
+
+ String resourcePath = "/" + path;
+ String tagPath = path.isEmpty() ? "/" : path;
+
+ // Create tag node for this class.
+ ObjectNode tagObject = mapper.createObjectNode();
+ tagObject.put("name", tagPath);
+ if (javaClass.getComment() != null) {
+ tagObject.put("description", shortText(javaClass.getComment()));
+ }
+ tags.add(tagObject);
+
+ // Create an array node add to all methods from this class.
+ ArrayNode tagArray = mapper.createArrayNode();
+ tagArray.add(tagPath);
+
+ processAllMethods(javaClass, resourcePath, paths, tagArray);
+ }
+
+ private JavaAnnotation getPathAnnotation(JavaClass javaClass) {
+ Optional<JavaAnnotation> optional = javaClass.getAnnotations()
+ .stream().filter(a -> a.getType().getName().equals(PATH)).findAny();
+ return optional.isPresent() ? optional.get() : null;
+ }
+
+ // Checks whether a class's methods are REST methods and then places all the
+ // methods under a specific path into the paths node
+ private void processAllMethods(JavaClass javaClass, String resourcePath,
+ ObjectNode paths, ArrayNode tagArray) {
+ // map of the path to its methods represented by an ObjectNode
+ Map<String, ObjectNode> pathMap = new HashMap<>();
+
+ javaClass.getMethods().forEach(javaMethod -> {
+ javaMethod.getAnnotations().forEach(annotation -> {
+ String name = annotation.getType().getName();
+ if (name.equals(POST) || name.equals(GET) || name.equals(DELETE) || name.equals(PUT)) {
+ // substring(12) removes "javax.ws.rs."
+ String method = annotation.getType().toString().substring(12).toLowerCase();
+ processRestMethod(javaMethod, method, pathMap, resourcePath, tagArray);
+ }
+ });
+ });
+
+ // for each path add its methods to the path node
+ for (Map.Entry<String, ObjectNode> entry : pathMap.entrySet()) {
+ paths.set(entry.getKey(), entry.getValue());
+ }
+
+
+ }
+
+ private void processRestMethod(JavaMethod javaMethod, String method,
+ Map<String, ObjectNode> pathMap,
+ String resourcePath, ArrayNode tagArray) {
+ String fullPath = resourcePath, consumes = "", produces = "",
+ comment = javaMethod.getComment();
+ for (JavaAnnotation annotation : javaMethod.getAnnotations()) {
+ String name = annotation.getType().getName();
+ if (name.equals(PATH)) {
+ fullPath = resourcePath + "/" + getPath(annotation);
+ fullPath = fullPath.replaceFirst("^//", "/");
+ }
+ if (name.equals(CONSUMES)) {
+ consumes = getIOType(annotation);
+ }
+ if (name.equals(PRODUCES)) {
+ produces = getIOType(annotation);
+ }
+ }
+ ObjectNode methodNode = mapper.createObjectNode();
+ methodNode.set("tags", tagArray);
+
+ addSummaryDescriptions(methodNode, comment);
+ processParameters(javaMethod, methodNode);
+
+ processConsumesProduces(methodNode, "consumes", consumes);
+ processConsumesProduces(methodNode, "produces", produces);
+
+ addResponses(methodNode);
+
+ ObjectNode operations = pathMap.get(fullPath);
+ if (operations == null) {
+ operations = mapper.createObjectNode();
+ operations.set(method, methodNode);
+ pathMap.put(fullPath, operations);
+ } else {
+ operations.set(method, methodNode);
+ }
+ }
+
+ private void processConsumesProduces(ObjectNode methodNode, String type, String io) {
+ if (!io.equals("")) {
+ ArrayNode array = mapper.createArrayNode();
+ methodNode.set(type, array);
+ array.add(io);
+ }
+ }
+
+ private void addSummaryDescriptions(ObjectNode methodNode, String comment) {
+ String summary = "", description;
+ if (comment != null) {
+ if (comment.contains(".")) {
+ int periodIndex = comment.indexOf(".");
+ summary = comment.substring(0, periodIndex);
+ description = comment.length() > periodIndex + 1 ?
+ comment.substring(periodIndex + 1).trim() : "";
+ } else {
+ description = comment;
+ }
+ methodNode.put("summary", summary);
+ methodNode.put("description", description);
+ }
+ }
+
+ // Temporary solution to add responses to a method
+ // TODO Provide annotations in the web resources for responses and parse them
+ private void addResponses(ObjectNode methodNode) {
+ ObjectNode responses = mapper.createObjectNode();
+ methodNode.set("responses", responses);
+
+ ObjectNode success = mapper.createObjectNode();
+ success.put("description", "successful operation");
+ responses.set("200", success);
+
+ ObjectNode defaultObj = mapper.createObjectNode();
+ defaultObj.put("description", "Unexpected error");
+ responses.set("default", defaultObj);
+ }
+
+ // Checks if the annotations has a value of JSON and returns the string
+ // that Swagger requires
+ private String getIOType(JavaAnnotation annotation) {
+ if (annotation.getNamedParameter("value").toString().equals(JSON)) {
+ return "application/json";
+ }
+ return "";
+ }
+
+ // If the annotation has a Path tag, returns the value with leading and
+ // trailing double quotes and slash removed.
+ private String getPath(JavaAnnotation annotation) {
+ String path = annotation.getNamedParameter("value").toString();
+ return path == null ? null : path.replaceAll("(^[\\\"/]*|[/\\\"]*$)", "");
+ }
+
+ // Processes parameters of javaMethod and enters the proper key-values into the methodNode
+ private void processParameters(JavaMethod javaMethod, ObjectNode methodNode) {
+ ArrayNode parameters = mapper.createArrayNode();
+ methodNode.set("parameters", parameters);
+ boolean required = true;
+
+ for (JavaParameter javaParameter : javaMethod.getParameters()) {
+ ObjectNode individualParameterNode = mapper.createObjectNode();
+ Optional<JavaAnnotation> optional = javaParameter.getAnnotations().stream().filter(
+ annotation -> annotation.getType().getName().equals(PATH_PARAM) ||
+ annotation.getType().getName().equals(QUERY_PARAM)).findAny();
+ JavaAnnotation pathType = optional.isPresent() ? optional.get() : null;
+
+ String annotationName = javaParameter.getName();
+
+
+ if (pathType != null) { //the parameter is a path or query parameter
+ individualParameterNode.put("name",
+ pathType.getNamedParameter("value").toString().replace("\"", ""));
+ if (pathType.getType().getName().equals(PATH_PARAM)) {
+ individualParameterNode.put("in", "path");
+ } else if (pathType.getType().getName().equals(QUERY_PARAM)) {
+ individualParameterNode.put("in", "query");
+ }
+ individualParameterNode.put("type", getType(javaParameter.getType()));
+ } else { // the parameter is a body parameter
+ individualParameterNode.put("name", annotationName);
+ individualParameterNode.put("in", "body");
+
+ // TODO add actual hardcoded schemas and a type
+ // body parameters must have a schema associated with them
+ ArrayNode schema = mapper.createArrayNode();
+ individualParameterNode.set("schema", schema);
+ }
+ for (DocletTag p : javaMethod.getTagsByName("param")) {
+ if (p.getValue().contains(annotationName)) {
+ try {
+ String description = p.getValue().split(" ", 2)[1].trim();
+ if (description.contains("optional")) {
+ required = false;
+ }
+ individualParameterNode.put("description", description);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ individualParameterNode.put("required", required);
+ parameters.add(individualParameterNode);
+ }
+ }
+
+ // Returns the Swagger specified strings for the type of a parameter
+ private String getType(JavaType javaType) {
+ String type = javaType.getFullyQualifiedName();
+ String value;
+ if (type.equals(String.class.getName())) {
+ value = "string";
+ } else if (type.equals("int")) {
+ value = "integer";
+ } else if (type.equals(boolean.class.getName())) {
+ value = "boolean";
+ } else if (type.equals(long.class.getName())) {
+ value = "number";
+ } else {
+ value = "";
+ }
+ return value;
+ }
+
+ // Writes the swagger.json file using the supplied JSON root.
+ private void genCatalog(ObjectNode root) {
+ File swaggerCfg = new File(dstDirectory, JSON_FILE);
+ if (dstDirectory.exists() || dstDirectory.mkdirs()) {
+ try (FileWriter fw = new FileWriter(swaggerCfg);
+ PrintWriter pw = new PrintWriter(fw)) {
+ pw.println(root.toString());
+ } catch (IOException e) {
+ getLog().warn("Unable to write " + JSON_FILE);
+ }
+ } else {
+ getLog().warn("Unable to create " + dstDirectory);
+ }
+ }
+
+ // Generates the registrator Java component.
+ private void genRegistrator() {
+ File dir = new File(dstDirectory, GEN_SRC);
+ File reg = new File(dir, apiPackage.replaceAll("\\.", "/") + "/ApiDocRegistrator.java");
+ File pkg = reg.getParentFile();
+ if (pkg.exists() || pkg.mkdirs()) {
+ try {
+ String src = new String(ByteStreams.toByteArray(getClass().getResourceAsStream(REG_SRC)));
+ src = src.replace("${api.package}", apiPackage)
+ .replace("${web.context}", webContext)
+ .replace("${api.title}", apiTitle)
+ .replace("${api.description}", apiTitle);
+ Files.write(src.getBytes(), reg);
+ } catch (IOException e) {
+ getLog().warn("Unable to write " + reg);
+ }
+ } else {
+ getLog().warn("Unable to create " + reg);
+ }
+ }
+
+ // Returns "nickname" based on method and path for a REST method
+ private String setNickname(String method, String path) {
+ if (!path.equals("")) {
+ return (method + path.replace('/', '_').replace("{", "").replace("}", "")).toLowerCase();
+ } else {
+ return method.toLowerCase();
+ }
+ }
+
+ private String shortText(String comment) {
+ int i = comment.indexOf('.');
+ return i > 0 ? comment.substring(0, i) : comment;
+ }
+
+}
diff --git a/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/app.xml b/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/app.xml
new file mode 100644
index 00000000..0f3133d3
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/app.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2015 Open Networking Laboratory
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<app name="${onos.app.name}" origin="${onos.app.origin}" version="${project.version}"
+ featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
+ features="${project.artifactId}">
+ <description>${project.description}</description>
+ <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
+</app>
diff --git a/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/features.xml b/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/features.xml
new file mode 100644
index 00000000..d5a91e2a
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/features.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!--
+ ~ Copyright 2015 Open Networking Laboratory
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
+ <repository>mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features</repository>
+ <feature name="${project.artifactId}" version="${project.version}"
+ description="${project.description}">
+ <feature>onos-api</feature>
+ <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
+ </feature>
+</features>
diff --git a/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/registrator.javat b/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/registrator.javat
new file mode 100644
index 00000000..a8e26536
--- /dev/null
+++ b/framework/src/onos/tools/package/maven-plugin/src/main/resources/org/onosproject/maven/registrator.javat
@@ -0,0 +1,31 @@
+/*
+ * Auto-generated by OnosSwaggerMojo.
+ *
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ${api.package};
+
+import org.apache.felix.scr.annotations.Component;
+import org.onosproject.rest.AbstractApiDocRegistrator;
+import org.onosproject.rest.ApiDocProvider;
+
+@Component(immediate = true)
+public class ApiDocRegistrator extends AbstractApiDocRegistrator {
+ public ApiDocRegistrator() {
+ super(new ApiDocProvider("${web.context}",
+ "${api.title}",
+ ApiDocRegistrator.class.getClassLoader()));
+ }
+}