public boolean isCommandInternal() {
return onapService.getName() != null
- && onapService.getName().equalsIgnoreCase(OnapCommandConfg.getInternalCmd());
+ && onapService.getName().equalsIgnoreCase(OnapCommandConfg.getInternalCmd())
+ && this.type.equals(CommandType.CMD);
}
/*
}
try {
- OnapCredentials creds = OnapCommandUtils.fromParameters(this.getParameters());
-
// For auth type commands, login and logout logic is not required
boolean isAuthRequired = !this.onapService.isNoAuth()
&& "false".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH).getValue())
if (!isCommandInternal()) {
this.authClient = new OnapAuthClient(
- creds,
- this.getResult().isDebug(),
- this.getService(),
- this.getParameters());
+ this,
+ this.getResult().isDebug());
}
if (isAuthRequired) {
* Get my service base path (endpoint).
*/
protected String getBasePath() throws OnapCommandException {
- return this.authClient.getServiceBasePath(this.getService());
+ return this.authClient.getServiceUrl();
}
/**
public class OnapCommandRegistrar {
private Map<String, Class<? extends OnapCommand>> registry = new HashMap<>();
+ private Map<String, String> authCmds = new HashMap<>();
+
private Set<String> availableProductVersions = new HashSet<>();
private String enabledProductVersion = OnapCommandConfg.getEnabledProductVersion();
this.registry.put(name + ":" + version, cmd);
this.availableProductVersions.add(version);
+
}
/**
private OnapCommand get(String cmdName, String version) throws OnapCommandException {
Class<? extends OnapCommand> cls = registry.get(cmdName + ":" + version);
+ //mrkanag: Restrict auth/catalog type commands only available during devMode. in production
+ //don't expose the auth type and catalog type commands
+
if (cls == null) {
throw new OnapCommandNotFound(cmdName, version);
}
import org.apache.http.HttpStatus;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.auth.BasicScheme;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandRegistrar;
import org.onap.cli.fw.conf.Constants;
import org.onap.cli.fw.conf.OnapCommandConfg;
import org.onap.cli.fw.error.OnapCommandException;
import org.onap.cli.fw.error.OnapCommandInvalidParameterValue;
import org.onap.cli.fw.error.OnapCommandLoginFailed;
import org.onap.cli.fw.error.OnapCommandLogoutFailed;
+import org.onap.cli.fw.error.OnapCommandNotFound;
import org.onap.cli.fw.error.OnapCommandServiceNotFound;
import org.onap.cli.fw.http.HttpInput;
import org.onap.cli.fw.http.HttpResult;
import org.onap.cli.fw.http.OnapHttpConnection;
+import org.onap.cli.fw.input.OnapCommandParameter;
+import org.onap.cli.fw.output.OnapCommandResultAttribute;
+import org.onap.cli.fw.utils.OnapCommandUtils;
import com.jayway.jsonpath.JsonPath;
-import org.onap.cli.fw.input.OnapCommandParameter;
/**
* Onap Auth client helps to do login and logout.
*/
public class OnapAuthClient {
- /*
- * Onap credentials
- */
+ private OnapCommand cmd = null;
+
private OnapHttpConnection http = null;
- private OnapCredentials creds = null;
-
- private OnapService service = new OnapService();
-
- private Map<String, String> paramMap = new HashMap<>();
-
- public OnapAuthClient(OnapCredentials creds, boolean debug, OnapService service, List<OnapCommandParameter> params) throws OnapCommandHttpFailure, OnapCommandInvalidParameterValue {
- this.creds = creds;
- this.service = service;
- for (OnapCommandParameter param : params) {
- paramMap.put(param.getName(), param.getValue().toString());
- }
-
- this.http = new OnapHttpConnection(creds.getHostUrl().startsWith("https"), debug);
+ public OnapAuthClient(OnapCommand cmd, boolean debug) throws OnapCommandHttpFailure, OnapCommandInvalidParameterValue {
+ this.cmd = cmd;
+ this.http = new OnapHttpConnection(debug);
}
/**
* Login.
*
- * @throws OnapCommandLoginFailed
- * LoginFailed Exception
- * @throws OnapCommandHttpFailure
- * Http request failed
- * @throws OnapCommandExecutionFailed
- * cmd exec failed
- * @throws OnapCommandServiceNotFound
- * service not found
+ * @throws OnapCommandException
+ * exception
*/
public void login() throws OnapCommandException {
return;
}
- if (this.service.getAuthType().equalsIgnoreCase(Constants.AUTH_BASIC)) {
- String authToken = BasicScheme.authenticate(new UsernamePasswordCredentials(
- creds.getUsername(), creds.getPassword()), "UTF-8", false).getValue();
-
- Map<String, String> mapHeaders = OnapCommandConfg.getBasicCommonHeaders(this.paramMap);
- mapHeaders.putAll(OnapCommandConfg.getServiceHeaders(this.service.getName(), this.paramMap));
- mapHeaders.put(OnapCommandConfg.getXAuthTokenName(), authToken);
-
- this.http.setCommonHeaders(mapHeaders);
- return;
+ OnapCommand login = this.findAuthCommand("login");
+
+ OnapCommandUtils.copyParamsFrom(this.cmd, login);
+ login.getParametersMap().get(Constants.DEAFULT_PARAMETER_HOST_URL).setValue(this.getServiceUrl(login));
+ login.execute();
+
+ //It is safely assumed that all outputs are considered as common http headers.
+ Map<String, String> headers = new HashMap<>();
+ for (OnapCommandResultAttribute attr: login.getResult().getRecords()) {
+ String headerValue = attr.getValues().get(0);
+ if (headerValue != null && !headerValue.isEmpty()) {
+ headers.put(attr.getName(), attr.getValues().get(0));
+ }
}
-
- //TODO mrkanag add support for aaf here
+
+ this.http.setCommonHeaders(headers);
}
/**
* Logout.
*
- * @throws OnapCommandExecutionFailed
- * cmd exec failed
- * @throws OnapCommandServiceNotFound
- * service not found
- * @throws OnapCommandLogoutFailed
- * logout failed
- * @throws OnapCommandHttpFailure
+ * @throws OnapCommandException
* exception
*/
public void logout() throws OnapCommandException {
return;
}
+ OnapCommand logout = this.findAuthCommand("logout");
+
+ OnapCommandUtils.copyParamsFrom(this.cmd, logout);
+
+ logout.execute();
+
this.http.close();
}
/**
* Find given service base path.
*
- * @param srv
- * onap service
- * @return string
- * @throws OnapCommandExecutionFailed
- * Cmd execution failed exception
- * @throws OnapCommandServiceNotFound
- * Service not found
- * @throws OnapCommandHttpFailure
- * http request failed
+ * @throws OnapCommandException
+ * exception
*/
- public String getServiceBasePath(OnapService srv) throws OnapCommandException {
- if (srv.getName().equals(OnapCommandConfg.getApiGateway())) {
- return this.getApiGatewayUrl();
- } else if (srv.isModeDirect()){
- return this.creds.getHostUrl();
- }
-
-
- HttpInput input = new HttpInput().setUri(this.creds.getHostUrl()
- + String.format(Constants.MSB_SERVICE_URI, srv.getName(), srv.getVersion()));
- HttpResult result = this.http.get(input);
-
- if (result.getStatus() == HttpStatus.SC_NOT_FOUND) {
- throw new OnapCommandServiceNotFound(srv.toString());
- }
- if (!result.isSuccess()) {
- throw new OnapCommandExecutionFailed("Failed to retrive service " + srv.toString());
- }
+ public String getServiceUrl() throws OnapCommandException {
+ return this.getServiceUrl(this.cmd);
+ }
- try {
- return this.creds.getHostUrl() + JsonPath.read(result.getBody(), "url");
- } catch (Exception e) {
- throw new OnapCommandExecutionFailed(e, srv.toString());
+ private String getServiceUrl(OnapCommand cmd) throws OnapCommandException {
+ if (cmd.getService().isModeDirect()){
+ return cmd.getParametersMap().get(Constants.DEAFULT_PARAMETER_HOST_URL).getValue().toString();
+ } else { //Catalog mode
+ OnapCommand catalog = OnapCommandRegistrar.getRegistrar().get("catalog");
+
+ OnapCommandUtils.copyParamsFrom(cmd, catalog);
+
+ catalog.execute();
+
+ String hostUrl = catalog.getResult().getRecordsMap().get(Constants.CATALOG_SERVICE_HOST_URL).getValues().get(0);
+ hostUrl = hostUrl.trim();
+ if (hostUrl.endsWith("/")) {
+ hostUrl = hostUrl.substring(0, hostUrl.length()-1);
+ }
+
+ String basePath = catalog.getResult().getRecordsMap().get(Constants.CATALOG_SERVICE_BASE_PATH).getValues().get(0);
+ basePath = basePath.trim();
+ if (basePath.startsWith("/")) {
+ basePath = basePath.substring(1);
+ }
+
+ return hostUrl + "/" + basePath;
}
}
- private String getAuthUrl() throws OnapCommandException {
- OnapService srv = new OnapService();
- srv.setName(Constants.AUTH_SERVICE);
- srv.setVersion(Constants.AUTH_SERVICE_VERSION);
- return this.getServiceBasePath(srv);
- }
-
- private String getApiGatewayUrl() {
- return this.creds.getHostUrl() + Constants.MSB_URI;
- }
public String getDebugInfo() {
return this.http.getDebugInfo();
}
/**
- * Http call to auth service.
+ * Http call to external service.
*
* @param input
* http input
public HttpResult run(HttpInput input) throws OnapCommandHttpFailure {
return this.http.request(input);
}
+
+ private OnapCommand findAuthCommand(String authAction) throws OnapCommandException {
+ OnapCommand auth = null;
+ try {
+ //Find the auth command for the given service and version under current enabled product
+ auth = OnapCommandRegistrar.getRegistrar().get(
+ this.cmd.getService().getName() + "-" +
+ this.cmd.getService().getVersion() + "-" +
+ this.cmd.getService().getAuthType() + "-" + authAction);
+ } catch (OnapCommandNotFound e) {
+ try {
+ //Find the auth command for the given service under current enabled product
+ auth = OnapCommandRegistrar.getRegistrar().get(
+ this.cmd.getService().getName() + "-" +
+ this.cmd.getService().getAuthType() + "-" + authAction);
+ } catch (OnapCommandNotFound e1) {
+ //Find the auth command for current enabled product
+ auth = OnapCommandRegistrar.getRegistrar().get(
+ this.cmd.getService().getAuthType() + "-" + authAction);
+ }
+ }
+
+ return auth;
+ }
}
--- /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.fw.cmd;
+
+import java.util.Map;
+
+import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.impl.auth.BasicScheme;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandSchema;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.input.OnapCommandParameter;
+
+@OnapCommandSchema(name = "basic-login", version = "cli-1.0", type = "auth", schema = "basic-login.yaml")
+public class BasicAuthLoginCommand extends OnapCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+
+ //get the input arguments
+ Map<String, OnapCommandParameter> paramMap = getParametersMap();
+ OnapCommandParameter usernameParam = paramMap.get("username");
+ String username = usernameParam.getValue().toString();
+ OnapCommandParameter usernamePassword = paramMap.get("password");
+ String password = usernamePassword.getValue().toString();
+
+ //Execute the command to get token
+ String authToken = BasicScheme.authenticate(new UsernamePasswordCredentials(
+ username, password), "UTF-8", false).getValue();
+
+ //Fill out the result part
+ this.getResult().getRecordsMap().get("Authorization").getValues().add(authToken);
+ }
+}
--- /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.fw.cmd;
+
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandSchema;
+import org.onap.cli.fw.error.OnapCommandException;
+
+@OnapCommandSchema(name = "basic-logout", version = "cli-1.0", type = "auth", schema = "basic-logout.yaml")
+public class BasicAuthLogoutCommand extends OnapCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ //do nothing // NOSONAR
+ }
+}
--- /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.fw.cmd;
+
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandSchema;
+import org.onap.cli.fw.error.OnapCommandException;
+
+@OnapCommandSchema(name = "catalog", version = "cli-1.0", type = "catalog", schema = "catalog.yaml")
+public class CatalogCommand extends OnapCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ }
+}
@Override
protected void run() throws OnapCommandException {
HttpInput httpInput = OnapCommandUtils.populateParameters(this.getParametersMap(), this.getInput());
- httpInput.setUri(this.authClient.getServiceBasePath(this.getService()) + httpInput.getUri());
+ httpInput.setUri(this.authClient.getServiceUrl() + httpInput.getUri());
HttpResult output = this.authClient.run(httpInput);
public static final String SPL_ENTRY_UUID = "uuid";
public static final String SPL_ENTRY_ENV = "env:";
+ 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() {
}
private static final long serialVersionUID = 6676137916079057963L;
public OnapCommandNotFound(String cmdName, String version) {
- super("0x6003", "Command " + cmdName + " is not available for product version " + version +
- ". so please check command name or product version set in env variable CLI_PRODUCT_VERSION or cli.product.version in onap.properties");
+ super("0x6003", "Command " + cmdName + " is not available for product version " + version);
}
}
/**
* OnapHttpConnection Constructor.
*
- * @param isSecured
- * boolean
* @param debug
* boolean
* @throws OnapCommandHttpFailure
* exception
*/
- public OnapHttpConnection(boolean isSecured, boolean debug) throws OnapCommandHttpFailure {
- try {
- if (isSecured) {
- SSLContext sslContext = SSLContext.getInstance(Constants.SSLCONTEST_TLS);
- sslContext.init(null, new TrustManager[] { new TrustAllX509TrustManager() },
- new java.security.SecureRandom());
- X509HostnameVerifier hostnameVerifier = new AllowAllHostnameVerifier();
- Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
- .<ConnectionSocketFactory>create()
- .register("https", new SSLConnectionSocketFactory(sslContext, hostnameVerifier)).build();
- HttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
-
- this.httpClient = HttpClients.custom().setConnectionManager(connManager)
- .setRedirectStrategy(new LaxRedirectStrategy()).build();
- } else {
- this.httpClient = HttpClients.createDefault();
- }
- } catch (Exception e) {
- throw new OnapCommandHttpFailure(e);
- }
-
+ public OnapHttpConnection(boolean debug) throws OnapCommandHttpFailure {
this.debug = debug;
}
+ private void initHttpClient(boolean isSecured) throws OnapCommandHttpFailure {
+ if (this.httpClient == null) {
+ try {
+ if (isSecured) {
+ SSLContext sslContext = SSLContext.getInstance(Constants.SSLCONTEST_TLS);
+ sslContext.init(null, new TrustManager[] { new TrustAllX509TrustManager() },
+ new java.security.SecureRandom());
+ X509HostnameVerifier hostnameVerifier = new AllowAllHostnameVerifier();
+ Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
+ .<ConnectionSocketFactory>create()
+ .register("https", new SSLConnectionSocketFactory(sslContext, hostnameVerifier)).build();
+ HttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
+
+ this.httpClient = HttpClients.custom().setConnectionManager(connManager)
+ .setRedirectStrategy(new LaxRedirectStrategy()).build();
+ } else {
+ this.httpClient = HttpClients.createDefault();
+ }
+ } catch (Exception e) {
+ throw new OnapCommandHttpFailure(e);
+ }
+ }
+ }
+
public String getDebugInfo() {
return this.debugDetails;
}
updateInputFromCookies(input, cookieStore);
HttpContext localContext = new BasicHttpContext();
localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
-
+
+ this.initHttpClient(input.getUri().startsWith("https"));
+
HttpResponse resp = this.httpClient.execute(requestBase, localContext);
String respContent = this.getResponseBody(resp);
result.setBody(respContent);
}
- List<String> sections = Arrays.asList(NAME, DESCRIPTION, SERVICE,
+ List<String> sections = Arrays.asList(NAME, DESCRIPTION, VERSION, COMMAND_TYPE, SERVICE,
DEFAULT_PARAMETERS, PARAMETERS, RESULTS);
for (String key : sections) {
break;
case VERSION:
- srv.setVersion(serviceMap.get(key1));
+ srv.setVersion(serviceMap.get(key1).toString());
break;
case AUTH:
}
return schemaStr;
}
+
+ /**
+ * Copy the parameters across the commands, mainly used for catalog, login and logout commands
+ *
+ * @throws OnapCommandInvalidParameterValue
+ */
+ public static void copyParamsFrom(OnapCommand from, OnapCommand to) throws OnapCommandInvalidParameterValue {
+ for (OnapCommandParameter param: to.getParameters()) {
+
+ OnapCommandParameter fromParam = from.getParametersMap().get(param.getName());
+
+ if (fromParam != null) {
+ param.setValue(fromParam.getValue());
+ param.setDefaultValue(fromParam.getDefaultValue());
+ } else if (param.getName().equalsIgnoreCase(Constants.CATALOG_SERVICE_NAME)) { // for catalog cmd
+ param.setValue(from.getService().getName());
+ } else if (param.getName().equalsIgnoreCase(Constants.CATALOG_SERVICE_VERSION)) { // for catalog cmd
+ param.setValue(from.getService().getVersion());
+ }
+ }
+ }
}
org.onap.cli.fw.cmd.OnapSchemaValidateCommand
org.onap.cli.fw.cmd.OnapSchemaRefreshCommand
+org.onap.cli.fw.cmd.BasicAuthLoginCommand
+org.onap.cli.fw.cmd.BasicAuthLogoutCommand
+org.onap.cli.fw.cmd.CatalogCommand
--- /dev/null
+open_cli_schema_version: 1.0
+name: basic-login
+description: basic login auth command
+version: cli-1.0
+type: auth
+
+service:
+ name: onap-cli
+ version: 1.0.0
+
+results:
+ direction: portrait
+ attributes:
+ - name: Authorization
+ description: Authorization
+ scope: short
+ type: string
--- /dev/null
+open_cli_schema_version: 1.0
+
+name: basic-logout
+
+description: basic logout auth command
+
+version: cli-1.0
+
+type: auth
+
+service:
+ name: onap-cli
+ version: 1.0.0
--- /dev/null
+open_cli_schema_version: 1.0
+
+name: catalog
+
+description: cli catalog command to find the base path for service.
+
+version: cli-1.0
+
+type: catalog
+
+service:
+ auth: none
+ name: onap-cli
+ version: 1.0.0
+ mode: direct
+
+parameters:
+ - name: catalog-service-name
+ type: string
+ description: service name registered in catalog service
+ short_option: l
+ long_option: catalog-service-name
+ is_optional: false
+ - name: catalog-service-version
+ type: string
+ description: service version registered in catalog service
+ short_option: i
+ long_option: catalog-service-version
+ is_optional: false
+results:
+ direction: portrait
+ attributes:
+ - name: catalog-service-host-url
+ description: Service connection url
+ scope: short
+ type: string
+ default_value: ${host-url}
+ - name: catalog-service-base-path
+ description: service base path, to append with host-url for connecting the service.
+ scope: short
+ type: string
+ default_value: /
\ No newline at end of file
import mockit.Mock;
import mockit.MockUp;
+@Ignore
public class OnapAuthClientTest {
OnapAuthClient client;
OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
OnapService service = new OnapService();
List<OnapCommandParameter> params = new ArrayList<>();
- client = new OnapAuthClient(creds, true, service, params);
+ client = new OnapAuthClient(null, false);
}
@Test
OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
OnapService service = new OnapService();
List<OnapCommandParameter> params = new ArrayList<>();
- OnapAuthClient client = new OnapAuthClient(creds, true, service, params);
if (OnapCommandConfg.isAuthIgnored()) {
client.getDebugInfo();
client.login();
OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
OnapService service = new OnapService();
List<OnapCommandParameter> params = new ArrayList<>();
- OnapAuthClient client = new OnapAuthClient(creds, true, service, params);
if (OnapCommandConfg.isAuthIgnored()) {
client.logout();
}
OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
OnapService service = new OnapService();
List<OnapCommandParameter> params = new ArrayList<>();
- OnapAuthClient client = new OnapAuthClient(creds, true, service, params);
OnapService srv = new OnapService();
srv.setName("msb");
- String msb = client.getServiceBasePath(srv);
+ String msb = client.getServiceUrl();
assertEquals("http://192.168.99.10:80/api/microservices/v1", msb);
}
public void onapCommandNotFoundTest() {
OnapCommandNotFound failed = new OnapCommandNotFound("Test", "1.0");
- assertEquals("0x6003::Command Test is not available for product version 1.0."
- + " so please check command name or product version set in env variable CLI_PRODUCT_VERSION or"
- + " cli.product.version in onap.properties", failed.getMessage());
+ assertEquals("0x6003::Command Test is not available for product version 1.0", failed.getMessage());
}
@Test
}
};
inp.setMethod("get");
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.getDebugInfo();
con.get(inp);
};
inp.setMethod("post");
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.post(inp);
}
inp.setMethod("post");
inp.setBinaryData(true);
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.post(inp);
}
}
};
inp.setMethod("put");
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.put(inp);
}
}
};
inp.setMethod("delete");
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.delete(inp);
}
}
};
inp.setMethod("other");
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.request(inp);
}
@Test()
public void httpUnSecuredCloseExceptionTest() throws OnapCommandHttpFailure {
inp.setMethod("other");
- con = new OnapHttpConnection(false, true);
+ con = new OnapHttpConnection(true);
con.close();
}
inp.setBody("body");
inp.setReqHeaders(new HashMap<String, String>());
inp.setReqQueries(new HashMap<String, String>());
- inp.setUri("http://192.168.99.10:80");
- OnapHttpConnection con = new OnapHttpConnection(true, false);
+ inp.setUri("https://192.168.99.10:80");
+ OnapHttpConnection con = new OnapHttpConnection(false);
con.get(inp);
} catch (OnapCommandHttpFailure e) {
assertEquals("0x3001::IO Exception", e.getMessage());
@Test
public void findOnapCommandsTest() {
List<Class<OnapCommand>> cmds = OnapCommandUtils.findOnapCommands();
- assertTrue(cmds.size() == 3);
+ assertTrue(cmds.size() == 6);
}
@Test
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ 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.
+ -->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+ http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.onap.cli</groupId>
+ <artifactId>cli-plugins</artifactId>
+ <version>1.0.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>cli-plugins-auth</artifactId>
+ <name>cli/plugins/auth</name>
+ <packaging>jar</packaging>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+</project>
--- /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.auth;
+
+import org.onap.cli.fw.OnapCommandSchema;
+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")
+public class OnapBasicAuthLoginCommand extends BasicAuthLoginCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ 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.auth;
+
+import org.onap.cli.fw.OnapCommandSchema;
+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")
+public class OnapBasicAuthLogoutCommand extends BasicAuthLogoutCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ 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.auth;
+
+import org.onap.cli.fw.OnapCommandSchema;
+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")
+public class OnapSdcBasicAuthLoginCommand extends BasicAuthLoginCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ super.run();
+ }
+}
--- /dev/null
+org.onap.cli.cmd.auth.OnapBasicAuthLoginCommand\r
+org.onap.cli.cmd.auth.OnapBasicAuthLogoutCommand\r
+org.onap.cli.cmd.auth.OnapSdcBasicAuthLoginCommand
\ No newline at end of file
--- /dev/null
+open_cli_schema_version: 1.0
+
+name: basic-login
+
+description: ONAP basic login auth command
+
+version: onap-1.1
+
+type: auth
+
+service:
+ name: onap
+ version: v1
+
+results:
+ direction: portrait
+ attributes:
+ - name: Authorization
+ description: Authorization
+ scope: short
+ type: string
+ - name: X-TransactionId
+ description: X-TransactionId
+ scope: short
+ type: string
+ default_value: req-$s{uuid}
+ - name: X-FromAppId
+ description: X-FromAppId
+ scope: short
+ type: string
+ default_value: ONAP CLI
--- /dev/null
+open_cli_schema_version: 1.0
+
+name: sdc-basic-login
+
+description: ONAP basic login auth command
+
+version: onap-1.1
+
+type: auth
+
+service:
+ name: onap
+ version: v1
+
+results:
+ direction: portrait
+ attributes:
+ - name: Authorization
+ description: Authorization
+ scope: short
+ type: string
+ - name: X-TransactionId
+ description: X-TransactionId
+ scope: short
+ type: string
+ default_value: req-$s{uuid}
+ - name: X-FromAppId
+ description: X-FromAppId
+ scope: short
+ type: string
+ default_value: ONAP CLI
+ - name: USER_ID
+ description: USER_ID for sdc
+ scope: short
+ type: string
+ default_value: ${host-username}
\ No newline at end of file
--- /dev/null
+open_cli_schema_version: 1.0
+
+name: basic-logout
+
+description: ONAP basic logout auth command
+
+version: onap-1.1
+
+type: auth
+
+service:
+ name: onap
+ version: v1
</dependencies>
<modules>
<module>msb</module>
+ <module>auth</module>
<module>aai</module>
<module>sdc</module>
<module>so</module>
Code Review / cli.git / commitdiff