/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.cloudstack.storage.datastore.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.BasicClientConnectionManager;
import org.apache.log4j.Logger;
import com.cloud.utils.exception.CloudRuntimeException;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
public class NexentaNmsClient {
private static final Logger logger = Logger.getLogger(NexentaNmsClient.class);
protected NexentaNmsUrl nmsUrl = null;
protected DefaultHttpClient httpClient = null;
NexentaNmsClient(NexentaNmsUrl nmsUrl) {
this.nmsUrl = nmsUrl;
}
private static boolean isSuccess(int iCode) {
return iCode >= 200 && iCode < 300;
}
protected DefaultHttpClient getClient() {
if (httpClient == null) {
if (nmsUrl.getSchema().equalsIgnoreCase("http")) {
httpClient = getHttpClient();
} else {
httpClient = getHttpsClient();
}
AuthScope authScope = new AuthScope(nmsUrl.getHost(), nmsUrl.getPort(), AuthScope.ANY_SCHEME, "basic");
UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(nmsUrl.getUsername(), nmsUrl.getPassword());
httpClient.getCredentialsProvider().setCredentials(authScope, credentials);
}
return httpClient;
}
protected DefaultHttpClient getHttpsClient() {
try {
SSLContext sslContext = SSLContext.getInstance("SSL");
X509TrustManager tm = new X509TrustManager() {
@Override
public void checkClientTrusted(X509Certificate[] xcs, String string) throws CertificateException {
}
@Override
public void checkServerTrusted(X509Certificate[] xcs, String string) throws CertificateException {
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
sslContext.init(null, new TrustManager[] {tm}, new SecureRandom());
SSLSocketFactory socketFactory = new SSLSocketFactory(sslContext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("https", nmsUrl.getPort(), socketFactory));
BasicClientConnectionManager mgr = new BasicClientConnectionManager(registry);
return new DefaultHttpClient(mgr);
} catch (NoSuchAlgorithmException ex) {
throw new CloudRuntimeException(ex.getMessage());
} catch (KeyManagementException ex) {
throw new CloudRuntimeException(ex.getMessage());
}
}
protected DefaultHttpClient getHttpClient() {
return new DefaultHttpClient();
}
@SuppressWarnings("unused")
static class NmsRequest {
private String method;
private String object;
private Object[] params;
NmsRequest(String object, String method) {
this(method, object, null);
}
NmsRequest(String object, String method, Object... params) {
this.method = method;
this.object = object;
this.params = params;
}
public String toString() {
StringBuffer b = new StringBuffer();
b.append("Request to ").append(object).append(" method ").append(method);
if (params != null) {
b.append(" params:");
for (Object param:params) {
b.append(" ").append(param).append(",");
}
}
return b.toString();
}
}
@SuppressWarnings("unused")
static class NmsError {
private String message;
public String getMesssage() {
return message;
}
}
@SuppressWarnings("unused")
static class NmsResponse {
@SerializedName("tg_flash") protected String tgFlash;
protected NmsError error;
NmsResponse() {}
NmsResponse(String tgFlash, NmsError error) {
this.tgFlash = tgFlash;
this.error = error;
}
public String getTgFlash() {
return tgFlash;
}
public NmsError getError() {
return error;
}
}
public NmsResponse execute(Class responseClass, String object, String method, Object... params) {
StringBuilder sb = new StringBuilder();
NmsRequest nmsRequest = new NmsRequest(object, method, params);
if (logger.isDebugEnabled()) {
logger.debug(nmsRequest);
}
final Gson gson = new Gson();
String jsonRequest = gson.toJson(nmsRequest);
StringEntity input = new StringEntity(jsonRequest, ContentType.APPLICATION_JSON);
HttpPost postRequest = new HttpPost(nmsUrl.toString());
postRequest.setEntity(input);
DefaultHttpClient httpClient = getClient();
try {
HttpResponse response = httpClient.execute(postRequest);
final int status = response.getStatusLine().getStatusCode();
if (!isSuccess(status)) {
throw new CloudRuntimeException("Failed on JSON-RPC API call. HTTP error code = " + status);
}
BufferedReader buffer = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
String tmp;
while ((tmp = buffer.readLine()) != null) {
sb.append(tmp);
}
} catch (ClientProtocolException ex) {
throw new CloudRuntimeException(ex.getMessage());
} catch (IOException ex) {
throw new CloudRuntimeException(ex.getMessage());
} finally {
if (httpClient != null) {
try {
httpClient.getConnectionManager().shutdown();
} catch (Exception t) {
logger.debug(t.getMessage());
}
}
}
String responseString = sb.toString();
if (logger.isDebugEnabled()) {
logger.debug("NexentaStor Appliance response: " + responseString);
}
NmsResponse nmsResponse = (NmsResponse) gson.fromJson(responseString, responseClass);
if (nmsResponse.getError() != null) {
throw new CloudRuntimeException(nmsResponse.getError().getMesssage());
}
return nmsResponse;
}
}