Java tutorial
/* * Copyright 2009-2012 the original author or authors. * * 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.cloudfoundry.caldecott.client; import org.cloudfoundry.caldecott.TunnelException; import org.cloudfoundry.client.lib.domain.CloudApplication; import org.cloudfoundry.client.lib.CloudFoundryClient; import org.cloudfoundry.client.lib.domain.Staging; import org.codehaus.jackson.map.ObjectMapper; import org.codehaus.jackson.map.type.TypeFactory; import org.springframework.core.io.ClassPathResource; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.HttpStatus; import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.ResourceAccessException; import org.springframework.web.client.RestTemplate; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.URI; import java.net.URISyntaxException; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Random; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; /** * A utility class for accessing information regarding tunnels and data services. * * @author Thomas Risberg */ public class TunnelHelper { private static final String TUNNEL_APP_NAME = "caldecott"; private static final String[] TUNNEL_URI_SCHEMES = { "https:", "http:" }; private static final String TUNNEL_AUTH_KEY = "CALDECOTT_AUTH"; private static final Map<String, String> TUNNEL_URI_CACHE = new ConcurrentHashMap<String, String>(); private static final RestTemplate restTemplate = new RestTemplate(); private static ObjectMapper objectMapper = new ObjectMapper(); private TunnelHelper() { throw new AssertionError("Helper class should not be instantiated."); } public static String getTunnelAppName() { return TUNNEL_APP_NAME; } public static CloudApplication getTunnelAppInfo(CloudFoundryClient client) { return client.getApplication(TunnelHelper.getTunnelAppName()); } public static void deployTunnelApp(CloudFoundryClient client) { ClassPathResource cpr = new ClassPathResource("caldecott_helper.zip"); try { File temp = copyCaldecottZipFile(cpr); client.createApplication(TUNNEL_APP_NAME, new Staging("ruby19", "sinatra"), 64, Arrays.asList(getRandomUrl(client, TUNNEL_APP_NAME)), Arrays.asList(new String[] {}), false); client.uploadApplication(TUNNEL_APP_NAME, temp); client.updateApplicationEnv(TUNNEL_APP_NAME, Collections.singletonMap("CALDECOTT_AUTH", UUID.randomUUID().toString())); client.startApplication(TUNNEL_APP_NAME); temp.delete(); } catch (IOException e) { throw new TunnelException("Unable to deploy the Caldecott server application", e); } } public static void bindServiceToTunnelApp(CloudFoundryClient client, String serviceName) { if (getTunnelAppInfo(client).getServices().contains(serviceName)) { return; } client.stopApplication(getTunnelAppName()); client.bindService(getTunnelAppName(), serviceName); client.startApplication(getTunnelAppName()); } public static String getTunnelUri(CloudFoundryClient client) { String uriAuthority = client.getApplication(TunnelHelper.getTunnelAppName()).getUris().get(0); if (TUNNEL_URI_CACHE.containsKey(uriAuthority)) { return TUNNEL_URI_CACHE.get(uriAuthority); } String uriScheme = testUriSchemes(client, TUNNEL_URI_SCHEMES, uriAuthority); String uri = uriScheme + "//" + uriAuthority; TUNNEL_URI_CACHE.put(uriAuthority, uri); return uri; } public static String getTunnelAuth(CloudFoundryClient client) { String auth = client.getApplication(TunnelHelper.getTunnelAppName()).getEnvAsMap().get(TUNNEL_AUTH_KEY); return auth; } public static Map<String, String> getTunnelServiceInfo(CloudFoundryClient client, String serviceName) { String urlToUse = getTunnelUri(client) + "/services/" + serviceName; HttpHeaders requestHeaders = new HttpHeaders(); requestHeaders.set("Auth-Token", getTunnelAuth(client)); HttpEntity<?> requestEntity = new HttpEntity(requestHeaders); HttpEntity<String> response = restTemplate.exchange(urlToUse, HttpMethod.GET, requestEntity, String.class); String json = response.getBody().trim(); Map<String, String> svcInfo = new HashMap<String, String>(); try { svcInfo = convertJsonToMap(json); } catch (IOException e) { return new HashMap<String, String>(); } if (svcInfo.containsKey("url")) { String svcUrl = svcInfo.get("url"); try { URI uri = new URI(svcUrl); String[] userInfo; if (uri.getUserInfo().contains(":")) { userInfo = uri.getUserInfo().split(":"); } else { userInfo = new String[2]; userInfo[0] = uri.getUserInfo(); userInfo[1] = ""; } svcInfo.put("user", userInfo[0]); svcInfo.put("username", userInfo[0]); svcInfo.put("password", userInfo[1]); svcInfo.put("host", uri.getHost()); svcInfo.put("hostname", uri.getHost()); svcInfo.put("port", "" + uri.getPort()); svcInfo.put("path", (uri.getPath().startsWith("/") ? uri.getPath().substring(1) : uri.getPath())); svcInfo.put("vhost", svcInfo.get("path")); } catch (URISyntaxException e) { } } return svcInfo; } private static String testUriSchemes(CloudFoundryClient client, String[] uriSchemes, String uriAuthority) { int i = 0; int retries = 0; String scheme = null; while (i < uriSchemes.length) { scheme = uriSchemes[i]; String uriToUse = scheme + "//" + uriAuthority; try { getTunnelProtocolVersion(client, uriToUse); break; } catch (HttpClientErrorException e) { if (e.getStatusCode().equals(HttpStatus.NOT_FOUND)) { if (retries < 10) { retries++; } else { throw new TunnelException("Not able to locate tunnel server at: " + uriToUse, e); } } else { throw new TunnelException("Error accessing tunnel server at: " + uriToUse, e); } } catch (ResourceAccessException e) { if (e.getMessage().contains("refused") || e.getMessage().contains("unable")) { i++; } else { throw e; } } catch (RuntimeException e) { throw e; } } return scheme; } private static File copyCaldecottZipFile(ClassPathResource cpr) throws IOException { File temp = File.createTempFile("caldecott", "zip"); InputStream in = cpr.getInputStream(); OutputStream out = new FileOutputStream(temp); int read = 0; byte[] bytes = new byte[1024]; while ((read = in.read(bytes)) != -1) { out.write(bytes, 0, read); } in.close(); out.flush(); out.close(); return temp; } public static String getRandomUrl(CloudFoundryClient client, String appname) { int range = 0x01000000; int r = new Random().nextInt(range - 1); StringBuilder url = new StringBuilder(); url.append(appname); url.append("-"); url.append(Integer.toHexString((r))); String domain = client.getCloudControllerUrl().getHost(); if (domain.startsWith("api.")) { domain = domain.substring(3); } else { url.append("-"); } url.append(domain); return url.toString(); } public static String getTunnelProtocolVersion(CloudFoundryClient client, String uri) { String uriToUse = uri + "/info"; HttpHeaders requestHeaders = new HttpHeaders(); requestHeaders.set("Auth-Token", getTunnelAuth(client)); HttpEntity<?> requestEntity = new HttpEntity(requestHeaders); HttpEntity<String> response = restTemplate.exchange(uriToUse, HttpMethod.GET, requestEntity, String.class); return response.getBody().trim(); } public static Map<String, String> convertJsonToMap(String json) throws IOException { Map<String, String> svcInfo = objectMapper.readValue(json, TypeFactory.mapType(HashMap.class, String.class, String.class)); return svcInfo; } }