protected boolean isInitialzied = false;
public String getSchemaVersion() {
- return Constants.OPEN_CLI_SCHEMA_VERSION_VALUE;
+ return Constants.OPEN_CLI_SCHEMA_VERSION_VALUE_1_0;
}
/**
import java.util.Map;
import java.util.Set;
-import org.onap.cli.fw.cmd.CommandType;
import org.onap.cli.fw.cmd.OnapHttpCommand;
import org.onap.cli.fw.conf.Constants;
import org.onap.cli.fw.conf.OnapCommandConfg;
import org.onap.cli.fw.error.OnapCommandProductVersionInvalid;
import org.onap.cli.fw.error.OnapCommandRegistrationFailed;
import org.onap.cli.fw.error.OnapCommandRegistrationProductInfoMissing;
+import org.onap.cli.fw.error.OnapUnsupportedSchemaProfile;
import org.onap.cli.fw.input.cache.OnapCommandParameterCache;
import org.onap.cli.fw.output.OnapCommandResult;
import org.onap.cli.fw.output.OnapCommandResultAttribute;
import org.onap.cli.fw.output.OnapCommandResultAttributeScope;
import org.onap.cli.fw.output.PrintDirection;
import org.onap.cli.fw.output.ResultType;
-import org.onap.cli.fw.utils.ExternalSchema;
import org.onap.cli.fw.utils.OnapCommandUtils;
+import org.onap.cli.fw.utils.SchemaInfo;
+
/**
* Onap Command registrar provides a common place, where every command would get registered automatically when its
public static OnapCommandRegistrar getRegistrar() throws OnapCommandException {
if (registrar == null) {
registrar = new OnapCommandRegistrar();
- registrar.autoDiscover();
- registrar.autoDiscoverHttpSchemas();
+ registrar.autoDiscoverSchemas();
}
return registrar;
* @throws OnapCommandException
* exception
*/
- public List<ExternalSchema> listCommandInfo() throws OnapCommandException {
- return OnapCommandUtils.findAllExternalSchemas();
+ public List<SchemaInfo> listCommandInfo() throws OnapCommandException {
+ return OnapCommandUtils.discoverSchemas();
}
/**
String schemaName;
if (cmd.getClass().equals(OnapHttpCommand.class)) { // NOSONAR
- schemaName = OnapCommandUtils.loadExternalSchemaFromJson(cmdName, version).getSchemaName();
+ schemaName = OnapCommandUtils.getSchemaInfo(cmdName, version).getSchemaName();
} else {
schemaName = this.getSchemaFileName(cls);
}
return cmd;
}
- private void autoDiscover() throws OnapCommandInvalidRegistration, OnapCommandRegistrationProductInfoMissing {
- List<Class<OnapCommand>> cmds = OnapCommandUtils.findOnapCommands();
+ private Map<String, Class<OnapCommand>> autoDiscoverCommandPlugins() throws OnapCommandException {
+ List<Class<OnapCommand>> cmds = OnapCommandUtils.discoverCommandPlugins();
+ Map<String, Class<OnapCommand>> map = new HashMap<>();
for (Class<OnapCommand> cmd : cmds) {
if (cmd.isAnnotationPresent(OnapCommandSchema.class)) {
OnapCommandSchema ano = cmd.getAnnotation(OnapCommandSchema.class);
- this.register(ano.name(), ano.version(), cmd);
+ map.put(ano.schema(), cmd);
}
}
+
+ return map;
}
- private void autoDiscoverHttpSchemas() throws OnapCommandException {
- List<ExternalSchema> schemas = OnapCommandUtils.loadExternalSchemasFromJson();
- for (ExternalSchema schema : schemas) {
+ private void autoDiscoverSchemas() throws OnapCommandException {
+ List<SchemaInfo> schemas = OnapCommandUtils.discoverOrLoadSchemas();
+
+ Map<String, Class<OnapCommand>> plugins = this.autoDiscoverCommandPlugins();
+
+ for (SchemaInfo schema : schemas) {
if (schema.isHttp()) {
- this.register(schema.getCmdName(), schema.getCmdVersion(), OnapHttpCommand.class);
+ this.register(schema.getCmdName(), schema.getProduct(), OnapHttpCommand.class);
+ } else if (plugins.containsKey(schema.getSchemaName())) {
+ this.register(schema.getCmdName(), schema.getProduct(), plugins.get(schema.getSchemaName()));
+ } else {
+ throw new OnapUnsupportedSchemaProfile(schema.getSchemaURI());
}
}
}
OnapCommandResultAttribute attrVer = new OnapCommandResultAttribute();
if (!isEnabledProductVersionOnly) {
- attrVer.setName(Constants.PRODUCT_VERSION.toUpperCase());
+ attrVer.setName(Constants.INFO_PRODUCT.toUpperCase());
attrVer.setDescription(Constants.DESCRIPTION);
attrVer.setScope(OnapCommandResultAttributeScope.SHORT);
help.getRecords().add(attrVer);
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OnapCommandSchema {
- /**
- * Command name
- *
- * @return
- */
- String name();
-
- /**
- * Command version
- *
- * @return
- */
- String version();
-
/**
* Schema file name placed under class path
*
* @return
*/
- String schema() default "";
-
- /**
- * Command type
- *
- * @return
- */
- String type() default "cmd";
+ String schema();
}
package org.onap.cli.fw.ad;
import org.onap.cli.fw.conf.Constants;
-import org.onap.cli.fw.conf.OnapCommandConfg;
/**
* Onap Service as reported in api catalog.
* Another mode is 'direct', in which bastPath will be
* same as OnapCredentails.ServiceUrl.
*/
- private String mode = Constants.MODE_CATALOG;
+ private String mode = Constants.MODE_DIRECT;
- private String authType = OnapCommandConfg.getAuthType();;
+ private String authType = Constants.AUTH_NONE;
public String getMode() {
return mode;
import org.onap.cli.fw.error.OnapCommandException;
import org.onap.cli.fw.input.OnapCommandParameter;
-@OnapCommandSchema(name = "basic-login", version = "open-cli", type = "auth", schema = "basic-login.yaml")
+@OnapCommandSchema(schema = "basic-login.yaml")
public class BasicAuthLoginCommand extends OnapHttpCommand {
@Override
import org.onap.cli.fw.OnapCommandSchema;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "basic-logout", version = "open-cli", type = "auth", schema = "basic-logout.yaml")
+@OnapCommandSchema(schema = "basic-logout.yaml")
public class BasicAuthLogoutCommand extends OnapHttpCommand {
@Override
import org.onap.cli.fw.OnapCommandSchema;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "catalog", version = "open-cli", type = "catalog", schema = "catalog.yaml")
+@OnapCommandSchema(schema = "catalog.yaml")
public class CatalogCommand extends OnapHttpCommand {
@Override
@Override
public String getSchemaVersion() {
- return Constants.OPEN_CLI_SCHEMA_VERSION_VALUE;
+ return Constants.OPEN_CLI_SCHEMA_VERSION_VALUE_1_0;
}
public void setSuccessStatusCodes(List<Integer> successStatusCodes) {
import org.onap.cli.fw.OnapCommandSchema;
import org.onap.cli.fw.error.OnapCommandException;
import org.onap.cli.fw.output.OnapCommandResultAttribute;
-import org.onap.cli.fw.utils.ExternalSchema;
+import org.onap.cli.fw.utils.SchemaInfo;
import org.onap.cli.fw.utils.OnapCommandUtils;
import java.util.ArrayList;
* Refresh external schema.
*
*/
-@OnapCommandSchema(name = "schema-refresh", version = "open-cli", schema = "schema-refresh.yaml")
+@OnapCommandSchema(schema = "schema-refresh.yaml")
public class OnapSchemaRefreshCommand extends OnapCommand {
@Override
protected void run() throws OnapCommandException {
- List<ExternalSchema> schemas = OnapCommandUtils.findAllExternalSchemas();
+ List<SchemaInfo> schemas = OnapCommandUtils.discoverSchemas();
// Will override the existing json file
- OnapCommandUtils.persist(schemas);
+ OnapCommandUtils.persistSchemaInfo(schemas);
List<String> slNumbers = new ArrayList<>();
List<String> cmdNames = new ArrayList<>();
List<String> cmdVersions = new ArrayList<>();
for (int i = 0; i < schemas.size(); i++) {
- ExternalSchema schema = schemas.get(i);
+ SchemaInfo schema = schemas.get(i);
slNumbers.add(String.valueOf(i + 1));
cmdNames.add(schema.getCmdName());
cmdFiles.add(schema.getSchemaName());
versions.add(schema.getVersion());
- cmdVersions.add(schema.getCmdVersion());
+ cmdVersions.add(schema.getProduct());
}
for (OnapCommandResultAttribute attribute : this.getResult().getRecords()) {
if ("sl-no".equals(attribute.getName())) {
/**
* Validate schema command.
*/
-@OnapCommandSchema(name = "schema-validate", version = "open-cli", schema = "schema-validate.yaml")
+@OnapCommandSchema(schema = "schema-validate.yaml")
public class OnapSchemaValidateCommand extends OnapCommand {
@Override
*/
public class Constants {
- // schema validation
+ //config
+ public static final String CONF = "open-cli.properties";
+ public static final String OPEN_IGNORE_AUTH = "cli.ignore_auth";
+ public static final String OPEN_CLI_VERSION = "cli.version";
+ public static final String HTTP_API_KEY_USE_COOKIES = "cli.http.api_key_use_cookies";
+
public static final String TOP_LEVEL_PARAMS_LIST ="cli.schema.top_level_params_list";
public static final String TOP_LEVEL_MANDATORY_LIST ="cli.schema.top_level_mandatory_list";
public static final String SERVICE_PARAMS_LIST ="cli.schema.service_params_list";
public static final String MODE_VALUES="cli.schema.mode_values";
public static final String COMMAND_TYPE_VALUES="cli.command.type";
+ //http connection
public static final String SSLCONTEST_TLS = "TLSV1.2";
public static final String APPLICATION_JSON = "application/json";
public static final String OPEN_CLI_PRODUCT_NAME = "cli.product_name";
+ //schema
+ public static final String OPEN_CLI_SCHEMA_VERSION = "open_cli_schema_version";
+ public static final String OPEN_CLI_SCHEMA_VERSION_VALUE_1_0 = "1.0";
- //http
- public static final String URI = "uri";
- public static final String BODY = "body";
- public static final String METHOD_TYPE = "method";
- public static final String HEADERS = "headers";
- public static final String QUERIES = "queries";
- public static final String COOKIES = "cookies";
+ public static final String NAME = "name";
- public static final String HTTP = "http";
- public static final String REQUEST = "request";
- public static final String SAMPLE_RESPONSE = "sample_response";
- public static final String SUCCESS_CODES = "success_codes";
- public static final String RESULT_MAP = "result_map";
+ public static final String DESCRIPTION = "description";
//Info
public static final String INFO = "info";
+
public static final String INFO_PRODUCT = "product";
+ public static final String OPEN_OPEN_CLI_PRODUCT_IN_USE_ENV_NAME = "OPEN_CLI_PRODUCT_IN_USE";
+
public static final String INFO_SERVICE = "service";
public static final String INFO_TYPE = "type";
public static final String INFO_AUTHOR = "author";
- //swagger
- public static final String EXECUTOR = "exec";
-
- public static final String API = "api";
- public static final String CLIENT = "client";
- public static final String ENTITY = "entity";
- public static final String METHOD = "method";
- public static final String MULTIPART_ENTITY_NAME = "multipart_entity_name";
- public static final String EXCEPTION = "exception";
-
- public static final String SCOPE = "scope";
-
- public static final String OPEN_CLI_SCHEMA_VERSION_VALUE = "1.0";
- public static final String DESCRIPTION = "description";
- public static final String COMMAND_TYPE = "type";
- public static final String SERVICE = "service";
+ //parameters
public static final String PARAMETERS = "parameters";
-
- public static final String RESULTS = "results";
-
- public static final String OPEN_CLI_SCHEMA_VERSION = "open_cli_schema_version";
- public static final String NAME = "name";
- public static final String VERSION = "version";
- public static final String BASE_PATH = "base_path";
- public static final String AUTH = "auth";
- public static final String AUTH_NONE = "none";
- public static final String AUTH_BASIC = "basic";
- public static final String MODE = "mode";
- public static final String MODE_DIRECT = "direct";
- public static final String MODE_CATALOG = "catalog";
-
public static final String SHORT_OPTION = "short_option";
public static final String LONG_OPTION = "long_option";
public static final String TYPE = "type";
public static final String IS_SECURED = "is_secured";
public static final String IS_INCLUDE = "is_include";
- public static final String DIRECTION = "direction";
- public static final String ATTRIBUTES = "attributes";
+ public static final String PARAMETER_TYPE_JSON = "json";
+ public static final String PARAMETER_TYPE_YAML = "yaml";
+ public static final String PARAMETER_TYPE_STRING = "string";
+ public static final String PARAMETER_TYPE_LONG = "long";
+ public static final String PARAMETER_TYPE_URL = "url";
+ public static final String PARAMETER_TYPE_BOOL = "bool";
+ public static final String PARAMETER_TYPE_ARRAY = "array";
+ public static final String PARAMETER_TYPE_BINARY = "binary";
+ public static final String PARAMETER_TYPE_MAP = "map";
public static final String DEFAULT_PARAMETER_FILE_NAME = "default_input_parameters.yaml";
public static final String DEFAULT_PARAMETER_HTTP_FILE_NAME = "default_input_parameters_http.yaml";
- // Common parameters used across all commands.
public static final String DEAFULT_PARAMETER_USERNAME = "host-username";
public static final String DEAFULT_PARAMETER_PASSWORD = "host-password";
public static final String DEAFULT_PARAMETER_HOST_URL = "host-url";
public static final String DEFAULT_PARAMETER_OUTPUT_NO_TITLE = "no-title";
public static final String DEFAULT_PARAMETER_NO_AUTH = "no-auth";
- // Configuration properties
- public static final String CONF = "open-cli.properties";
- public static final String OPEN_IGNORE_AUTH = "cli.ignore_auth";
- public static final String OPEN_CLI_VERSION = "cli.version";
- public static final String OPEN_OPEN_CLI_PRODUCT_IN_USE_ENV_NAME = "OPEN_CLI_PRODUCT_IN_USE";
- public static final String HTTP_API_KEY_USE_COOKIES = "cli.http.api_key_use_cookies";
+ //results
+ public static final String RESULTS = "results";
- public static final String SERVICE_AUTH = "cli.service.auth";
- public static final String SERVICE_AUTH_BASIC_HTTP_HEADERS = "cli.http.basic.common_headers";
+ public static final String DIRECTION = "direction";
+ public static final String DIRECTION_PORTRAIT = "portrait";
+ public static final String DIRECTION_LANDSCAPE = "landscape";
+
+ public static final String ATTRIBUTES = "attributes";
+
+ public static final String SCOPE = "scope";
+ public static final String RESULT_SCOPE_SHORT = "short";
+ public static final String RESULT_SCOPE_LONG = "long";
- // Used while printing the column name during PORTRAIT mode print
+ //print
public static final String PORTRAINT_COLUMN_NAME_PROPERTY = "property";
public static final String PORTRAINT_COLUMN_NAME_VALUE = "value";
- public static final String EXTERNAL_SCHEMA_DIRECTORY = "open-cli-schema";
- public static final String EXTERNAL_YAML_PATTERN = "/**/*.yaml";
- public static final String EXTERNAL_JSON_PATTERN = "/**/*.json";
- public static final String EXTERNAL_SCHEMA_PATH_PATERN = EXTERNAL_SCHEMA_DIRECTORY + EXTERNAL_YAML_PATTERN;
+ public static final String SCHEMA_DIRECTORY = "open-cli-schema";
+ public static final String YAML_PATTERN = "/**/*.yaml";
+ public static final String JSON_PATTERN = "/**/*.json";
+ public static final String SCHEMA_PATH_PATERN = SCHEMA_DIRECTORY + YAML_PATTERN;
public static final String DATA_DIRECTORY = "data";
- public static final String EXTERNAL_DISCOVERY_FILE = "cli-schema.json";
- public static final String DATA_DIRECTORY_JSON_PATTERN = DATA_DIRECTORY
- + EXTERNAL_JSON_PATTERN;
+ public static final String DISCOVERY_FILE = "cli-schema.json";
+ public static final String DATA_PATH_JSON_PATTERN = DATA_DIRECTORY + JSON_PATTERN;
+ public static final String DISCOVER_ALWAYS = "discover_always";
+ public static final String PARAM_CACHE_FILE_NAME = "global-profile";
- public static final String PARAMETER_TYPE_JSON = "json";
- public static final String PARAMETER_TYPE_YAML = "yaml";
- public static final String PARAMETER_TYPE_STRING = "string";
- public static final String PARAMETER_TYPE_LONG = "long";
- public static final String PARAMETER_TYPE_URL = "url";
- public static final String PARAMETER_TYPE_BOOL = "bool";
- public static final String PARAMETER_TYPE_ARRAY = "array";
- public static final String PARAMETER_TYPE_BINARY = "binary";
- public static final String PARAMETER_TYPE_MAP = "map";
+ //normal
+ public static final String BASIC_SCHEMA_PROFILE = "basic-schema";
+ public static final String HTTP_SCHEMA_PROFILE = "http-schema";
- public static final String BOOLEAN_TRUE = "true";
- public static final String BOOLEAN_FALSE = "false";
+ //http
+ public static final String HTTP = "http";
- public static final String DIRECTION_PORTRAIT = "portrait";
- public static final String DIRECTION_LANDSCAPE = "landscape";
+ public static final String SERVICE = "service";
+ public static final String VERSION = "version";
+ public static final String BASE_PATH = "base_path";
+ public static final String AUTH = "auth";
+ public static final String AUTH_NONE = "none";
+ public static final String AUTH_BASIC = "basic";
+ public static final String MODE = "mode";
+ public static final String MODE_DIRECT = "direct";
+ public static final String MODE_CATALOG = "catalog";
- public static final String RESULT_SCOPE_SHORT = "short";
- public static final String RESULT_SCOPE_LONG = "long";
+ public static final String REQUEST = "request";
+ public static final String URI = "uri";
+ public static final String BODY = "body";
+ public static final String METHOD_TYPE = "method";
public static final String POST = "post";
public static final String GET = "get";
public static final String DELETE = "delete";
public static final String PUT = "put";
public static final String HEAD = "delete";
- public static final String DEFAULT_SCHEMA_FILE_NAME = "default_input_parameters.yaml";
+ public static final String HEADERS = "headers";
+ public static final String QUERIES = "queries";
+ public static final String COOKIES = "cookies";
+
+ public static final String SUCCESS_CODES = "success_codes";
+
+ public static final String RESULT_MAP = "result_map";
+
+ public static final String SAMPLE_RESPONSE = "sample_response";
+
+ //swagger
+ public static final String EXECUTOR = "exec";
+
+ public static final String API = "api";
+ public static final String CLIENT = "client";
+ public static final String ENTITY = "entity";
+ public static final String METHOD = "method";
+ public static final String MULTIPART_ENTITY_NAME = "multipart_entity_name";
+ public static final String EXCEPTION = "exception";
+ public static final String BOOLEAN_TRUE = "true";
+ public static final String BOOLEAN_FALSE = "false";
- public static final String PRODUCT_VERSION = "product version";
// Error message
public static final String SCHEMA_INVALID_DEFAULT_PARAMS_SECTION = "Invalid default_parameter section";
public static final String SCHEMA_FILE_EMPTY = "The schema file cann't be null or empty";
public static final String HTTP_SAMPLE_RESPONSE_FAILED_PARSING = "The http Sample response json is failed to parse.";
public static final String USE_DIRECTIVE = "use";
- public static final String PARAM_CACHE_FILE_NAME = "global-profile";
-
- public static final String DISCOVER_ALWAYS = "discover_always";
public static final String SAMPLE_GEN_ENABLED = "cli.sample.gen.enable";
public static final String SAMPLE_GEN_TARGET_FOLDER = "cli.sample.gen.target";
public static final String SPL_ENTRY_UUID = "uuid";
public static final String SPL_ENTRY_ENV = "env:";
+ //auth plugin
public static final String AUTH_SERVICE_AUTHORIZATION = "Authorization";
+ //catalog plugin
public static final String CATALOG_SERVICE_NAME = "catalog-service-name";
-
public static final String CATALOG_SERVICE_VERSION = "catalog-service-version";
-
public static final String CATALOG_SERVICE_BASE_PATH = "catalog-service-base-path";
-
public static final String CATALOG_SERVICE_HOST_URL = "catalog-service-host-url";
private Constants() {
return prps.getProperty(Constants.OPEN_CLI_PRODUCT_NAME);
}
- public static String getAuthType() {
- return prps.getProperty(Constants.SERVICE_AUTH, Constants.AUTH_BASIC);
- }
-
private static Map<String, String> getHeaderValues(String headerKey, Map<String, String> paramMap) {
Map<String, String> mapHeaders = new HashMap<String, String> ();
if (prps.containsKey(headerKey)) {
return mapHeaders;
}
- public static Map<String, String> getBasicCommonHeaders(Map<String, String> paramMap) {
- return getHeaderValues(Constants.SERVICE_AUTH_BASIC_HTTP_HEADERS, paramMap);
- }
-
- public static Map<String, String> getServiceHeaders(String serviceName, Map<String, String> paramMap) {
- String serviceHeader = Constants.SERVICE_AUTH_BASIC_HTTP_HEADERS+ "." + serviceName;
- return getHeaderValues(serviceHeader, paramMap);
- }
-
//mrkanag move this utils class
public static List<String> getSchemaAttrInfo(String key) {
return Arrays.stream(prps.getProperty(key).split(",")).map(String::trim).collect(Collectors.toList()); // NOSONAR
* limitations under the License.
*/
-package org.onap.cli.cmd.cs.msb;
+package org.onap.cli.fw.error;
-import org.onap.cli.fw.OnapCommandSchema;
-import org.onap.cli.fw.cmd.OnapHttpCommand;
+/**
+ * Command schema not found.
+ *
+ */
+public class OnapUnsupportedSchemaProfile extends OnapCommandException {
+
+ private static final long serialVersionUID = -3919580583845280200L;
+
+ private static final String ERROR_CODE = "0xb004";
+
+ private static final String ERROR_MSG = "Unsupported schema profile";
+
+ public OnapUnsupportedSchemaProfile(String schema) {
+ super(ERROR_CODE, ERROR_MSG + schema);
+ }
-@OnapCommandSchema(name = "microservice-show", version = "onap-1.1", schema = "microservice-show-schema.yaml")
-public class OnapServiceShowCommand extends OnapHttpCommand {
}
}
try {
- OnapCommandUtils.persistParams(params, this.profileName);
+ OnapCommandUtils.persistProfile(params, this.profileName);
} catch (OnapCommandPersistProfileFailed e) {
throw new RuntimeException(e); // NOSONAR
}
import static org.onap.cli.fw.conf.Constants.CLIENT;
import static org.onap.cli.fw.conf.Constants.COMMAND_TYPE_VALUES;
import static org.onap.cli.fw.conf.Constants.DATA_DIRECTORY;
-import static org.onap.cli.fw.conf.Constants.DATA_DIRECTORY_JSON_PATTERN;
+import static org.onap.cli.fw.conf.Constants.DATA_PATH_JSON_PATTERN;
import static org.onap.cli.fw.conf.Constants.DEAFULT_PARAMETER_PASSWORD;
import static org.onap.cli.fw.conf.Constants.DEAFULT_PARAMETER_USERNAME;
import static org.onap.cli.fw.conf.Constants.DEFAULT_PARAMETER_FILE_NAME;
import static org.onap.cli.fw.conf.Constants.DEFAULT_VALUE;
import static org.onap.cli.fw.conf.Constants.DESCRIPTION;
import static org.onap.cli.fw.conf.Constants.DIRECTION;
+import static org.onap.cli.fw.conf.Constants.DISCOVERY_FILE;
import static org.onap.cli.fw.conf.Constants.ENTITY;
import static org.onap.cli.fw.conf.Constants.EXCEPTION;
import static org.onap.cli.fw.conf.Constants.EXECUTOR;
-import static org.onap.cli.fw.conf.Constants.EXTERNAL_DISCOVERY_FILE;
-import static org.onap.cli.fw.conf.Constants.EXTERNAL_SCHEMA_DIRECTORY;
-import static org.onap.cli.fw.conf.Constants.EXTERNAL_SCHEMA_PATH_PATERN;
import static org.onap.cli.fw.conf.Constants.HEADERS;
import static org.onap.cli.fw.conf.Constants.HTTP;
import static org.onap.cli.fw.conf.Constants.HTTP_BODY_FAILED_PARSING;
import static org.onap.cli.fw.conf.Constants.RESULT_PARAMS_LIST;
import static org.onap.cli.fw.conf.Constants.RESULT_PARAMS_MANDATORY_LIST;
import static org.onap.cli.fw.conf.Constants.SAMPLE_RESPONSE;
+import static org.onap.cli.fw.conf.Constants.SCHEMA_DIRECTORY;
import static org.onap.cli.fw.conf.Constants.SCHEMA_FILE_NOT_EXIST;
import static org.onap.cli.fw.conf.Constants.SCHEMA_FILE_WRONG_EXTN;
+import static org.onap.cli.fw.conf.Constants.SCHEMA_PATH_PATERN;
import static org.onap.cli.fw.conf.Constants.SCOPE;
import static org.onap.cli.fw.conf.Constants.SERVICE;
import static org.onap.cli.fw.conf.Constants.SERVICE_PARAMS_LIST;
import org.onap.cli.fw.output.PrintDirection;
import org.onap.cli.fw.output.ResultType;
import org.onap.cli.fw.run.OnapCommandExecutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
*/
public class OnapCommandUtils {
+ private static Logger LOG = LoggerFactory.getLogger(OnapCommandUtils.class);
/**
* Private constructor.
*/
InputStream inputStream = OnapCommandUtils.class.getClassLoader().getResourceAsStream(schemaName);
try {
- Resource resource = getExternalResource(schemaName, EXTERNAL_SCHEMA_PATH_PATERN);
+ Resource resource = getExternalResource(schemaName, SCHEMA_PATH_PATERN);
if (resource != null) {
inputStream = resource.getInputStream();
* @param schemaName schema name
* @param includeDefault include if default
* @param validateSchema flag to represent validation
- * @throws OnapCommandParameterNameConflict param name conflict exception
- * @throws OnapCommandParameterOptionConflict param option conflict exception
- * @throws OnapCommandInvalidParameterType invalid param type exception
- * @throws OnapCommandInvalidPrintDirection invalid print direction exception
- * @throws OnapCommandInvalidResultAttributeScope invalid scope exception
- * @throws OnapCommandSchemaNotFound schema not found
- * @throws OnapCommandInvalidSchema invalid schema
- * @throws OnapCommandInvalidSchemaVersion invalid schema version
+ * @throws OnapCommandException on error
*/
public static List<String> loadSchema(OnapCommand cmd, String schemaName, boolean includeDefault,
boolean validateSchema) throws OnapCommandException {
}
}
- private static void throwOrCollect(OnapCommandException ex, List<String> list,
- boolean shouldCollectException) throws OnapCommandException {
- if (shouldCollectException) {
- list.add(ex.getMessage());
- } else {
- throw ex;
- }
- }
-
- private static void validateTags(List<String> schemaErrors, Map<String, ?> yamlMap,
- List<String> totalParams, List<String> mandatoryParams,
- String section) {
- //mrkanag capture invalid entries as well
- for (String param : totalParams) {
- boolean isMandatory = mandatoryParams.contains(param);
- boolean isYamlContains = yamlMap.containsKey(param);
- if (isMandatory) {
- if (!isYamlContains) {
- schemaErrors.add("Mandatory attribute '" + param + "' is missing under '" + section + "'");
- } else {
- String value = String.valueOf(yamlMap.get(param));
- if (value == null || value.isEmpty()) {
- schemaErrors.add("Mandatory attribute '" + param + "' under '" + section
- + "' shouldn't be null or empty");
- }
- }
- }
- }
- }
-
- /**
- * Validate Boolean.
- *
- * @param toValidate
- * string
- * @return boolean
- */
- protected static boolean validateBoolean(String toValidate) {
- return OnapCommandConfg.getSchemaAttrInfo(BOOLEAN_VALUE).contains(toValidate.toLowerCase());
- }
-
private static List<String> parseSchema(OnapCommand cmd,
final Map<String, ?> values,
boolean validate) throws OnapCommandException {
return exceptionList;
}
- private static String emptySection(String section) {
- return "The section '" + section + ":' cann't be null or empty";
- }
-
- private static String invalidBooleanValueMessage(String section, String attribute, String value) {
- return "The value '" + value + "' of '" + attribute + "' present under '" + section + "' should be boolean";
- }
-
- private static Set<String> validateHttpQueries(Map<String, Object> requestMap) {
- Map<String, Object> queries = (Map<String, Object>) requestMap.get(QUERIES);
- Set<String> queryParamNames = new HashSet<>();
- if (queries != null) {
- for (Entry<String, Object> entry : queries.entrySet()) {
- parseParameters(String.valueOf(entry.getValue()), queryParamNames);
- }
- }
- return queryParamNames;
- }
-
-
- private static Set<String> validateHttpHeaders(Map<String, Object> requestMap) {
-
- Map<String, Object> headers = (Map<String, Object>) requestMap.get(HEADERS);
- Set<String> headerParamNames = new HashSet<>();
- if (headers != null) {
- for (Entry<String, Object> entry : headers.entrySet()) {
- parseParameters(String.valueOf(entry.getValue()), headerParamNames);
- }
- }
- return headerParamNames;
- }
-
- private static Set<String> validateHttpBody(List<String> errorList, Map<String, Object> requestMap) {
- Set<String> bodyParamNames = new HashSet<>();
- Object bodyString = requestMap.get(BODY);
- if (bodyString == null) {
- return bodyParamNames;
- }
-
- String body = String.valueOf(bodyString);
- JSONObject obj = null;
- try {
- obj = new ObjectMapper().readValue(body, JSONObject.class);
- } catch (IOException e1) { // NOSONAR
- errorList.add(HTTP_BODY_FAILED_PARSING);
- }
- if (obj == null || "".equals(obj.toString())) {
- errorList.add(HTTP_BODY_JSON_EMPTY);
- }
- parseParameters(body, bodyParamNames);
-
- return bodyParamNames;
- }
-
- private static Set<String> validateHttpUri(List<String> errorList, Map<String, Object> requestMap) {
- Set<String> uriParamNames = new HashSet<>();
- String uri = (String) requestMap.get(URI);
- if (uri == null || uri.isEmpty()) {
- errorList.add(emptySection(URI));
- return uriParamNames;
- }
- parseParameters(uri, uriParamNames);
- return uriParamNames;
- }
-
- private static void parseParameters(String line, Set<String> paramNames) {
-
- int currentIdx = 0;
- while (currentIdx < line.length()) {
- int idxS = line.indexOf("${", currentIdx);
- if (idxS == -1) {
- break;
- }
- int idxE = line.indexOf("}", idxS);
- String paramName = line.substring(idxS + 2, idxE);
- paramNames.add(paramName.trim());
-
- currentIdx = idxE + 1;
- }
-
- }
-
- private static Set<String> getRequestParams(Map<String, ?> yamlMap) {
-
- Set<String> set = new HashSet<>();
-
- @SuppressWarnings("unchecked")
- List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS);
-
- if (inputParams != null) {
- for (Map<String, Object> map : inputParams) {
- for (Entry<String, Object> entry : map.entrySet()) {
- Object key = entry.getKey();
-
- if (NAME.equals(key)) {
- set.add(String.valueOf(entry.getValue()));
- break;
- }
- }
- }
- }
-
- return set;
- }
-
/**
* Load the schema.
*
* OnapHttpCommand
* @param schemaName
* schema name
- * @throws OnapCommandParameterNameConflict
- * param name conflict exception
- * @throws OnapCommandParameterOptionConflict
- * param option conflict exception
- * @throws OnapCommandInvalidParameterType
- * invalid param type exception
- * @throws OnapCommandInvalidPrintDirection
- * invalid print direction exception
- * @throws OnapCommandInvalidResultAttributeScope
- * invalid scope exception
- * @throws OnapCommandSchemaNotFound
- * schema not found
- * @throws OnapCommandInvalidSchema
- * invalid schema
- * @throws OnapCommandInvalidSchemaVersion
- * invalid schema version
+ * @throws OnapCommandException
+ * on error
*/
private static ArrayList<String> parseHttpSchema(OnapHttpCommand cmd,
final Map<String, ?> values,
return errorList;
}
+
+ private static void throwOrCollect(OnapCommandException ex, List<String> list, boolean shouldCollectException)
+ throws OnapCommandException {
+ if (shouldCollectException) {
+ list.add(ex.getMessage());
+ } else {
+ throw ex;
+ }
+ }
+
+ private static void validateTags(List<String> schemaErrors, Map<String, ?> yamlMap, List<String> totalParams,
+ List<String> mandatoryParams, String section) {
+ // mrkanag capture invalid entries as well
+ for (String param : totalParams) {
+ boolean isMandatory = mandatoryParams.contains(param);
+ boolean isYamlContains = yamlMap.containsKey(param);
+ if (isMandatory) {
+ if (!isYamlContains) {
+ schemaErrors.add("Mandatory attribute '" + param + "' is missing under '" + section + "'");
+ } else {
+ String value = String.valueOf(yamlMap.get(param));
+ if (value == null || value.isEmpty()) {
+ schemaErrors.add("Mandatory attribute '" + param + "' under '" + section
+ + "' shouldn't be null or empty");
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Validate Boolean.
+ *
+ * @param toValidate
+ * string
+ * @return boolean
+ */
+ protected static boolean validateBoolean(String toValidate) {
+ return OnapCommandConfg.getSchemaAttrInfo(BOOLEAN_VALUE).contains(toValidate.toLowerCase());
+ }
+
+ private static String emptySection(String section) {
+ return "The section '" + section + ":' cann't be null or empty";
+ }
+
+ private static String invalidBooleanValueMessage(String section, String attribute, String value) {
+ return "The value '" + value + "' of '" + attribute + "' present under '" + section + "' should be boolean";
+ }
+
+ private static Set<String> validateHttpQueries(Map<String, Object> requestMap) {
+ Map<String, Object> queries = (Map<String, Object>) requestMap.get(QUERIES);
+ Set<String> queryParamNames = new HashSet<>();
+ if (queries != null) {
+ for (Entry<String, Object> entry : queries.entrySet()) {
+ parseParameters(String.valueOf(entry.getValue()), queryParamNames);
+ }
+ }
+ return queryParamNames;
+ }
+
+
+ private static Set<String> validateHttpHeaders(Map<String, Object> requestMap) {
+
+ Map<String, Object> headers = (Map<String, Object>) requestMap.get(HEADERS);
+ Set<String> headerParamNames = new HashSet<>();
+ if (headers != null) {
+ for (Entry<String, Object> entry : headers.entrySet()) {
+ parseParameters(String.valueOf(entry.getValue()), headerParamNames);
+ }
+ }
+ return headerParamNames;
+ }
+
+ private static Set<String> validateHttpBody(List<String> errorList, Map<String, Object> requestMap) {
+ Set<String> bodyParamNames = new HashSet<>();
+ Object bodyString = requestMap.get(BODY);
+ if (bodyString == null) {
+ return bodyParamNames;
+ }
+
+ String body = String.valueOf(bodyString);
+ JSONObject obj = null;
+ try {
+ obj = new ObjectMapper().readValue(body, JSONObject.class);
+ } catch (IOException e1) { // NOSONAR
+ errorList.add(HTTP_BODY_FAILED_PARSING);
+ }
+ if (obj == null || "".equals(obj.toString())) {
+ errorList.add(HTTP_BODY_JSON_EMPTY);
+ }
+ parseParameters(body, bodyParamNames);
+
+ return bodyParamNames;
+ }
+
+ private static Set<String> validateHttpUri(List<String> errorList, Map<String, Object> requestMap) {
+ Set<String> uriParamNames = new HashSet<>();
+ String uri = (String) requestMap.get(URI);
+ if (uri == null || uri.isEmpty()) {
+ errorList.add(emptySection(URI));
+ return uriParamNames;
+ }
+ parseParameters(uri, uriParamNames);
+ return uriParamNames;
+ }
+
+ private static void parseParameters(String line, Set<String> paramNames) {
+
+ int currentIdx = 0;
+ while (currentIdx < line.length()) {
+ int idxS = line.indexOf("${", currentIdx);
+ if (idxS == -1) {
+ break;
+ }
+ int idxE = line.indexOf("}", idxS);
+ String paramName = line.substring(idxS + 2, idxE);
+ paramNames.add(paramName.trim());
+
+ currentIdx = idxE + 1;
+ }
+
+ }
+
+ private static Set<String> getRequestParams(Map<String, ?> yamlMap) {
+
+ Set<String> set = new HashSet<>();
+
+ @SuppressWarnings("unchecked")
+ List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS);
+
+ if (inputParams != null) {
+ for (Map<String, Object> map : inputParams) {
+ for (Entry<String, Object> entry : map.entrySet()) {
+ Object key = entry.getKey();
+
+ if (NAME.equals(key)) {
+ set.add(String.valueOf(entry.getValue()));
+ break;
+ }
+ }
+ }
+ }
+
+ return set;
+ }
+
private static void validateHttpResultMap(List<String> errorList, Map<String, ?> values) throws OnapCommandException {
Map<String, ?> valMap = (Map<String, ?>) values.get(HTTP);
List<Map<String, String>> attributes = (List<Map<String, String>>) ((Map<String, ?>)values.get(RESULTS)).get(ATTRIBUTES);
*
* @return list
*/
- public static List<Class<OnapCommand>> findOnapCommands() {
+ public static List<Class<OnapCommand>> discoverCommandPlugins() {
ServiceLoader<OnapCommand> loader = ServiceLoader.load(OnapCommand.class);
List<Class<OnapCommand>> clss = new ArrayList<>();
for (OnapCommand implClass : loader) {
inp.getReqQueries().put(h, replaceLineFromInputParameters(value, params));
}
- //mrkanag replaceLineFromInputParameters for result_map, to support input param in result output
return inp;
}
* @throws OnapCommandInvalidSchema
* exception
*/
- public static List<ExternalSchema> findAllExternalSchemas() throws OnapCommandException {
- List<ExternalSchema> extSchemas = new ArrayList<>();
+ public static List<SchemaInfo> discoverSchemas() throws OnapCommandException {
+ List<SchemaInfo> extSchemas = new ArrayList<>();
try {
- Resource[] res = getExternalResources(EXTERNAL_SCHEMA_PATH_PATERN);
+ Resource[] res = getExternalResources(SCHEMA_PATH_PATERN);
if (res != null && res.length > 0) {
Map<String, ?> resourceMap;
+
for (Resource resource : res) {
- resourceMap = getExternalSchemaMap(resource);
+ resourceMap = loadSchema(resource);
+
if (resourceMap != null && resourceMap.size() > 0) {
- ExternalSchema schema = new ExternalSchema();
- schema.setSchemaName(resource.getFilename());
+ SchemaInfo schema = new SchemaInfo();
+
schema.setSchemaURI(resource.getURI().toString());
- schema.setCmdName((String) resourceMap.get(NAME));
+
Object obj = resourceMap.get(OPEN_CLI_SCHEMA_VERSION);
schema.setVersion(obj.toString());
+ if (!schema.getVersion().equalsIgnoreCase(Constants.OPEN_CLI_SCHEMA_VERSION_VALUE_1_0)) {
+ LOG.info("Unsupported Schema version found " + schema.getSchemaURI());
+ continue;
+ }
+
+ schema.setSchemaName(resource.getFilename());
+ schema.setCmdName((String) resourceMap.get(NAME));
+
Map<String, ?> infoMap = (Map<String, ?>) resourceMap.get(Constants.INFO);
- if (infoMap != null && infoMap.get(Constants.COMMAND_TYPE) != null) {
- schema.setType(infoMap.get(Constants.COMMAND_TYPE).toString());
+ if (infoMap != null && infoMap.get(Constants.INFO_TYPE) != null) {
+ schema.setType(infoMap.get(Constants.INFO_TYPE).toString());
}
+
if (infoMap != null && infoMap.get(Constants.INFO_PRODUCT) != null) {
- schema.setCmdVersion(infoMap.get(Constants.INFO_PRODUCT).toString());
+ schema.setProduct(infoMap.get(Constants.INFO_PRODUCT).toString());
}
- if (resourceMap.get(Constants.HTTP) != null) {
- schema.setHttp("true");
- }
+ schema.setSchemaProfile(identitySchemaProfileType(resourceMap));
+
extSchemas.add(schema);
}
}
}
} catch (IOException e) {
- throw new OnapCommandDiscoveryFailed(EXTERNAL_SCHEMA_DIRECTORY, e);
+ throw new OnapCommandDiscoveryFailed(SCHEMA_DIRECTORY, e);
}
return extSchemas;
}
+ private static String identitySchemaProfileType(Map<String, ?> schemaYamlMap) {
+ if (schemaYamlMap.get(Constants.HTTP) != null) {
+ return Constants.HTTP_SCHEMA_PROFILE;
+ }
+
+ return Constants.BASIC_SCHEMA_PROFILE;
+ }
+
/**
* Returns all resources available under certain directory in class-path.
*
* @throws OnapCommandInvalidSchema
* exception
*/
- public static Map<String, ?> getExternalSchemaMap(Resource resource) throws OnapCommandInvalidSchema {
+ public static Map<String, ?> loadSchema(Resource resource) throws OnapCommandInvalidSchema {
Map<String, ?> values = null;
try {
values = (Map<String, ?>) new Yaml().load(resource.getInputStream());
* @throws OnapCommandDiscoveryFailed
* exception
*/
- public static void persist(List<ExternalSchema> schemas) throws OnapCommandDiscoveryFailed {
+ public static void persistSchemaInfo(List<SchemaInfo> schemas) throws OnapCommandDiscoveryFailed {
if (schemas != null) {
try {
Resource[] resources = getExternalResources(DATA_DIRECTORY);
if (resources != null && resources.length == 1) {
String path = resources[0].getURI().getPath();
- File file = new File(path + File.separator + EXTERNAL_DISCOVERY_FILE);
+ File file = new File(path + File.separator + DISCOVERY_FILE);
ObjectMapper mapper = new ObjectMapper();
mapper.writerWithDefaultPrettyPrinter().writeValue(file, schemas);
}
} catch (IOException e1) {
throw new OnapCommandDiscoveryFailed(DATA_DIRECTORY,
- EXTERNAL_DISCOVERY_FILE, e1);
+ DISCOVERY_FILE, e1);
}
}
}
- public static void persistP
arams(List<Param> params, String profileName) throws OnapCommandPersistProfileFailed {
+ public static void persistP
rofile(List<Param> params, String profileName) throws OnapCommandPersistProfileFailed {
if (params != null) {
try {
Resource[] resources = getExternalResources(DATA_DIRECTORY);
* @throws OnapCommandDiscoveryFailed
* exception
*/
- public static boolean isJsonFileDiscovered() throws OnapCommandDiscoveryFailed {
+ public static boolean isAlreadyDiscovered() throws OnapCommandDiscoveryFailed {
Resource resource = null;
try {
- resource = getExternalResource(EXTERNAL_DISCOVERY_FILE,
- DATA_DIRECTORY_JSON_PATTERN);
+ resource = getExternalResource(DISCOVERY_FILE,
+ DATA_PATH_JSON_PATTERN);
if (resource != null) {
return true;
}
} catch (IOException e) {
throw new OnapCommandDiscoveryFailed(DATA_DIRECTORY,
- EXTERNAL_DISCOVERY_FILE, e);
+ DISCOVERY_FILE, e);
}
return false;
* @throws OnapCommandDiscoveryFailed
* exception
*/
- public static List<ExternalSchema> loadExternalSchemasFromJson() throws OnapCommandException {
- List<ExternalSchema> schemas = new ArrayList<>();
- if (OnapCommandConfg.isDiscoverAlways() || !isJsonFileDiscovered()) {
- schemas = findAllExternalSchemas();
+ public static List<SchemaInfo> discoverOrLoadSchemas() throws OnapCommandException {
+ List<SchemaInfo> schemas = new ArrayList<>();
+ if (OnapCommandConfg.isDiscoverAlways() || !isAlreadyDiscovered()) {
+ schemas = discoverSchemas();
if (!schemas.isEmpty()) {
- persist(schemas);
+ persistSchemaInfo(schemas);
}
} else {
try {
- Resource resource = getExternalResource(EXTERNAL_DISCOVERY_FILE,
- DATA_DIRECTORY_JSON_PATTERN);
+ Resource resource = getExternalResource(DISCOVERY_FILE,
+ DATA_PATH_JSON_PATTERN);
if (resource != null) {
File file = new File(resource.getURI().getPath());
ObjectMapper mapper = new ObjectMapper();
- ExternalSchema[] list = mapper.readValue(file, ExternalSchema[].class);
+ SchemaInfo[] list = mapper.readValue(file, SchemaInfo[].class);
schemas.addAll(Arrays.asList(list));
}
} catch (IOException e) {
throw new OnapCommandDiscoveryFailed(DATA_DIRECTORY,
- EXTERNAL_DISCOVERY_FILE, e);
+ DISCOVERY_FILE, e);
}
}
try {
Resource resource = getExternalResource(profileName + ".json",
- DATA_DIRECTORY_JSON_PATTERN);
+ DATA_PATH_JSON_PATTERN);
if (resource != null) {
File file = new File(resource.getURI().getPath());
ObjectMapper mapper = new ObjectMapper();
* @throws OnapCommandDiscoveryFailed
* exception
*/
- public static ExternalSchema loadExternalSchemaFromJson(String cmd, String version) throws OnapCommandException {
- List<ExternalSchema> list = loadExternalSchemasFromJson();
- ExternalSchema schemaStr = null;
+ public static SchemaInfo getSchemaInfo(String cmd, String version) throws OnapCommandException {
+ List<SchemaInfo> list = discoverOrLoadSchemas();
+ SchemaInfo schemaStr = null;
if (list != null) {
- for (ExternalSchema schema : list) {
- if (cmd.equals(schema.getCmdName()) && version.equals(schema.getCmdVersion())) {
+ for (SchemaInfo schema : list) {
+ if (cmd.equals(schema.getCmdName()) && version.equals(schema.getProduct())) {
schemaStr = schema;
break;
}
package org.onap.cli.fw.utils;
import org.onap.cli.fw.cmd.CommandType;
+import org.onap.cli.fw.conf.Constants;
-public class ExternalSchema {
+import com.fasterxml.jackson.annotation.JsonIgnore;
+/**
+ * SchemaInfo is used in discovery caching.
+ *
+ */
+public class SchemaInfo {
+
+ /**
+ * Name of the schema file name
+ */
private String schemaName;
+
+ /**
+ * Schema location in complete path
+ */
private String schemaURI;
+
private String cmdName;
- private String cmdVersion;
+
+ private String product;
+
+ /**
+ * OCS version
+ */
private String version;
+
private String type = CommandType.CMD.name();
- private String http = "false";
+
+ private String schemaProfile = Constants.BASIC_SCHEMA_PROFILE;
public String getSchemaName() {
return schemaName;
this.version = version;
}
- public String getCmdVersion() {
- return cmdVersion;
+ public String getProduct() {
+ return product;
}
- public void setCmdVersion(String cmdVersion) {
- this.cmdVersion = cmdVersion;
+ public void setProduct(String cmdVersion) {
+ this.product = cmdVersion;
}
public String getSchemaURI() {
this.schemaURI = schemaURI;
}
- public String getHttp() {
- return http;
+ public String getSchemaProfile() {
+ return schemaProfile;
}
- public void setHttp(String internal) {
- this.http = internal;
+ public void setSchemaProfile(String internal) {
+ this.schemaProfile = internal;
}
+ @JsonIgnore
public boolean isHttp() {
- return this.getHttp().equals("true");
+ return this.getSchemaProfile().equals(Constants.HTTP_SCHEMA_PROFILE);
}
public String getType() {
* This command helps to test the Command functionalities.
*
*/
-@OnapCommandSchema(name = "sample-test", version="open-cli", schema = "sample-test-schema.yaml")
+@OnapCommandSchema(schema = "sample-test-schema.yaml")
public class OnapCommandSample extends OnapCommand {
public OnapCommandSample() {
@Test
public void onapCommandRegistrationFailedTest() throws OnapCommandException {
- @OnapCommandSchema(name = "Test2", version= "open-cli", schema = "sample-test-schema.yaml")
+ @OnapCommandSchema(schema = "sample-test-schema.yaml")
class Test extends OnapCommand {
@Override
}
}
-@OnapCommandSchema(name = OnapCommandTest.CMD_NAME, version = "open-cli", schema = "sample-test-schema.yaml")
+@OnapCommandSchema(schema = "sample-test-schema.yaml")
class OnapCommandTest extends OnapCommand {
public OnapCommandTest() {
}
-@OnapCommandSchema(name = OnapCommandTest1.CMD_NAME, version = "open-cli", schema = "test-schema.yaml")
+@OnapCommandSchema(schema = "test-schema.yaml")
class OnapCommandTest1 extends OnapCommand {
public OnapCommandTest1() {
String version = onapCommandResultAttribute.get(4).getValues().get(0);
assertTrue(s1Number.equalsIgnoreCase("1"));
- assertTrue(cmdName.equalsIgnoreCase("sample-test1"));
- assertTrue(cmdFile.equalsIgnoreCase("sample-test1-schema-http.yaml"));
- assertTrue(version.equalsIgnoreCase("1.0"));
- assertTrue(cmdVer.equalsIgnoreCase("open-cli"));
-
}
}
@Test
public void externalSchemaTest() {
- ExternalSchema schema = new ExternalSchema();
+ SchemaInfo schema = new SchemaInfo();
schema.setCmdName("cmdName");
schema.setSchemaName("schemaName");
schema.setVersion("version");
@Test
public void findOnapCommandsTest() {
- List<Class<OnapCommand>> cmds = OnapCommandUtils.findOnapCommands();
+ List<Class<OnapCommand>> cmds = OnapCommandUtils.discoverCommandPlugins();
assertTrue(cmds.size() == 6);
}
public void zendExceptionTest4() throws OnapCommandException {
mockExternalResources();
- OnapCommandUtils.loadExternalSchemasFromJson();
+ OnapCommandUtils.discoverOrLoadSchemas();
}
@Test(expected = OnapCommandException.class)
public void zendExceptionTest5() throws OnapCommandException {
mockExternalResources();
- OnapCommandUtils.findAllExternalSchemas();
+ OnapCommandUtils.discoverSchemas();
}
@Test(expected = OnapCommandException.class)
public void zendExceptionTest6() throws OnapCommandException {
mockExternalResources();
- OnapCommandUtils.persist(new ArrayList<ExternalSchema>());
+ OnapCommandUtils.persistSchemaInfo(new ArrayList<SchemaInfo>());
}
@Test(expected = OnapCommandHelpFailed.class)
assert info != null;
}
- @OnapCommandSchema(name = "sample-test-info", version = "open-cli", schema = "sample-test-info.yaml")
+ @OnapCommandSchema(schema = "sample-test-info.yaml")
class OnapCommandSampleInfo extends OnapCommand {
@Override
protected void run() throws OnapCommandException {
}
}
- @OnapCommandSchema(name = "sample-test", version = "open-cli", schema = "sample-test-schema.yaml")
+ @OnapCommandSchema(schema = "sample-test-schema.yaml")
class OnapCommandSample extends OnapCommand {
@Override
protected void run() throws OnapCommandException {
}
}
- @OnapCommandSchema(name = "sample-swagger-test", version = "open-cli", schema = "sample-test-schema-swagger.yaml")
+ @OnapCommandSchema(schema = "sample-test-schema-swagger.yaml")
class OnapSwaggerBasedCommandSample extends OnapSwaggerCommand {
@Override
}
}
- @OnapCommandSchema(name = "sample-http-test", version = "open-cli", schema = "sample-test-schema-http.yaml")
+ @OnapCommandSchema(schema = "sample-test-schema-http.yaml")
class OnapHttpCommandSample extends OnapHttpCommand {
@Override
OnapCommand cmd = registrar.get("sample-test");
cmd.printVersion();
registrar.listCommands();
-
}
}
* This command helps to test the Command functionalities.
*
*/
-@OnapCommandSchema(name = "sample-test", version = "open-cli", schema = "sample-test-schema.yaml")
+@OnapCommandSchema(schema = "sample-test-schema.yaml")
public class OnapCommandSampleTest extends OnapCommand {
@Override
import org.onap.cli.fw.cmd.BasicAuthLoginCommand;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "basic-login", version = "onap-1.0", type = "auth", schema = "basic-login-onap-1-0.yaml")
+@OnapCommandSchema(schema = "basic-login-onap-1-0.yaml")
public class OnapBasicAuthLoginCommand extends BasicAuthLoginCommand {
@Override
protected void run() throws OnapCommandException {
- super.run();
+ super.run();
}
}
import org.onap.cli.fw.cmd.BasicAuthLogoutCommand;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "basic-logout", version = "onap-1.0", type = "auth", schema = "basic-logout-onap-1-0.yaml")
+@OnapCommandSchema(schema = "basic-logout-onap-1-0.yaml")
public class OnapBasicAuthLogoutCommand extends BasicAuthLogoutCommand {
@Override
import org.onap.cli.fw.cmd.BasicAuthLoginCommand;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "sdc-basic-login", version = "onap-1.0", type = "auth", schema = "basic-login-onap-sdc-1-0.yaml")
+@OnapCommandSchema(schema = "basic-login-onap-sdc-1-0.yaml")
public class OnapSdcBasicAuthLoginCommand extends BasicAuthLoginCommand {
@Override
protected void run() throws OnapCommandException {
- super.run();
+ super.run();
}
}
import org.onap.cli.fw.cmd.BasicAuthLoginCommand;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "basic-login", version = "onap-1.1", type = "auth", schema = "basic-login-onap-1-1.yaml")
+@OnapCommandSchema(schema = "basic-login-onap-1-1.yaml")
public class OnapBasicAuthLoginCommandAmesterdam extends BasicAuthLoginCommand {
@Override
protected void run() throws OnapCommandException {
- super.run();
+ super.run();
}
}
import org.onap.cli.fw.cmd.BasicAuthLogoutCommand;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "basic-logout", version = "onap-1.1", type = "auth", schema = "basic-logout-onap-1-1.yaml")
+@OnapCommandSchema(schema = "basic-logout-onap-1-1.yaml")
public class OnapBasicAuthLogoutCommandAmesterdam extends BasicAuthLogoutCommand {
@Override
import org.onap.cli.fw.cmd.BasicAuthLoginCommand;
import org.onap.cli.fw.error.OnapCommandException;
-@OnapCommandSchema(name = "sdc-basic-login", version = "onap-1.1", type = "auth", schema = "basic-login-onap-sdc-1-1.yaml")
+@OnapCommandSchema(schema = "basic-login-onap-sdc-1-1.yaml")
public class OnapSdcBasicAuthLoginCommandAmesterdam extends BasicAuthLoginCommand {
@Override
protected void run() throws OnapCommandException {
- super.run();
+ super.run();
}
}
+++ /dev/null
-/*
- * Copyright 2017 Huawei Technologies Co., Ltd.
- *
- * 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.onap.cli.cmd.cs.msb;
-
-import org.onap.cli.fw.OnapCommandSchema;
-import org.onap.cli.fw.cmd.OnapHttpCommand;
-
-@OnapCommandSchema(name = "microservice-create", version = "onap-1.1", schema = "microservice-create-schema.yaml")
-public class OnapServiceCreateCommand extends OnapHttpCommand {
-}
+++ /dev/null
-/*
- * Copyright 2017 Huawei Technologies Co., Ltd.
- *
- * 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.onap.cli.cmd.cs.msb;
-
-import org.onap.cli.fw.OnapCommandSchema;
-import org.onap.cli.fw.cmd.OnapHttpCommand;
-
-@OnapCommandSchema(name = "microservice-delete", version = "onap-1.1", schema = "microservice-delete-schema.yaml")
-public class OnapServiceDeleteCommand extends OnapHttpCommand {
-}
+++ /dev/null
-/*
- * Copyright 2017 Huawei Technologies Co., Ltd.
- *
- * 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.onap.cli.cmd.cs.msb;
-
-import org.onap.cli.fw.OnapCommandSchema;
-import org.onap.cli.fw.cmd.OnapHttpCommand;
-
-@OnapCommandSchema(name = "microservice-list", version = "onap-1.1", schema = "microservice-list-schema.yaml")
-public class OnapServiceListCommand extends OnapHttpCommand {
-}
+++ /dev/null
-org.onap.cli.cmd.cs.msb.OnapServiceListCommand
-org.onap.cli.cmd.cs.msb.OnapServiceShowCommand
-org.onap.cli.cmd.cs.msb.OnapServiceDeleteCommand
-org.onap.cli.cmd.cs.msb.OnapServiceCreateCommand
\ No newline at end of file
/**
* Hello world.
*/
-@OnapCommandSchema(name = "hello-world", version = "sample-1.0", schema = "hello-world.yaml")
+@OnapCommandSchema(schema = "hello-world.yaml")
public class OnapHelloWorldCommand extends OnapCommand {
@Override
import org.junit.Test;
import org.onap.cli.fw.OnapCommandRegistrar;
import org.onap.cli.fw.error.OnapCommandException;
-import org.onap.cli.fw.utils.ExternalSchema;
+import org.onap.cli.fw.utils.SchemaInfo;
import org.onap.cli.main.OnapCli;
import org.onap.cli.moco.OnapCommandHttpMocoServer;
import org.onap.cli.moco.OnapCommandSample;
OnapCommandRegistrar.getRegistrar().setEnabledProductVersion(version);
System.out.println(version);
System.out.println("==========================\n\n");
- for (ExternalSchema sch : OnapCommandRegistrar.getRegistrar().listCommandInfo()) {
- if (sch.getCmdVersion().equals(version)) {
+ for (SchemaInfo sch : OnapCommandRegistrar.getRegistrar().listCommandInfo()) {
+ if (sch.getProduct().equals(version)) {
System.out.println(
"************************* validate '" + sch.getCmdName() + "' *******************************");
OnapCommandRegistrar.getRegistrar().setEnabledProductVersion("open-cli");
System.out.println(version);
System.out.println("==========================\n\n");
int i = 1;
- for (ExternalSchema sch : OnapCommandRegistrar.getRegistrar().listCommandInfo()) {
- if (sch.getCmdVersion().equals(version)) {
+ for (SchemaInfo sch : OnapCommandRegistrar.getRegistrar().listCommandInfo()) {
+ if (sch.getProduct().equals(version)) {
System.out.println("[" + i++ + "] " + sch.getCmdName());
System.out.println("-----------------------------------------------\n\n");
this.handle(new String[] { sch.getCmdName(), "-h"});
@Ignore
@Test
- public void validateCommands() throws OnapCommandException {
+ public void verifyCommandResults() throws OnapCommandException {
OnapCommandHttpMocoServer server = new OnapCommandHttpMocoServer();
server.verifySamples();
}
Code Review / cli.git / commitdiff