@Override
public void addAtributesFor(HttpServletRequest req, URI resource, JSONObject representation) {
IPath path = new Path(req.getPathInfo() == null ? "" : req.getPathInfo());
if (!(("/" + SITE_CONFIGURATION_SERVLET_ALIAS).equals(req.getServletPath()))) return;
try {
WebUser webUser = getWebUser(req);
if (path.segmentCount() == 0) {
if ("GET".equals(req.getMethod())) { // $NON-NLS-1$
// GET /site/ (get all site configs)
JSONArray siteConfigurations =
representation.optJSONArray(SiteConfigurationConstants.KEY_SITE_CONFIGURATIONS);
if (siteConfigurations != null) {
for (int i = 0; i < siteConfigurations.length(); i++) {
addStatus(req, siteConfigurations.getJSONObject(i), webUser, resource);
}
}
} else if ("POST".equals(req.getMethod())) { // $NON-NLS-1$
// POST /site/ (create a site config)
addStatus(req, representation, webUser, resource);
}
} else if (path.segmentCount() == 1) {
// GET /site/siteConfigId (get a single site config)
addStatus(req, representation, webUser, resource);
}
} catch (JSONException e) {
// Shouldn't happen, but since we are just decorating someone else's response we shouldn't
// cause a failure
LogHelper.log(e);
}
}
@Override
public boolean handleRequest(
HttpServletRequest request, HttpServletResponse response, String path)
throws ServletException {
try {
switch (getMethod(request)) {
case GET:
return handleGet(request, response, path);
case PUT:
return handlePut(request, response, path);
case POST:
return handlePost(request, response, path);
case DELETE:
return handleDelete(request, response, path);
default:
// we don't know how to handle this request
return false;
}
} catch (Exception e) {
String msg = NLS.bind("Failed to handle /git/clone request for {0}", path);
ServerStatus status =
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, e);
LogHelper.log(status);
return statusHandler.handleRequest(request, response, status);
}
}
public static void log(Throwable t) {
log(
new Status(
IStatus.ERROR,
ServerConstants.PI_SERVER_CORE,
"Internal server error",
t)); //$NON-NLS-1$
}
private static byte[] encryptPassword(byte[] password, byte[] salt) {
try {
byte[] encryptedPassword = null;
PBEKeySpec pbeKeySpec = new PBEKeySpec(getPassword(), salt, 1024, 256);
SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(ENCRYPTION_ALGORITHM);
SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);
PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt, 10);
Cipher cipher = Cipher.getInstance(ENCRYPTION_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, secretKey, pbeParameterSpec);
encryptedPassword = cipher.doFinal(password);
return encryptedPassword;
} catch (NoSuchAlgorithmException e) {
LogHelper.log(e);
} catch (InvalidKeySpecException e) {
LogHelper.log(e);
} catch (InvalidKeyException e) {
LogHelper.log(e);
} catch (IllegalBlockSizeException e) {
LogHelper.log(e);
} catch (BadPaddingException e) {
LogHelper.log(e);
} catch (NoSuchPaddingException e) {
LogHelper.log(e);
} catch (InvalidAlgorithmParameterException e) {
LogHelper.log(e);
}
return null;
}
// temp code for grabbing files from filesystem
protected IFileStore tempGetFileStore(IPath path) {
// first check if we have an alias registered
if (path.segmentCount() > 0) {
URI alias = aliasRegistry.lookupAlias(path.segment(0));
if (alias != null)
try {
return EFS.getStore(alias).getFileStore(path.removeFirstSegments(1));
} catch (CoreException e) {
LogHelper.log(
new Status(
IStatus.WARNING,
HostingActivator.PI_SERVER_HOSTING,
1,
"An error occured when getting file store for path '"
+ path
+ "' and alias '"
+ alias
+ '\'',
e)); //$NON-NLS-1$ //$NON-NLS-2$
// fallback is to try the same path relatively to the root
}
}
// assume it is relative to the root
try {
return EFS.getStore(rootStoreURI).getFileStore(path);
} catch (CoreException e) {
LogHelper.log(
new Status(
IStatus.WARNING,
HostingActivator.PI_SERVER_HOSTING,
1,
"An error occured when getting file store for path '"
+ path
+ "' and root '"
+ rootStoreURI
+ '\'',
e)); //$NON-NLS-1$ //$NON-NLS-2$
// fallback and return null
}
return null;
}
public static String encryptPassword(String password) {
try {
byte[] salt = generateSalt();
byte[] encryptedPassword = encryptPassword(password.getBytes(), salt);
byte[] saltBase64 = Base64.encode(salt);
byte[] encryptedPasswordBase64 = Base64.encode(encryptedPassword);
String saltString = new String(saltBase64, CHAR_ENCODING);
String encryptedPasswordString = new String(encryptedPasswordBase64, CHAR_ENCODING);
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(saltString);
stringBuffer.append(SALT_SEPARATOR);
stringBuffer.append(encryptedPasswordString);
return stringBuffer.toString();
} catch (NoSuchAlgorithmException e) {
LogHelper.log(e);
} catch (UnsupportedEncodingException e) {
LogHelper.log(e);
}
return null;
}
public static boolean verifyPassword(String password, String encryptedText) {
try {
int saltPos = encryptedText.indexOf(SALT_SEPARATOR);
if (saltPos == -1) {
throw new RuntimeException("Invalid Data Format");
}
byte[] saltBase64 = encryptedText.substring(0, saltPos).getBytes(CHAR_ENCODING);
byte[] encryptedPasswordBase64 = encryptedText.substring(saltPos + 1).getBytes(CHAR_ENCODING);
byte[] salt = Base64.decode(saltBase64);
byte[] encryptedPassword = Base64.decode(encryptedPasswordBase64);
return verifyPassword(password, encryptedPassword, salt);
} catch (NoSuchAlgorithmException e) {
LogHelper.log(e);
} catch (InvalidKeySpecException e) {
LogHelper.log(e);
} catch (UnsupportedEncodingException e) {
LogHelper.log(e);
}
return false;
}
/** Returns the platform instance location. */
public Location getInstanceLocation() {
if (instanceLocationTracker == null) {
Filter filter;
try {
filter = bundleContext.createFilter(Location.INSTANCE_FILTER);
} catch (InvalidSyntaxException e) {
LogHelper.log(e);
return null;
}
instanceLocationTracker = new ServiceTracker<Location, Location>(bundleContext, filter, null);
instanceLocationTracker.open();
}
return instanceLocationTracker.getService();
}
private User getUserForCredentials(String login, String password) {
IOrionCredentialsService userAdmin = defaultUserAdmin;
if (userAdmin == null) {
LogHelper.log(
new Status(
IStatus.ERROR,
Activator.PI_SERVER_AUTHENTICATION_BASIC,
"User admin server is not available"));
return null;
}
User user = userAdmin.getUser("login", login); // $NON-NLS-1$
if (user != null && user.hasCredential("password", password)) { // $NON-NLS-1$
return user;
}
return null;
}
public static String decryptPassword(String encryptedText) {
try {
int saltPos = encryptedText.indexOf(SALT_SEPARATOR);
if (saltPos == -1) {
throw new RuntimeException("Invalid Data Format");
}
byte[] saltBase64 = encryptedText.substring(0, saltPos).getBytes(CHAR_ENCODING);
byte[] encryptedPasswordBase64 = encryptedText.substring(saltPos + 1).getBytes(CHAR_ENCODING);
byte[] salt = Base64.decode(saltBase64);
byte[] encryptedPassword = Base64.decode(encryptedPasswordBase64);
byte[] decryptedPassword = decryptPassword(encryptedPassword, salt);
return new String(decryptedPassword);
} catch (UnsupportedEncodingException e) {
LogHelper.log(e);
}
return null;
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
traceRequest(req);
SolrQuery query = buildSolrQuery(req);
if (query == null) {
handleException(resp, "Invalid search request", null, HttpServletResponse.SC_BAD_REQUEST);
return;
}
try {
QueryResponse solrResponse = SearchActivator.getInstance().getSolrServer().query(query);
writeResponse(query, req, resp, solrResponse);
} catch (SolrServerException e) {
LogHelper.log(e);
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
}
}
@Override
public boolean handleRequest(
HttpServletRequest request, HttpServletResponse response, IFileStore dir)
throws ServletException {
try {
switch (getMethod(request)) {
case GET:
return handleGet(request, response, dir);
case PUT:
return handlePut(request, response, dir);
case POST:
return handlePost(request, response, dir);
case DELETE:
return handleDelete(request, response, dir);
}
} catch (JSONException e) {
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, "Syntax error in request", e));
} catch (CoreException e) {
// core exception messages are designed for end user consumption, so use message directly
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage(), e));
} catch (Exception e) {
// the exception message is probably not appropriate for end user consumption
LogHelper.log(e);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"An unknown failure occurred. Consult your server log or contact your system administrator.",
e));
}
return false;
}
public void addAtributesFor(HttpServletRequest request, URI resource, JSONObject representation) {
if (!decorate) {
return;
}
if (!"/users".equals(request.getServletPath())) return;
try {
addPluginLinks(request, resource, representation);
JSONArray children = representation.optJSONArray("users");
if (children != null) {
for (int i = 0; i < children.length(); i++) {
JSONObject child = children.getJSONObject(i);
addPluginLinks(request, resource, child);
}
}
} catch (Exception e) {
// log and continue
LogHelper.log(e);
}
}
public void start(BundleContext context) throws Exception {
singleton = this;
bundleContext = context;
packageAdminTracker =
new ServiceTracker<PackageAdmin, PackageAdmin>(context, PackageAdmin.class.getName(), null);
packageAdminTracker.open();
authServiceTracker = new AuthServiceTracker(context);
authServiceTracker.open();
IEclipsePreferences preferences =
DefaultScope.INSTANCE.getNode(ServerConstants.PREFERENCE_SCOPE);
Boolean httpsEnabled =
new Boolean(preferences.get(ConfigurationFormat.HTTPS_ENABLED, "false")); // $NON-NLS-1$
Dictionary<String, Object> properties = new Hashtable<String, Object>();
properties.put(
JettyConstants.CONTEXT_SESSIONINACTIVEINTERVAL, new Integer(4 * 60 * 60)); // 4 hours
// properties.put(JettyConstants.CONTEXT_PATH, "/cc");
if (httpsEnabled) {
LogHelper.log(
new Status(IStatus.INFO, PI_CONFIGURATOR, "Https is enabled", null)); // $NON-NLS-1$
properties.put(JettyConstants.HTTPS_ENABLED, true);
properties.put(
JettyConstants.HTTPS_PORT,
new Integer(
preferences.get(
HTTPS_PORT,
System.getProperty(
"org.eclipse.equinox.http.jetty.https.port",
"8443")))); //$NON-NLS-1$//$NON-NLS-2$
properties.put(
JettyConstants.SSL_KEYSTORE, preferences.get(SSL_KEYSTORE, "keystore")); // $NON-NLS-1$
LogHelper.log(
new Status(
IStatus.INFO,
PI_CONFIGURATOR,
"Keystore absolute path is "
+ preferences.get(SSL_KEYSTORE, "keystore"))); // $NON-NLS-1$ //$NON-NLS-2$
properties.put(
JettyConstants.SSL_PASSWORD, preferences.get(SSL_PASSWORD, "password")); // $NON-NLS-1$
properties.put(
JettyConstants.SSL_KEYPASSWORD,
preferences.get(SSL_KEYPASSWORD, "password")); // $NON-NLS-1$
properties.put(
JettyConstants.SSL_PROTOCOL, preferences.get(SSL_PROTOCOL, "SSLv3")); // $NON-NLS-1$
String httpsHost =
System.getProperty("org.eclipse.equinox.http.jetty.https.host"); // $NON-NLS-1$
if (httpsHost != null) {
properties.put(JettyConstants.HTTPS_HOST, httpsHost);
}
}
String port = null;
if (!httpsEnabled) {
properties.put(JettyConstants.HTTP_ENABLED, true);
port =
preferences.get(
HTTP_PORT,
System.getProperty(
"org.eclipse.equinox.http.jetty.http.port", "8080")); // $NON-NLS-1$ //$NON-NLS-2$
properties.put(JettyConstants.HTTP_PORT, new Integer(port));
String httpHost =
System.getProperty("org.eclipse.equinox.http.jetty.http.host"); // $NON-NLS-1$
if (httpHost != null) {
properties.put(JettyConstants.HTTP_HOST, httpHost);
}
}
// properties to help us filter orion content
properties.put("other.info", "org.eclipse.orion"); // $NON-NLS-1$ //$NON-NLS-2$
try {
JettyConfigurator.startServer("MasterJetty", properties); // $NON-NLS-1$
} catch (Exception e) {
throw new Exception("Error starting Jetty on port: " + port, e);
}
}