_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q8300 | PathValueClient.removeDefaultCustomResponse | train | public static boolean removeDefaultCustomResponse(String pathValue, String requestType) {
try {
JSONObject profile = getDefaultProfile();
String profileName = profile.getString("name");
PathValueClient client = new PathValueClient(profileName, false);
return client.removeCustomResponse(pathValue, requestType);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8301 | PathValueClient.removeCustomResponse | train | public boolean removeCustomResponse(String pathValue, String requestType) {
try {
JSONObject path = getPathFromEndpoint(pathValue, requestType);
if (path == null) {
return false;
}
String pathId = path.getString("pathId");
return resetResponseOverride(pathId);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8302 | PathValueClient.setCustomResponse | train | public boolean setCustomResponse(String pathValue, String requestType, String customData) {
try {
JSONObject path = getPathFromEndpoint(pathValue, requestType);
if (path == null) {
String pathName = pathValue;
createPath(pathName, pathValue, requestType);
path = getPathFromEndpoint(pathValue, requestType);
}
String pathId = path.getString("pathId");
resetResponseOverride(pathId);
setCustomResponse(pathId, customData);
return toggleResponseOverride(pathId, true);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8303 | ClientController.getClientList | train | @RequestMapping(value = "/api/profile/{profileIdentifier}/clients", method = RequestMethod.GET)
public
@ResponseBody
HashMap<String, Object> getClientList(Model model,
@PathVariable("profileIdentifier") String profileIdentifier) throws Exception {
Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
return Utils.getJQGridJSON(clientService.findAllClients(profileId), "clients");
} | java | {
"resource": ""
} |
q8304 | ClientController.getClient | train | @RequestMapping(value = "/api/profile/{profileIdentifier}/clients/{clientUUID}", method = RequestMethod.GET)
public
@ResponseBody
HashMap<String, Object> getClient(Model model,
@PathVariable("profileIdentifier") String profileIdentifier,
@PathVariable("clientUUID") String clientUUID) throws Exception {
Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
HashMap<String, Object> valueHash = new HashMap<String, Object>();
valueHash.put("client", clientService.findClient(clientUUID, profileId));
return valueHash;
} | java | {
"resource": ""
} |
q8305 | ClientController.addClient | train | @RequestMapping(value = "/api/profile/{profileIdentifier}/clients", method = RequestMethod.POST)
public
@ResponseBody
HashMap<String, Object> addClient(Model model,
@PathVariable("profileIdentifier") String profileIdentifier,
@RequestParam(required = false) String friendlyName) throws Exception {
Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
// make sure client with this name does not already exist
if (null != clientService.findClientFromFriendlyName(profileId, friendlyName)) {
throw new Exception("Cannot add client. Friendly name already in use.");
}
Client client = clientService.add(profileId);
// set friendly name if it was specified
if (friendlyName != null) {
clientService.setFriendlyName(profileId, client.getUUID(), friendlyName);
client.setFriendlyName(friendlyName);
}
HashMap<String, Object> valueHash = new HashMap<String, Object>();
valueHash.put("client", client);
return valueHash;
} | java | {
"resource": ""
} |
q8306 | ClientController.updateClient | train | @RequestMapping(value = "/api/profile/{profileIdentifier}/clients/{clientUUID}", method = RequestMethod.POST)
public
@ResponseBody
HashMap<String, Object> updateClient(Model model,
@PathVariable("profileIdentifier") String profileIdentifier,
@PathVariable("clientUUID") String clientUUID,
@RequestParam(required = false) Boolean active,
@RequestParam(required = false) String friendlyName,
@RequestParam(required = false) Boolean reset) throws Exception {
Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
if (active != null) {
logger.info("Active: {}", active);
clientService.updateActive(profileId, clientUUID, active);
}
if (friendlyName != null) {
clientService.setFriendlyName(profileId, clientUUID, friendlyName);
}
if (reset != null && reset) {
clientService.reset(profileId, clientUUID);
}
HashMap<String, Object> valueHash = new HashMap<String, Object>();
valueHash.put("client", clientService.findClient(clientUUID, profileId));
return valueHash;
} | java | {
"resource": ""
} |
q8307 | ClientController.deleteClient | train | @RequestMapping(value = "/api/profile/{profileIdentifier}/clients/{clientUUID}", method = RequestMethod.DELETE)
public
@ResponseBody
HashMap<String, Object> deleteClient(Model model,
@PathVariable("profileIdentifier") String profileIdentifier,
@PathVariable("clientUUID") String clientUUID) throws Exception {
logger.info("Attempting to remove the following client: {}", clientUUID);
if (clientUUID.compareTo(Constants.PROFILE_CLIENT_DEFAULT_ID) == 0)
throw new Exception("Default client cannot be deleted");
Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
clientService.remove(profileId, clientUUID);
HashMap<String, Object> valueHash = new HashMap<String, Object>();
valueHash.put("clients", clientService.findAllClients(profileId));
return valueHash;
} | java | {
"resource": ""
} |
q8308 | ClientController.deleteClient | train | @RequestMapping(value = "/api/profile/{profileIdentifier}/clients/delete", method = RequestMethod.POST)
public
@ResponseBody
HashMap<String, Object> deleteClient(Model model,
@RequestParam("profileIdentifier") String profileIdentifier,
@RequestParam("clientUUID") String[] clientUUID) throws Exception {
logger.info("Attempting to remove clients from the profile: ", profileIdentifier);
logger.info("Attempting to remove the following clients: {}", Arrays.toString(clientUUID));
HashMap<String, Object> valueHash = new HashMap<String, Object>();
Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
for( int i = 0; i < clientUUID.length; i++ )
{
if (clientUUID[i].compareTo(Constants.PROFILE_CLIENT_DEFAULT_ID) == 0)
throw new Exception("Default client cannot be deleted");
clientService.remove(profileId, clientUUID[i]);
}
valueHash.put("clients", clientService.findAllClients(profileId));
return valueHash;
} | java | {
"resource": ""
} |
q8309 | PluginController.getPluginInformation | train | @RequestMapping(value = "/api/plugins", method = RequestMethod.GET)
public
@ResponseBody
HashMap<String, Object> getPluginInformation() {
return pluginInformation();
} | java | {
"resource": ""
} |
q8310 | PluginController.addPluginPath | train | @RequestMapping(value = "/api/plugins", method = RequestMethod.POST)
public
@ResponseBody
HashMap<String, Object> addPluginPath(Model model, Plugin add) throws Exception {
PluginManager.getInstance().addPluginPath(add.getPath());
return pluginInformation();
} | java | {
"resource": ""
} |
q8311 | SampleClient.addOverrideToPath | train | public static void addOverrideToPath() throws Exception {
Client client = new Client("ProfileName", false);
// Use the fully qualified name for a plugin override.
client.addMethodToResponseOverride("Test Path", "com.groupon.odo.sample.Common.delay");
// The third argument is the ordinal - the nth instance of this override added to this path
// The final arguments count and type are determined by the override. "delay" used in this sample
// has a single int argument - # of milliseconds delay to simulate
client.setMethodArguments("Test Path", "com.groupon.odo.sample.Common.delay", 1, "100");
} | java | {
"resource": ""
} |
q8312 | SampleClient.getHistory | train | public static void getHistory() throws Exception{
Client client = new Client("ProfileName", false);
// Obtain the 100 history entries starting from offset 0
History[] history = client.refreshHistory(100, 0);
client.clearHistory();
} | java | {
"resource": ""
} |
q8313 | ProfileController.list | train | @RequestMapping(value = "/profiles", method = RequestMethod.GET)
public String list(Model model) {
Profile profiles = new Profile();
model.addAttribute("addNewProfile", profiles);
model.addAttribute("version", Constants.VERSION);
logger.info("Loading initial page");
return "profiles";
} | java | {
"resource": ""
} |
q8314 | ProfileController.getList | train | @RequestMapping(value = "/api/profile", method = RequestMethod.GET)
public
@ResponseBody
HashMap<String, Object> getList(Model model) throws Exception {
logger.info("Using a GET request to list profiles");
return Utils.getJQGridJSON(profileService.findAllProfiles(), "profiles");
} | java | {
"resource": ""
} |
q8315 | ProfileController.addProfile | train | @RequestMapping(value = "/api/profile", method = RequestMethod.POST)
public
@ResponseBody
HashMap<String, Object> addProfile(Model model, String name) throws Exception {
logger.info("Should be adding the profile name when I hit the enter button={}", name);
return Utils.getJQGridJSON(profileService.add(name), "profile");
} | java | {
"resource": ""
} |
q8316 | ProfileController.deleteProfile | train | @RequestMapping(value = "/api/profile", method = RequestMethod.DELETE)
public
@ResponseBody
HashMap<String, Object> deleteProfile(Model model, int id) throws Exception {
profileService.remove(id);
return Utils.getJQGridJSON(profileService.findAllProfiles(), "profiles");
} | java | {
"resource": ""
} |
q8317 | HistoryService.cullHistory | train | public void cullHistory(final int profileId, final String clientUUID, final int limit) throws Exception {
//Allow only 1 delete thread to run
if (threadActive) {
return;
}
threadActive = true;
//Create a thread so proxy will continue to work during long delete
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
PreparedStatement statement = null;
try (Connection sqlConnection = sqlService.getConnection()) {
String sqlQuery = "SELECT COUNT(" + Constants.GENERIC_ID + ") FROM " + Constants.DB_TABLE_HISTORY + " ";
// see if profileId is set or not (-1)
if (profileId != -1) {
sqlQuery += "WHERE " + Constants.GENERIC_PROFILE_ID + "=" + profileId + " ";
}
if (clientUUID != null && clientUUID.compareTo("") != 0) {
sqlQuery += "AND " + Constants.GENERIC_CLIENT_UUID + "='" + clientUUID + "' ";
}
sqlQuery += ";";
Statement query = sqlConnection.createStatement();
ResultSet results = query.executeQuery(sqlQuery);
if (results.next()) {
if (results.getInt("COUNT(" + Constants.GENERIC_ID + ")") < (limit + 10000)) {
return;
}
}
//Find the last item in the table
statement = sqlConnection.prepareStatement("SELECT " + Constants.GENERIC_ID + " FROM " + Constants.DB_TABLE_HISTORY +
" WHERE " + Constants.CLIENT_CLIENT_UUID + " = \'" + clientUUID + "\'" +
" AND " + Constants.CLIENT_PROFILE_ID + " = " + profileId +
" ORDER BY " + Constants.GENERIC_ID + " ASC LIMIT 1");
ResultSet resultSet = statement.executeQuery();
if (resultSet.next()) {
int currentSpot = resultSet.getInt(Constants.GENERIC_ID) + 100;
int finalDelete = currentSpot + 10000;
//Delete 100 items at a time until 10000 are deleted
//Do this so table is unlocked frequently to allow other proxy items to access it
while (currentSpot < finalDelete) {
PreparedStatement deleteStatement = sqlConnection.prepareStatement("DELETE FROM " + Constants.DB_TABLE_HISTORY +
" WHERE " + Constants.CLIENT_CLIENT_UUID + " = \'" + clientUUID + "\'" +
" AND " + Constants.CLIENT_PROFILE_ID + " = " + profileId +
" AND " + Constants.GENERIC_ID + " < " + currentSpot);
deleteStatement.executeUpdate();
currentSpot += 100;
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
threadActive = false;
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
}
});
t1.start();
} | java | {
"resource": ""
} |
q8318 | HistoryService.getHistoryCount | train | public int getHistoryCount(int profileId, String clientUUID, HashMap<String, String[]> searchFilter) {
int count = 0;
Statement query = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
String sqlQuery = "SELECT COUNT(" + Constants.GENERIC_ID + ") FROM " + Constants.DB_TABLE_HISTORY + " ";
// see if profileId is set or not (-1)
if (profileId != -1) {
sqlQuery += "WHERE " + Constants.GENERIC_PROFILE_ID + "=" + profileId + " ";
}
if (clientUUID != null && clientUUID.compareTo("") != 0) {
sqlQuery += "AND " + Constants.GENERIC_CLIENT_UUID + "='" + clientUUID + "' ";
}
sqlQuery += ";";
logger.info("Query: {}", sqlQuery);
query = sqlConnection.createStatement();
results = query.executeQuery(sqlQuery);
if (results.next()) {
count = results.getInt(1);
}
query.close();
} catch (Exception e) {
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (query != null) {
query.close();
}
} catch (Exception e) {
}
}
return count;
} | java | {
"resource": ""
} |
q8319 | HistoryService.getHistoryForID | train | public History getHistoryForID(int id) {
History history = null;
PreparedStatement query = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
query = sqlConnection.prepareStatement("SELECT * FROM " + Constants.DB_TABLE_HISTORY +
" WHERE " + Constants.GENERIC_ID + "=?");
query.setInt(1, id);
logger.info("Query: {}", query.toString());
results = query.executeQuery();
if (results.next()) {
history = historyFromSQLResult(results, true, ScriptService.getInstance().getScripts(Constants.SCRIPT_TYPE_HISTORY));
}
query.close();
} catch (Exception e) {
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (query != null) {
query.close();
}
} catch (Exception e) {
}
}
return history;
} | java | {
"resource": ""
} |
q8320 | HistoryService.clearHistory | train | public void clearHistory(int profileId, String clientUUID) {
PreparedStatement query = null;
try (Connection sqlConnection = sqlService.getConnection()) {
String sqlQuery = "DELETE FROM " + Constants.DB_TABLE_HISTORY + " ";
// see if profileId is null or not (-1)
if (profileId != -1) {
sqlQuery += "WHERE " + Constants.GENERIC_PROFILE_ID + "=" + profileId;
}
// see if clientUUID is null or not
if (clientUUID != null && clientUUID.compareTo("") != 0) {
sqlQuery += " AND " + Constants.GENERIC_CLIENT_UUID + "='" + clientUUID + "'";
}
sqlQuery += ";";
logger.info("Query: {}", sqlQuery);
query = sqlConnection.prepareStatement(sqlQuery);
query.executeUpdate();
} catch (Exception e) {
} finally {
try {
if (query != null) {
query.close();
}
} catch (Exception e) {
}
}
} | java | {
"resource": ""
} |
q8321 | Client.destroy | train | public void destroy() throws Exception {
if (_clientId == null) {
return;
}
// delete the clientId here
String uri = BASE_PROFILE + uriEncode(_profileName) + "/" + BASE_CLIENTS + "/" + _clientId;
try {
doDelete(uri, null);
} catch (Exception e) {
// some sort of error
throw new Exception("Could not delete a proxy client");
}
} | java | {
"resource": ""
} |
q8322 | Client.setHostName | train | public void setHostName(String hostName) {
if (hostName == null || hostName.contains(":")) {
return;
}
ODO_HOST = hostName;
BASE_URL = "http://" + ODO_HOST + ":" + API_PORT + "/" + API_BASE + "/";
} | java | {
"resource": ""
} |
q8323 | Client.setDefaultHostName | train | public static void setDefaultHostName(String hostName) {
if (hostName == null || hostName.contains(":")) {
return;
}
DEFAULT_BASE_URL = "http://" + hostName + ":" + DEFAULT_API_PORT + "/" + API_BASE + "/";
} | java | {
"resource": ""
} |
q8324 | Client.filterHistory | train | public History[] filterHistory(String... filters) throws Exception {
BasicNameValuePair[] params;
if (filters.length > 0) {
params = new BasicNameValuePair[filters.length];
for (int i = 0; i < filters.length; i++) {
params[i] = new BasicNameValuePair("source_uri[]", filters[i]);
}
} else {
return refreshHistory();
}
return constructHistory(params);
} | java | {
"resource": ""
} |
q8325 | Client.refreshHistory | train | public History[] refreshHistory(int limit, int offset) throws Exception {
BasicNameValuePair[] params = {
new BasicNameValuePair("limit", String.valueOf(limit)),
new BasicNameValuePair("offset", String.valueOf(offset))
};
return constructHistory(params);
} | java | {
"resource": ""
} |
q8326 | Client.clearHistory | train | public void clearHistory() throws Exception {
String uri;
try {
uri = HISTORY + uriEncode(_profileName);
doDelete(uri, null);
} catch (Exception e) {
throw new Exception("Could not delete proxy history");
}
} | java | {
"resource": ""
} |
q8327 | Client.toggleProfile | train | public boolean toggleProfile(Boolean enabled) {
// TODO: make this return values properly
BasicNameValuePair[] params = {
new BasicNameValuePair("active", enabled.toString())
};
try {
String uri = BASE_PROFILE + uriEncode(this._profileName) + "/" + BASE_CLIENTS + "/";
if (_clientId == null) {
uri += "-1";
} else {
uri += _clientId;
}
JSONObject response = new JSONObject(doPost(uri, params));
} catch (Exception e) {
// some sort of error
System.out.println(e.getMessage());
return false;
}
return true;
} | java | {
"resource": ""
} |
q8328 | Client.setCustomResponse | train | public boolean setCustomResponse(String pathName, String customResponse) throws Exception {
// figure out the new ordinal
int nextOrdinal = this.getNextOrdinalForMethodId(-1, pathName);
// add override
this.addMethodToResponseOverride(pathName, "-1");
// set argument
return this.setMethodArguments(pathName, "-1", nextOrdinal, customResponse);
} | java | {
"resource": ""
} |
q8329 | Client.addMethodToResponseOverride | train | public boolean addMethodToResponseOverride(String pathName, String methodName) {
// need to find out the ID for the method
// TODO: change api for adding methods to take the name instead of ID
try {
Integer overrideId = getOverrideIdForMethodName(methodName);
// now post to path api to add this is a selected override
BasicNameValuePair[] params = {
new BasicNameValuePair("addOverride", overrideId.toString()),
new BasicNameValuePair("profileIdentifier", this._profileName)
};
JSONObject response = new JSONObject(doPost(BASE_PATH + uriEncode(pathName), params));
// check enabled endpoints array to see if this overrideID exists
JSONArray enabled = response.getJSONArray("enabledEndpoints");
for (int x = 0; x < enabled.length(); x++) {
if (enabled.getJSONObject(x).getInt("overrideId") == overrideId) {
return true;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8330 | Client.setOverrideRepeatCount | train | public boolean setOverrideRepeatCount(String pathName, String methodName, Integer ordinal, Integer repeatCount) {
try {
String methodId = getOverrideIdForMethodName(methodName).toString();
BasicNameValuePair[] params = {
new BasicNameValuePair("profileIdentifier", this._profileName),
new BasicNameValuePair("ordinal", ordinal.toString()),
new BasicNameValuePair("repeatNumber", repeatCount.toString())
};
JSONObject response = new JSONObject(doPost(BASE_PATH + uriEncode(pathName) + "/" + methodId, params));
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8331 | Client.setMethodArguments | train | public boolean setMethodArguments(String pathName, String methodName, Integer ordinal, Object... arguments) {
try {
BasicNameValuePair[] params = new BasicNameValuePair[arguments.length + 2];
int x = 0;
for (Object argument : arguments) {
params[x] = new BasicNameValuePair("arguments[]", argument.toString());
x++;
}
params[x] = new BasicNameValuePair("profileIdentifier", this._profileName);
params[x + 1] = new BasicNameValuePair("ordinal", ordinal.toString());
JSONObject response = new JSONObject(doPost(BASE_PATH + uriEncode(pathName) + "/" + methodName, params));
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8332 | Client.createPath | train | public void createPath(String pathName, String pathValue, String requestType) {
try {
int type = getRequestTypeFromString(requestType);
String url = BASE_PATH;
BasicNameValuePair[] params = {
new BasicNameValuePair("pathName", pathName),
new BasicNameValuePair("path", pathValue),
new BasicNameValuePair("requestType", String.valueOf(type)),
new BasicNameValuePair("profileIdentifier", this._profileName)
};
JSONObject response = new JSONObject(doPost(BASE_PATH, params));
} catch (Exception e) {
e.printStackTrace();
}
} | java | {
"resource": ""
} |
q8333 | Client.setCustomForDefaultClient | train | protected static boolean setCustomForDefaultClient(String profileName, String pathName, Boolean isResponse, String customData) {
try {
Client client = new Client(profileName, false);
client.toggleProfile(true);
client.setCustom(isResponse, pathName, customData);
if (isResponse) {
client.toggleResponseOverride(pathName, true);
} else {
client.toggleRequestOverride(pathName, true);
}
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8334 | Client.setCustomRequestForDefaultClient | train | public static boolean setCustomRequestForDefaultClient(String profileName, String pathName, String customData) {
try {
return setCustomForDefaultClient(profileName, pathName, false, customData);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8335 | Client.setCustomResponseForDefaultClient | train | public static boolean setCustomResponseForDefaultClient(String profileName, String pathName, String customData) {
try {
return setCustomForDefaultClient(profileName, pathName, true, customData);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8336 | Client.setCustomRequestForDefaultProfile | train | public static boolean setCustomRequestForDefaultProfile(String pathName, String customData) {
try {
return setCustomForDefaultProfile(pathName, false, customData);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8337 | Client.setCustomResponseForDefaultProfile | train | public static boolean setCustomResponseForDefaultProfile(String pathName, String customData) {
try {
return setCustomForDefaultProfile(pathName, true, customData);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} | java | {
"resource": ""
} |
q8338 | Client.getDefaultProfile | train | protected static JSONObject getDefaultProfile() throws Exception {
String uri = DEFAULT_BASE_URL + BASE_PROFILE;
try {
JSONObject response = new JSONObject(doGet(uri, 60000));
JSONArray profiles = response.getJSONArray("profiles");
if (profiles.length() > 0) {
return profiles.getJSONObject(0);
}
} catch (Exception e) {
// some sort of error
throw new Exception("Could not create a proxy client");
}
return null;
} | java | {
"resource": ""
} |
q8339 | Client.getNextOrdinalForMethodId | train | private Integer getNextOrdinalForMethodId(int methodId, String pathName) throws Exception {
String pathInfo = doGet(BASE_PATH + uriEncode(pathName), new BasicNameValuePair[0]);
JSONObject pathResponse = new JSONObject(pathInfo);
JSONArray enabledEndpoints = pathResponse.getJSONArray("enabledEndpoints");
int lastOrdinal = 0;
for (int x = 0; x < enabledEndpoints.length(); x++) {
if (enabledEndpoints.getJSONObject(x).getInt("overrideId") == methodId) {
lastOrdinal++;
}
}
return lastOrdinal + 1;
} | java | {
"resource": ""
} |
q8340 | Client.getRequestTypeFromString | train | protected int getRequestTypeFromString(String requestType) {
if ("GET".equals(requestType)) {
return REQUEST_TYPE_GET;
}
if ("POST".equals(requestType)) {
return REQUEST_TYPE_POST;
}
if ("PUT".equals(requestType)) {
return REQUEST_TYPE_PUT;
}
if ("DELETE".equals(requestType)) {
return REQUEST_TYPE_DELETE;
}
return REQUEST_TYPE_ALL;
} | java | {
"resource": ""
} |
q8341 | Client.addServerMapping | train | public ServerRedirect addServerMapping(String sourceHost, String destinationHost, String hostHeader) {
JSONObject response = null;
ArrayList<BasicNameValuePair> params = new ArrayList<BasicNameValuePair>();
params.add(new BasicNameValuePair("srcUrl", sourceHost));
params.add(new BasicNameValuePair("destUrl", destinationHost));
params.add(new BasicNameValuePair("profileIdentifier", this._profileName));
if (hostHeader != null) {
params.add(new BasicNameValuePair("hostHeader", hostHeader));
}
try {
BasicNameValuePair paramArray[] = new BasicNameValuePair[params.size()];
params.toArray(paramArray);
response = new JSONObject(doPost(BASE_SERVER, paramArray));
} catch (Exception e) {
e.printStackTrace();
return null;
}
return getServerRedirectFromJSON(response);
} | java | {
"resource": ""
} |
q8342 | Client.deleteServerMapping | train | public List<ServerRedirect> deleteServerMapping(int serverMappingId) {
ArrayList<ServerRedirect> servers = new ArrayList<ServerRedirect>();
try {
JSONArray serverArray = new JSONArray(doDelete(BASE_SERVER + "/" + serverMappingId, null));
for (int i = 0; i < serverArray.length(); i++) {
JSONObject jsonServer = serverArray.getJSONObject(i);
ServerRedirect server = getServerRedirectFromJSON(jsonServer);
if (server != null) {
servers.add(server);
}
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
return servers;
} | java | {
"resource": ""
} |
q8343 | Client.getServerMappings | train | public List<ServerRedirect> getServerMappings() {
ArrayList<ServerRedirect> servers = new ArrayList<ServerRedirect>();
try {
JSONObject response = new JSONObject(doGet(BASE_SERVER, null));
JSONArray serverArray = response.getJSONArray("servers");
for (int i = 0; i < serverArray.length(); i++) {
JSONObject jsonServer = serverArray.getJSONObject(i);
ServerRedirect server = getServerRedirectFromJSON(jsonServer);
if (server != null) {
servers.add(server);
}
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
return servers;
} | java | {
"resource": ""
} |
q8344 | Client.updateServerRedirectHost | train | public ServerRedirect updateServerRedirectHost(int serverMappingId, String hostHeader) {
ServerRedirect redirect = new ServerRedirect();
BasicNameValuePair[] params = {
new BasicNameValuePair("hostHeader", hostHeader),
new BasicNameValuePair("profileIdentifier", this._profileName)
};
try {
JSONObject response = new JSONObject(doPost(BASE_SERVER + "/" + serverMappingId + "/host", params));
redirect = getServerRedirectFromJSON(response);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return redirect;
} | java | {
"resource": ""
} |
q8345 | Client.addServerGroup | train | public ServerGroup addServerGroup(String groupName) {
ServerGroup group = new ServerGroup();
BasicNameValuePair[] params = {
new BasicNameValuePair("name", groupName),
new BasicNameValuePair("profileIdentifier", this._profileName)
};
try {
JSONObject response = new JSONObject(doPost(BASE_SERVERGROUP, params));
group = getServerGroupFromJSON(response);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return group;
} | java | {
"resource": ""
} |
q8346 | Client.getServerGroups | train | public List<ServerGroup> getServerGroups() {
ArrayList<ServerGroup> groups = new ArrayList<ServerGroup>();
try {
JSONObject response = new JSONObject(doGet(BASE_SERVERGROUP, null));
JSONArray serverArray = response.getJSONArray("servergroups");
for (int i = 0; i < serverArray.length(); i++) {
JSONObject jsonServerGroup = serverArray.getJSONObject(i);
ServerGroup group = getServerGroupFromJSON(jsonServerGroup);
groups.add(group);
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
return groups;
} | java | {
"resource": ""
} |
q8347 | Client.updateServerGroupName | train | public ServerGroup updateServerGroupName(int serverGroupId, String name) {
ServerGroup serverGroup = null;
BasicNameValuePair[] params = {
new BasicNameValuePair("name", name),
new BasicNameValuePair("profileIdentifier", this._profileName)
};
try {
JSONObject response = new JSONObject(doPost(BASE_SERVERGROUP + "/" + serverGroupId, params));
serverGroup = getServerGroupFromJSON(response);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return serverGroup;
} | java | {
"resource": ""
} |
q8348 | Client.uploadConfigurationAndProfile | train | public boolean uploadConfigurationAndProfile(String fileName, String odoImport) {
File file = new File(fileName);
MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
FileBody fileBody = new FileBody(file, ContentType.MULTIPART_FORM_DATA);
multipartEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
multipartEntityBuilder.addPart("fileData", fileBody);
multipartEntityBuilder.addTextBody("odoImport", odoImport);
try {
JSONObject response = new JSONObject(doMultipartPost(BASE_BACKUP_PROFILE + "/" + uriEncode(this._profileName) + "/" + this._clientId, multipartEntityBuilder));
if (response.length() == 0) {
return true;
} else {
return false;
}
} catch (Exception e) {
return false;
}
} | java | {
"resource": ""
} |
q8349 | Client.exportConfigurationAndProfile | train | public JSONObject exportConfigurationAndProfile(String oldExport) {
try {
BasicNameValuePair[] params = {
new BasicNameValuePair("oldExport", oldExport)
};
String url = BASE_BACKUP_PROFILE + "/" + uriEncode(this._profileName) + "/" + this._clientId;
return new JSONObject(doGet(url, new BasicNameValuePair[]{}));
} catch (Exception e) {
return new JSONObject();
}
} | java | {
"resource": ""
} |
q8350 | BackupService.getGroups | train | private List<Group> getGroups() throws Exception {
List<Group> groups = new ArrayList<Group>();
List<Group> sourceGroups = PathOverrideService.getInstance().findAllGroups();
// loop through the groups
for (Group sourceGroup : sourceGroups) {
Group group = new Group();
// add all methods
ArrayList<Method> methods = new ArrayList<Method>();
for (Method sourceMethod : EditService.getInstance().getMethodsFromGroupId(sourceGroup.getId(), null)) {
Method method = new Method();
method.setClassName(sourceMethod.getClassName());
method.setMethodName(sourceMethod.getMethodName());
methods.add(method);
}
group.setMethods(methods);
group.setName(sourceGroup.getName());
groups.add(group);
}
return groups;
} | java | {
"resource": ""
} |
q8351 | BackupService.getProfileBackupData | train | public SingleProfileBackup getProfileBackupData(int profileID, String clientUUID) throws Exception {
SingleProfileBackup singleProfileBackup = new SingleProfileBackup();
List<PathOverride> enabledPaths = new ArrayList<>();
List<EndpointOverride> paths = PathOverrideService.getInstance().getPaths(profileID, clientUUID, null);
for (EndpointOverride override : paths) {
if (override.getRequestEnabled() || override.getResponseEnabled()) {
PathOverride pathOverride = new PathOverride();
pathOverride.setPathName(override.getPathName());
if (override.getRequestEnabled()) {
pathOverride.setRequestEnabled(true);
}
if (override.getResponseEnabled()) {
pathOverride.setResponseEnabled(true);
}
pathOverride.setEnabledEndpoints(override.getEnabledEndpoints());
enabledPaths.add(pathOverride);
}
}
singleProfileBackup.setEnabledPaths(enabledPaths);
Client backupClient = ClientService.getInstance().findClient(clientUUID, profileID);
ServerGroup activeServerGroup = ServerRedirectService.getInstance().getServerGroup(backupClient.getActiveServerGroup(), profileID);
singleProfileBackup.setActiveServerGroup(activeServerGroup);
return singleProfileBackup;
} | java | {
"resource": ""
} |
q8352 | BackupService.getBackupData | train | public Backup getBackupData() throws Exception {
Backup backupData = new Backup();
backupData.setGroups(getGroups());
backupData.setProfiles(getProfiles());
ArrayList<Script> scripts = new ArrayList<Script>();
Collections.addAll(scripts, ScriptService.getInstance().getScripts());
backupData.setScripts(scripts);
return backupData;
} | java | {
"resource": ""
} |
q8353 | BackupService.getServerForName | train | private MBeanServer getServerForName(String name) {
try {
MBeanServer mbeanServer = null;
final ObjectName objectNameQuery = new ObjectName(name + ":type=Service,*");
for (final MBeanServer server : MBeanServerFactory.findMBeanServer(null)) {
if (server.queryNames(objectNameQuery, null).size() > 0) {
mbeanServer = server;
// we found it, bail out
break;
}
}
return mbeanServer;
} catch (Exception e) {
}
return null;
} | java | {
"resource": ""
} |
q8354 | Proxy.setProxyRequestHeaders | train | @SuppressWarnings("unchecked")
private void setProxyRequestHeaders(HttpServletRequest httpServletRequest,
HttpMethod httpMethodProxyRequest) throws Exception {
RequestInformation requestInfo = requestInformation.get();
String hostName = HttpUtilities.getHostNameFromURL(httpServletRequest.getRequestURL().toString());
// Get an Enumeration of all of the header names sent by the client
Boolean stripTransferEncoding = false;
Enumeration<String> enumerationOfHeaderNames = httpServletRequest.getHeaderNames();
while (enumerationOfHeaderNames.hasMoreElements()) {
String stringHeaderName = enumerationOfHeaderNames.nextElement();
if (stringHeaderName.equalsIgnoreCase(STRING_CONTENT_LENGTH_HEADER_NAME)) {
// don't add this header
continue;
}
// The forwarding proxy may supply a POST encoding hint in ODO-POST-TYPE
if (stringHeaderName.equalsIgnoreCase("ODO-POST-TYPE") &&
httpServletRequest.getHeader("ODO-POST-TYPE").startsWith("content-length:")) {
stripTransferEncoding = true;
}
logger.info("Current header: {}", stringHeaderName);
// As per the Java Servlet API 2.5 documentation:
// Some headers, such as Accept-Language can be sent by clients
// as several headers each with a different value rather than
// sending the header as a comma separated list.
// Thus, we get an Enumeration of the header values sent by the
// client
Enumeration<String> enumerationOfHeaderValues = httpServletRequest.getHeaders(stringHeaderName);
while (enumerationOfHeaderValues.hasMoreElements()) {
String stringHeaderValue = enumerationOfHeaderValues.nextElement();
// In case the proxy host is running multiple virtual servers,
// rewrite the Host header to ensure that we get content from
// the correct virtual server
if (stringHeaderName.equalsIgnoreCase(STRING_HOST_HEADER_NAME) &&
requestInfo.handle) {
String hostValue = getHostHeaderForHost(hostName);
if (hostValue != null) {
stringHeaderValue = hostValue;
}
}
Header header = new Header(stringHeaderName, stringHeaderValue);
// Set the same header on the proxy request
httpMethodProxyRequest.addRequestHeader(header);
}
}
// this strips transfer encoding headers and adds in the appropriate content-length header
// based on the hint provided in the ODO-POST-TYPE header(sent from BrowserMobProxyHandler)
if (stripTransferEncoding) {
httpMethodProxyRequest.removeRequestHeader("transfer-encoding");
// add content length back in based on the ODO information
String contentLengthHint = httpServletRequest.getHeader("ODO-POST-TYPE");
String[] contentLengthParts = contentLengthHint.split(":");
httpMethodProxyRequest.addRequestHeader("content-length", contentLengthParts[1]);
// remove the odo-post-type header
httpMethodProxyRequest.removeRequestHeader("ODO-POST-TYPE");
}
// bail if we aren't fully handling this request
if (!requestInfo.handle) {
return;
}
// deal with header overrides for the request
processRequestHeaderOverrides(httpMethodProxyRequest);
} | java | {
"resource": ""
} |
q8355 | Proxy.processRequestHeaderOverrides | train | private void processRequestHeaderOverrides(HttpMethod httpMethodProxyRequest) throws Exception {
RequestInformation requestInfo = requestInformation.get();
for (EndpointOverride selectedPath : requestInfo.selectedRequestPaths) {
List<EnabledEndpoint> points = selectedPath.getEnabledEndpoints();
for (EnabledEndpoint endpoint : points) {
if (endpoint.getOverrideId() == Constants.PLUGIN_REQUEST_HEADER_OVERRIDE_ADD) {
httpMethodProxyRequest.addRequestHeader(endpoint.getArguments()[0].toString(),
endpoint.getArguments()[1].toString());
requestInfo.modified = true;
} else if (endpoint.getOverrideId() == Constants.PLUGIN_REQUEST_HEADER_OVERRIDE_REMOVE) {
httpMethodProxyRequest.removeRequestHeader(endpoint.getArguments()[0].toString());
requestInfo.modified = true;
}
}
}
} | java | {
"resource": ""
} |
q8356 | Proxy.getHostHeaderForHost | train | private String getHostHeaderForHost(String hostName) {
List<ServerRedirect> servers = serverRedirectService.tableServers(requestInformation.get().client.getId());
for (ServerRedirect server : servers) {
if (server.getSrcUrl().compareTo(hostName) == 0) {
String hostHeader = server.getHostHeader();
if (hostHeader == null || hostHeader.length() == 0) {
return null;
}
return hostHeader;
}
}
return null;
} | java | {
"resource": ""
} |
q8357 | Proxy.processClientId | train | private void processClientId(HttpServletRequest httpServletRequest, History history) {
// get the client id from the request header if applicable.. otherwise set to default
// also set the client uuid in the history object
if (httpServletRequest.getHeader(Constants.PROFILE_CLIENT_HEADER_NAME) != null &&
!httpServletRequest.getHeader(Constants.PROFILE_CLIENT_HEADER_NAME).equals("")) {
history.setClientUUID(httpServletRequest.getHeader(Constants.PROFILE_CLIENT_HEADER_NAME));
} else {
history.setClientUUID(Constants.PROFILE_CLIENT_DEFAULT_ID);
}
logger.info("Client UUID is: {}", history.getClientUUID());
} | java | {
"resource": ""
} |
q8358 | Proxy.getApplicablePathNames | train | private JSONArray getApplicablePathNames (String requestUrl, Integer requestType) throws Exception {
RequestInformation requestInfo = requestInformation.get();
List<EndpointOverride> applicablePaths;
JSONArray pathNames = new JSONArray();
// Get all paths that match the request
applicablePaths = PathOverrideService.getInstance().getSelectedPaths(Constants.OVERRIDE_TYPE_REQUEST, requestInfo.client,
requestInfo.profile,
requestUrl + "?" + requestInfo.originalRequestInfo.getQueryString(),
requestType, true);
// Extract just the path name from each path
for (EndpointOverride path : applicablePaths) {
JSONObject pathName = new JSONObject();
pathName.put("name", path.getPathName());
pathNames.put(pathName);
}
return pathNames;
} | java | {
"resource": ""
} |
q8359 | Proxy.getDestinationHostName | train | private String getDestinationHostName(String hostName) {
List<ServerRedirect> servers = serverRedirectService
.tableServers(requestInformation.get().client.getId());
for (ServerRedirect server : servers) {
if (server.getSrcUrl().compareTo(hostName) == 0) {
if (server.getDestUrl() != null && server.getDestUrl().compareTo("") != 0) {
return server.getDestUrl();
} else {
logger.warn("Using source URL as destination URL since no destination was specified for: {}",
server.getSrcUrl());
}
// only want to apply the first host name change found
break;
}
}
return hostName;
} | java | {
"resource": ""
} |
q8360 | Proxy.processVirtualHostName | train | private void processVirtualHostName(HttpMethod httpMethodProxyRequest, HttpServletRequest httpServletRequest) {
String virtualHostName;
if (httpMethodProxyRequest.getRequestHeader(STRING_HOST_HEADER_NAME) != null) {
virtualHostName = HttpUtilities.removePortFromHostHeaderString(httpMethodProxyRequest.getRequestHeader(STRING_HOST_HEADER_NAME).getValue());
} else {
virtualHostName = HttpUtilities.getHostNameFromURL(httpServletRequest.getRequestURL().toString());
}
httpMethodProxyRequest.getParams().setVirtualHost(virtualHostName);
} | java | {
"resource": ""
} |
q8361 | Proxy.cullDisabledPaths | train | private void cullDisabledPaths() throws Exception {
ArrayList<EndpointOverride> removePaths = new ArrayList<EndpointOverride>();
RequestInformation requestInfo = requestInformation.get();
for (EndpointOverride selectedPath : requestInfo.selectedResponsePaths) {
// check repeat count on selectedPath
// -1 is unlimited
if (selectedPath != null && selectedPath.getRepeatNumber() == 0) {
// skip
removePaths.add(selectedPath);
} else if (selectedPath != null && selectedPath.getRepeatNumber() != -1) {
// need to decrement the #
selectedPath.updateRepeatNumber(selectedPath.getRepeatNumber() - 1);
}
}
// remove paths if we need to
for (EndpointOverride removePath : removePaths) {
requestInfo.selectedResponsePaths.remove(removePath);
}
} | java | {
"resource": ""
} |
q8362 | Proxy.getRemoveHeaders | train | private ArrayList<String> getRemoveHeaders() throws Exception {
ArrayList<String> headersToRemove = new ArrayList<String>();
for (EndpointOverride selectedPath : requestInformation.get().selectedResponsePaths) {
// check to see if there is custom override data or if we have headers to remove
List<EnabledEndpoint> points = selectedPath.getEnabledEndpoints();
for (EnabledEndpoint endpoint : points) {
// skip if repeat count is 0
if (endpoint.getRepeatNumber() == 0) {
continue;
}
if (endpoint.getOverrideId() == Constants.PLUGIN_RESPONSE_HEADER_OVERRIDE_REMOVE) {
// add to remove headers array
headersToRemove.add(endpoint.getArguments()[0].toString());
endpoint.decrementRepeatNumber();
}
}
}
return headersToRemove;
} | java | {
"resource": ""
} |
q8363 | Proxy.executeProxyRequest | train | private void executeProxyRequest(HttpMethod httpMethodProxyRequest,
HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse, History history) {
try {
RequestInformation requestInfo = requestInformation.get();
// Execute the request
// set virtual host so the server knows how to direct the request
// If the host header exists then this uses that value
// Otherwise the hostname from the URL is used
processVirtualHostName(httpMethodProxyRequest, httpServletRequest);
cullDisabledPaths();
// check for existence of ODO_PROXY_HEADER
// finding it indicates a bad loop back through the proxy
if (httpServletRequest.getHeader(Constants.ODO_PROXY_HEADER) != null) {
logger.error("Request has looped back into the proxy. This will not be executed: {}", httpServletRequest.getRequestURL());
return;
}
// set ODO_PROXY_HEADER
httpMethodProxyRequest.addRequestHeader(Constants.ODO_PROXY_HEADER, "proxied");
requestInfo.blockRequest = hasRequestBlock();
PluginResponse responseWrapper = new PluginResponse(httpServletResponse);
requestInfo.jsonpCallback = stripJSONPToOutstr(httpServletRequest, responseWrapper);
if (!requestInfo.blockRequest) {
logger.info("Sending request to server");
history.setModified(requestInfo.modified);
history.setRequestSent(true);
executeRequest(httpMethodProxyRequest,
httpServletRequest,
responseWrapper,
history);
} else {
history.setRequestSent(false);
}
logOriginalResponseHistory(responseWrapper, history);
applyResponseOverrides(responseWrapper, httpServletRequest, httpMethodProxyRequest, history);
// store history
history.setModified(requestInfo.modified);
logRequestHistory(httpMethodProxyRequest, responseWrapper, history);
writeResponseOutput(responseWrapper, requestInfo.jsonpCallback);
} catch (Exception e) {
e.printStackTrace();
}
} | java | {
"resource": ""
} |
q8364 | Proxy.executeRequest | train | private void executeRequest(HttpMethod httpMethodProxyRequest,
HttpServletRequest httpServletRequest,
PluginResponse httpServletResponse,
History history) throws Exception {
int intProxyResponseCode = 999;
// Create a default HttpClient
HttpClient httpClient = new HttpClient();
HttpState state = new HttpState();
try {
httpMethodProxyRequest.setFollowRedirects(false);
ArrayList<String> headersToRemove = getRemoveHeaders();
httpClient.getParams().setSoTimeout(60000);
httpServletRequest.setAttribute("com.groupon.odo.removeHeaders", headersToRemove);
// exception handling for httpclient
HttpMethodRetryHandler noretryhandler = new HttpMethodRetryHandler() {
public boolean retryMethod(
final HttpMethod method,
final IOException exception,
int executionCount) {
return false;
}
};
httpMethodProxyRequest.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, noretryhandler);
intProxyResponseCode = httpClient.executeMethod(httpMethodProxyRequest.getHostConfiguration(), httpMethodProxyRequest, state);
} catch (Exception e) {
// Return a gateway timeout
httpServletResponse.setStatus(504);
httpServletResponse.setHeader(Constants.HEADER_STATUS, "504");
httpServletResponse.flushBuffer();
return;
}
logger.info("Response code: {}, {}", intProxyResponseCode,
HttpUtilities.getURL(httpMethodProxyRequest.getURI().toString()));
// Pass the response code back to the client
httpServletResponse.setStatus(intProxyResponseCode);
// Pass response headers back to the client
Header[] headerArrayResponse = httpMethodProxyRequest.getResponseHeaders();
for (Header header : headerArrayResponse) {
// remove transfer-encoding header. The http libraries will handle this encoding
if (header.getName().toLowerCase().equals("transfer-encoding")) {
continue;
}
httpServletResponse.setHeader(header.getName(), header.getValue());
}
// there is no data for a HTTP 304 or 204
if (intProxyResponseCode != HttpServletResponse.SC_NOT_MODIFIED &&
intProxyResponseCode != HttpServletResponse.SC_NO_CONTENT) {
// Send the content to the client
httpServletResponse.resetBuffer();
httpServletResponse.getOutputStream().write(httpMethodProxyRequest.getResponseBody());
}
// copy cookies to servlet response
for (Cookie cookie : state.getCookies()) {
javax.servlet.http.Cookie servletCookie = new javax.servlet.http.Cookie(cookie.getName(), cookie.getValue());
if (cookie.getPath() != null) {
servletCookie.setPath(cookie.getPath());
}
if (cookie.getDomain() != null) {
servletCookie.setDomain(cookie.getDomain());
}
// convert expiry date to max age
if (cookie.getExpiryDate() != null) {
servletCookie.setMaxAge((int) ((cookie.getExpiryDate().getTime() - System.currentTimeMillis()) / 1000));
}
servletCookie.setSecure(cookie.getSecure());
servletCookie.setVersion(cookie.getVersion());
if (cookie.getComment() != null) {
servletCookie.setComment(cookie.getComment());
}
httpServletResponse.addCookie(servletCookie);
}
} | java | {
"resource": ""
} |
q8365 | Proxy.processRedirect | train | private void processRedirect(String stringStatusCode,
HttpMethod httpMethodProxyRequest,
HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws Exception {
// Check if the proxy response is a redirect
// The following code is adapted from
// org.tigris.noodle.filters.CheckForRedirect
// Hooray for open source software
String stringLocation = httpMethodProxyRequest.getResponseHeader(STRING_LOCATION_HEADER).getValue();
if (stringLocation == null) {
throw new ServletException("Received status code: "
+ stringStatusCode + " but no "
+ STRING_LOCATION_HEADER
+ " header was found in the response");
}
// Modify the redirect to go to this proxy servlet rather than the proxied host
String stringMyHostName = httpServletRequest.getServerName();
if (httpServletRequest.getServerPort() != 80) {
stringMyHostName += ":" + httpServletRequest.getServerPort();
}
stringMyHostName += httpServletRequest.getContextPath();
httpServletResponse.sendRedirect(stringLocation.replace(
getProxyHostAndPort() + this.getProxyPath(),
stringMyHostName));
} | java | {
"resource": ""
} |
q8366 | Proxy.logOriginalRequestHistory | train | private void logOriginalRequestHistory(String requestType,
HttpServletRequest request, History history) {
logger.info("Storing original request history");
history.setRequestType(requestType);
history.setOriginalRequestHeaders(HttpUtilities.getHeaders(request));
history.setOriginalRequestURL(request.getRequestURL().toString());
history.setOriginalRequestParams(request.getQueryString() == null ? "" : request.getQueryString());
logger.info("Done storing");
} | java | {
"resource": ""
} |
q8367 | Proxy.logOriginalResponseHistory | train | private void logOriginalResponseHistory(
PluginResponse httpServletResponse, History history) throws URIException {
RequestInformation requestInfo = requestInformation.get();
if (requestInfo.handle && requestInfo.client.getIsActive()) {
logger.info("Storing original response history");
history.setOriginalResponseHeaders(HttpUtilities.getHeaders(httpServletResponse));
history.setOriginalResponseCode(Integer.toString(httpServletResponse.getStatus()));
history.setOriginalResponseContentType(httpServletResponse.getContentType());
history.setOriginalResponseData(httpServletResponse.getContentString());
logger.info("Done storing");
}
} | java | {
"resource": ""
} |
q8368 | Proxy.logRequestHistory | train | private void logRequestHistory(HttpMethod httpMethodProxyRequest, PluginResponse httpServletResponse,
History history) {
try {
if (requestInformation.get().handle && requestInformation.get().client.getIsActive()) {
logger.info("Storing history");
String createdDate;
SimpleDateFormat sdf = new SimpleDateFormat();
sdf.setTimeZone(new SimpleTimeZone(0, "GMT"));
sdf.applyPattern("dd MMM yyyy HH:mm:ss");
createdDate = sdf.format(new Date()) + " GMT";
history.setCreatedAt(createdDate);
history.setRequestURL(HttpUtilities.getURL(httpMethodProxyRequest.getURI().toString()));
history.setRequestParams(httpMethodProxyRequest.getQueryString() == null ? ""
: httpMethodProxyRequest.getQueryString());
history.setRequestHeaders(HttpUtilities.getHeaders(httpMethodProxyRequest));
history.setResponseHeaders(HttpUtilities.getHeaders(httpServletResponse));
history.setResponseCode(Integer.toString(httpServletResponse.getStatus()));
history.setResponseContentType(httpServletResponse.getContentType());
history.setResponseData(httpServletResponse.getContentString());
history.setResponseBodyDecoded(httpServletResponse.isContentDecoded());
HistoryService.getInstance().addHistory(history);
logger.info("Done storing");
}
} catch (URIException e) {
e.printStackTrace();
}
} | java | {
"resource": ""
} |
q8369 | BrowserMobProxyHandler.handleConnectOriginal | train | public void handleConnectOriginal(String pathInContext, String pathParams, HttpRequest request, HttpResponse response) throws HttpException, IOException {
URI uri = request.getURI();
try {
LOG.fine("CONNECT: " + uri);
InetAddrPort addrPort;
// When logging, we'll attempt to send messages to hosts that don't exist
if (uri.toString().endsWith(".selenium.doesnotexist:443")) {
// so we have to do set the host to be localhost (you can't new up an IAP with a non-existent hostname)
addrPort = new InetAddrPort(443);
} else {
addrPort = new InetAddrPort(uri.toString());
}
if (isForbidden(HttpMessage.__SSL_SCHEME, addrPort.getHost(), addrPort.getPort(), false)) {
sendForbid(request, response, uri);
} else {
HttpConnection http_connection = request.getHttpConnection();
http_connection.forceClose();
HttpServer server = http_connection.getHttpServer();
SslListener listener = getSslRelayOrCreateNewOdo(uri, addrPort, server);
int port = listener.getPort();
// Get the timeout
int timeoutMs = 30000;
Object maybesocket = http_connection.getConnection();
if (maybesocket instanceof Socket) {
Socket s = (Socket) maybesocket;
timeoutMs = s.getSoTimeout();
}
// Create the tunnel
HttpTunnel tunnel = newHttpTunnel(request, response, InetAddress.getByName(null), port, timeoutMs);
if (tunnel != null) {
// TODO - need to setup semi-busy loop for IE.
if (_tunnelTimeoutMs > 0) {
tunnel.getSocket().setSoTimeout(_tunnelTimeoutMs);
if (maybesocket instanceof Socket) {
Socket s = (Socket) maybesocket;
s.setSoTimeout(_tunnelTimeoutMs);
}
}
tunnel.setTimeoutMs(timeoutMs);
customizeConnection(pathInContext, pathParams, request, tunnel.getSocket());
request.getHttpConnection().setHttpTunnel(tunnel);
response.setStatus(HttpResponse.__200_OK);
response.setContentLength(0);
}
request.setHandled(true);
}
} catch (Exception e) {
LOG.fine("error during handleConnect", e);
response.sendError(HttpResponse.__500_Internal_Server_Error, e.toString());
}
} | java | {
"resource": ""
} |
q8370 | BrowserMobProxyHandler.wireUpSslWithCyberVilliansCAOdo | train | protected X509Certificate wireUpSslWithCyberVilliansCAOdo(String host, SslListener listener) {
host = requestOriginalHostName.get();
// Add cybervillians CA(from browsermob)
try {
// see https://github.com/webmetrics/browsermob-proxy/issues/105
String escapedHost = host.replace('*', '_');
KeyStoreManager keyStoreManager = Utils.getKeyStoreManager(escapedHost);
keyStoreManager.getKeyStore().deleteEntry(KeyStoreManager._caPrivKeyAlias);
keyStoreManager.persist();
listener.setKeystore(new File("seleniumSslSupport" + File.separator + escapedHost + File.separator + "cybervillainsCA.jks").getAbsolutePath());
return keyStoreManager.getCertificateByAlias(escapedHost);
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q8371 | BrowserMobProxyHandler.startRelayWithPortTollerance | train | private void startRelayWithPortTollerance(HttpServer server, SslListener relay, int tries) throws Exception {
if (tries >= 5) {
throw new BindException("Unable to bind to several ports, most recently " + relay.getPort() + ". Giving up");
}
try {
if (server.isStarted()) {
relay.start();
} else {
throw new RuntimeException("Can't start SslRelay: server is not started (perhaps it was just shut down?)");
}
} catch (BindException e) {
// doh - the port is being used up, let's pick a new port
LOG.info("Unable to bind to port %d, going to try port %d now", relay.getPort(), relay.getPort() + 1);
relay.setPort(relay.getPort() + 1);
startRelayWithPortTollerance(server, relay, tries + 1);
}
} | java | {
"resource": ""
} |
q8372 | BrowserMobProxyHandler.getUnsafeOkHttpClient | train | private static OkHttpClient getUnsafeOkHttpClient() {
try {
// Create a trust manager that does not validate certificate chains
final TrustManager[] trustAllCerts = new TrustManager[] {
new X509TrustManager() {
@Override
public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return null;
}
}
};
// Install the all-trusting trust manager
final SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
// Create an ssl socket factory with our all-trusting manager
final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.setSslSocketFactory(sslSocketFactory);
okHttpClient.setHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
});
return okHttpClient;
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q8373 | BrowserMobProxyHandler.cleanup | train | public void cleanup() {
synchronized (_sslMap) {
for (SslRelayOdo relay : _sslMap.values()) {
if (relay.getHttpServer() != null && relay.isStarted()) {
relay.getHttpServer().removeListener(relay);
}
}
sslRelays.clear();
}
} | java | {
"resource": ""
} |
q8374 | OverrideService.removeOverride | train | public void removeOverride(int overrideId, int pathId, Integer ordinal, String clientUUID) {
// TODO: reorder priorities after removal
PreparedStatement statement = null;
try (Connection sqlConnection = sqlService.getConnection()) {
int enabledId = getEnabledEndpoint(pathId, overrideId, ordinal, clientUUID).getId();
statement = sqlConnection.prepareStatement(
"DELETE FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" WHERE " + Constants.GENERIC_ID + " = ?"
);
statement.setInt(1, enabledId);
statement.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
} | java | {
"resource": ""
} |
q8375 | OverrideService.increasePriority | train | public void increasePriority(int overrideId, int ordinal, int pathId, String clientUUID) {
logger.info("Increase priority");
int origPriority = -1;
int newPriority = -1;
int origId = 0;
int newId = 0;
PreparedStatement statement = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
results = null;
statement = sqlConnection.prepareStatement(
"SELECT * FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" WHERE " + Constants.ENABLED_OVERRIDES_PATH_ID + " = ?" +
" AND " + Constants.GENERIC_CLIENT_UUID + " = ?" +
" ORDER BY " + Constants.ENABLED_OVERRIDES_PRIORITY
);
statement.setInt(1, pathId);
statement.setString(2, clientUUID);
results = statement.executeQuery();
int ordinalCount = 0;
while (results.next()) {
if (results.getInt(Constants.ENABLED_OVERRIDES_OVERRIDE_ID) == overrideId) {
ordinalCount++;
if (ordinalCount == ordinal) {
origPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
origId = results.getInt(Constants.GENERIC_ID);
break;
}
}
newPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
newId = results.getInt(Constants.GENERIC_ID);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
try (Connection sqlConnection = sqlService.getConnection()) {
// update priorities
if (origPriority != -1 && newPriority != -1) {
statement = sqlConnection.prepareStatement(
"UPDATE " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" SET " + Constants.ENABLED_OVERRIDES_PRIORITY + "=?" +
" WHERE " + Constants.GENERIC_ID + "=?"
);
statement.setInt(1, origPriority);
statement.setInt(2, newId);
statement.executeUpdate();
statement.close();
statement = sqlConnection.prepareStatement(
"UPDATE " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" SET " + Constants.ENABLED_OVERRIDES_PRIORITY + "=?" +
" WHERE " + Constants.GENERIC_ID + "=?"
);
statement.setInt(1, newPriority);
statement.setInt(2, origId);
statement.executeUpdate();
}
} catch (Exception e) {
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
} | java | {
"resource": ""
} |
q8376 | OverrideService.preparePlaceHolders | train | private static String preparePlaceHolders(int length) {
StringBuilder builder = new StringBuilder();
for (int i = 0; i < length; ) {
builder.append("?");
if (++i < length) {
builder.append(",");
}
}
return builder.toString();
} | java | {
"resource": ""
} |
q8377 | OverrideService.disableAllOverrides | train | public void disableAllOverrides(int pathID, String clientUUID) {
PreparedStatement statement = null;
try (Connection sqlConnection = sqlService.getConnection()) {
statement = sqlConnection.prepareStatement(
"DELETE FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" WHERE " + Constants.ENABLED_OVERRIDES_PATH_ID + " = ? " +
" AND " + Constants.GENERIC_CLIENT_UUID + " = ? "
);
statement.setInt(1, pathID);
statement.setString(2, clientUUID);
statement.execute();
statement.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
} | java | {
"resource": ""
} |
q8378 | OverrideService.disableAllOverrides | train | public void disableAllOverrides(int pathID, String clientUUID, int overrideType) {
PreparedStatement statement = null;
try (Connection sqlConnection = sqlService.getConnection()) {
ArrayList<Integer> enabledOverrides = new ArrayList<Integer>();
enabledOverrides.add(Constants.PLUGIN_REQUEST_HEADER_OVERRIDE_ADD);
enabledOverrides.add(Constants.PLUGIN_REQUEST_HEADER_OVERRIDE_REMOVE);
enabledOverrides.add(Constants.PLUGIN_REQUEST_OVERRIDE_CUSTOM);
enabledOverrides.add(Constants.PLUGIN_REQUEST_OVERRIDE_CUSTOM_POST_BODY);
String overridePlaceholders = preparePlaceHolders(enabledOverrides.size());
statement = sqlConnection.prepareStatement(
"DELETE FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" WHERE " + Constants.ENABLED_OVERRIDES_PATH_ID + " = ? " +
" AND " + Constants.GENERIC_CLIENT_UUID + " = ? " +
" AND " + Constants.ENABLED_OVERRIDES_OVERRIDE_ID +
(overrideType == Constants.OVERRIDE_TYPE_RESPONSE ? " NOT" : "") +
" IN ( " + overridePlaceholders + " )"
);
statement.setInt(1, pathID);
statement.setString(2, clientUUID);
for (int i = 3; i <= enabledOverrides.size() + 2; ++i) {
statement.setInt(i, enabledOverrides.get(i - 3));
}
statement.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
} | java | {
"resource": ""
} |
q8379 | OverrideService.getEnabledEndpoints | train | public List<EnabledEndpoint> getEnabledEndpoints(int pathId, String clientUUID, String[] filters) throws Exception {
ArrayList<EnabledEndpoint> enabledOverrides = new ArrayList<EnabledEndpoint>();
PreparedStatement query = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
query = sqlConnection.prepareStatement(
"SELECT * FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" WHERE " + Constants.ENABLED_OVERRIDES_PATH_ID + "=?" +
" AND " + Constants.GENERIC_CLIENT_UUID + "=?" +
" ORDER BY " + Constants.ENABLED_OVERRIDES_PRIORITY
);
query.setInt(1, pathId);
query.setString(2, clientUUID);
results = query.executeQuery();
while (results.next()) {
EnabledEndpoint endpoint = this.getPartialEnabledEndpointFromResultset(results);
com.groupon.odo.proxylib.models.Method m = PathOverrideService.getInstance().getMethodForOverrideId(endpoint.getOverrideId());
// this is an errant entry.. perhaps a method got deleted from a plugin
// we'll also remove it from the endpoint
if (m == null) {
PathOverrideService.getInstance().removeOverride(endpoint.getOverrideId());
continue;
}
// check filters and see if any match
boolean addOverride = false;
if (filters != null) {
for (String filter : filters) {
if (m.getMethodType().endsWith(filter)) {
addOverride = true;
break;
}
}
} else {
// if there are no filters then we assume that the requester wants all enabled overrides
addOverride = true;
}
if (addOverride) {
enabledOverrides.add(endpoint);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (query != null) {
query.close();
}
} catch (Exception e) {
}
}
// now go through the ArrayList and get the method for all of the endpoints
// have to do this so we don't have overlapping SQL queries
ArrayList<EnabledEndpoint> enabledOverridesWithMethods = new ArrayList<EnabledEndpoint>();
for (EnabledEndpoint endpoint : enabledOverrides) {
if (endpoint.getOverrideId() >= 0) {
com.groupon.odo.proxylib.models.Method m = PathOverrideService.getInstance().getMethodForOverrideId(endpoint.getOverrideId());
endpoint.setMethodInformation(m);
}
enabledOverridesWithMethods.add(endpoint);
}
return enabledOverridesWithMethods;
} | java | {
"resource": ""
} |
q8380 | OverrideService.getCurrentMethodOrdinal | train | public int getCurrentMethodOrdinal(int overrideId, int pathId, String clientUUID, String[] filters) throws Exception {
int currentOrdinal = 0;
List<EnabledEndpoint> enabledEndpoints = getEnabledEndpoints(pathId, clientUUID, filters);
for (EnabledEndpoint enabledEndpoint : enabledEndpoints) {
if (enabledEndpoint.getOverrideId() == overrideId) {
currentOrdinal++;
}
}
return currentOrdinal;
} | java | {
"resource": ""
} |
q8381 | OverrideService.getPartialEnabledEndpointFromResultset | train | private EnabledEndpoint getPartialEnabledEndpointFromResultset(ResultSet result) throws Exception {
EnabledEndpoint endpoint = new EnabledEndpoint();
endpoint.setId(result.getInt(Constants.GENERIC_ID));
endpoint.setPathId(result.getInt(Constants.ENABLED_OVERRIDES_PATH_ID));
endpoint.setOverrideId(result.getInt(Constants.ENABLED_OVERRIDES_OVERRIDE_ID));
endpoint.setPriority(result.getInt(Constants.ENABLED_OVERRIDES_PRIORITY));
endpoint.setRepeatNumber(result.getInt(Constants.ENABLED_OVERRIDES_REPEAT_NUMBER));
endpoint.setResponseCode(result.getString(Constants.ENABLED_OVERRIDES_RESPONSE_CODE));
ArrayList<Object> args = new ArrayList<Object>();
try {
JSONArray arr = new JSONArray(result.getString(Constants.ENABLED_OVERRIDES_ARGUMENTS));
for (int x = 0; x < arr.length(); x++) {
args.add(arr.get(x));
}
} catch (Exception e) {
// ignore it.. this means the entry was null/corrupt
}
endpoint.setArguments(args.toArray(new Object[0]));
return endpoint;
} | java | {
"resource": ""
} |
q8382 | OverrideService.getOverrideIdForMethod | train | public Integer getOverrideIdForMethod(String className, String methodName) {
Integer overrideId = null;
PreparedStatement query = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
query = sqlConnection.prepareStatement(
"SELECT * FROM " + Constants.DB_TABLE_OVERRIDE +
" WHERE " + Constants.OVERRIDE_CLASS_NAME + " = ?" +
" AND " + Constants.OVERRIDE_METHOD_NAME + " = ?"
);
query.setString(1, className);
query.setString(2, methodName);
results = query.executeQuery();
if (results.next()) {
overrideId = results.getInt(Constants.GENERIC_ID);
}
} catch (SQLException e) {
e.printStackTrace();
return null;
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (query != null) {
query.close();
}
} catch (Exception e) {
}
}
return overrideId;
} | java | {
"resource": ""
} |
q8383 | ClientService.findAllClients | train | public List<Client> findAllClients(int profileId) throws Exception {
ArrayList<Client> clients = new ArrayList<Client>();
PreparedStatement query = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
query = sqlConnection.prepareStatement(
"SELECT * FROM " + Constants.DB_TABLE_CLIENT +
" WHERE " + Constants.GENERIC_PROFILE_ID + " = ?"
);
query.setInt(1, profileId);
results = query.executeQuery();
while (results.next()) {
clients.add(this.getClientFromResultSet(results));
}
} catch (Exception e) {
throw e;
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (query != null) {
query.close();
}
} catch (Exception e) {
}
}
return clients;
} | java | {
"resource": ""
} |
q8384 | ClientService.getClient | train | public Client getClient(int clientId) throws Exception {
Client client = null;
PreparedStatement statement = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
String queryString = "SELECT * FROM " + Constants.DB_TABLE_CLIENT +
" WHERE " + Constants.GENERIC_ID + " = ?";
statement = sqlConnection.prepareStatement(queryString);
statement.setInt(1, clientId);
results = statement.executeQuery();
if (results.next()) {
client = this.getClientFromResultSet(results);
}
} catch (Exception e) {
throw e;
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
return client;
} | java | {
"resource": ""
} |
q8385 | ClientService.findClient | train | public Client findClient(String clientUUID, Integer profileId) throws Exception {
Client client = null;
/* ERROR CODE: 500 WHEN TRYING TO DELETE A SERVER GROUP.
THIS APPEARS TO BE BECAUSE CLIENT UUID IS NULL.
*/
/* CODE ADDED TO PREVENT NULL POINTERS. */
if (clientUUID == null) {
clientUUID = "";
}
// first see if the clientUUID is actually a uuid.. it might be a friendlyName and need conversion
/* A UUID IS A UNIVERSALLY UNIQUE IDENTIFIER. */
if (clientUUID.compareTo(Constants.PROFILE_CLIENT_DEFAULT_ID) != 0 &&
!clientUUID.matches("[\\w]{8}-[\\w]{4}-[\\w]{4}-[\\w]{4}-[\\w]{12}")) {
Client tmpClient = this.findClientFromFriendlyName(profileId, clientUUID);
// if we can't find a client then fall back to the default ID
if (tmpClient == null) {
clientUUID = Constants.PROFILE_CLIENT_DEFAULT_ID;
} else {
return tmpClient;
}
}
PreparedStatement statement = null;
ResultSet results = null;
try (Connection sqlConnection = sqlService.getConnection()) {
String queryString = "SELECT * FROM " + Constants.DB_TABLE_CLIENT +
" WHERE " + Constants.CLIENT_CLIENT_UUID + " = ?";
if (profileId != null) {
queryString += " AND " + Constants.GENERIC_PROFILE_ID + "=?";
}
statement = sqlConnection.prepareStatement(queryString);
statement.setString(1, clientUUID);
if (profileId != null) {
statement.setInt(2, profileId);
}
results = statement.executeQuery();
if (results.next()) {
client = this.getClientFromResultSet(results);
}
} catch (Exception e) {
throw e;
} finally {
try {
if (results != null) {
results.close();
}
} catch (Exception e) {
}
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
return client;
} | java | {
"resource": ""
} |
q8386 | ClientService.getClientFromResultSet | train | private Client getClientFromResultSet(ResultSet result) throws Exception {
Client client = new Client();
client.setId(result.getInt(Constants.GENERIC_ID));
client.setUUID(result.getString(Constants.CLIENT_CLIENT_UUID));
client.setFriendlyName(result.getString(Constants.CLIENT_FRIENDLY_NAME));
client.setProfile(ProfileService.getInstance().findProfile(result.getInt(Constants.GENERIC_PROFILE_ID)));
client.setIsActive(result.getBoolean(Constants.CLIENT_IS_ACTIVE));
client.setActiveServerGroup(result.getInt(Constants.CLIENT_ACTIVESERVERGROUP));
return client;
} | java | {
"resource": ""
} |
q8387 | ClientService.setFriendlyName | train | public Client setFriendlyName(int profileId, String clientUUID, String friendlyName) throws Exception {
// first see if this friendlyName is already in use
Client client = this.findClientFromFriendlyName(profileId, friendlyName);
if (client != null && !client.getUUID().equals(clientUUID)) {
throw new Exception("Friendly name already in use");
}
PreparedStatement statement = null;
int rowsAffected = 0;
try (Connection sqlConnection = sqlService.getConnection()) {
statement = sqlConnection.prepareStatement(
"UPDATE " + Constants.DB_TABLE_CLIENT +
" SET " + Constants.CLIENT_FRIENDLY_NAME + " = ?" +
" WHERE " + Constants.CLIENT_CLIENT_UUID + " = ?" +
" AND " + Constants.GENERIC_PROFILE_ID + " = ?"
);
statement.setString(1, friendlyName);
statement.setString(2, clientUUID);
statement.setInt(3, profileId);
rowsAffected = statement.executeUpdate();
} catch (Exception e) {
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
if (rowsAffected == 0) {
return null;
}
return this.findClient(clientUUID, profileId);
} | java | {
"resource": ""
} |
q8388 | ClientService.updateActive | train | public void updateActive(int profileId, String clientUUID, Boolean active) throws Exception {
PreparedStatement statement = null;
try (Connection sqlConnection = sqlService.getConnection()) {
statement = sqlConnection.prepareStatement(
"UPDATE " + Constants.DB_TABLE_CLIENT +
" SET " + Constants.CLIENT_IS_ACTIVE + "= ?" +
" WHERE " + Constants.GENERIC_CLIENT_UUID + "= ? " +
" AND " + Constants.GENERIC_PROFILE_ID + "= ?"
);
statement.setBoolean(1, active);
statement.setString(2, clientUUID);
statement.setInt(3, profileId);
statement.executeUpdate();
} catch (Exception e) {
// ok to swallow this.. just means there wasn't any
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
} | java | {
"resource": ""
} |
q8389 | ClientService.reset | train | public void reset(int profileId, String clientUUID) throws Exception {
PreparedStatement statement = null;
// TODO: need a better way to do this than brute force.. but the iterative approach is too slow
try (Connection sqlConnection = sqlService.getConnection()) {
// first remove all enabled overrides with this client uuid
String queryString = "DELETE FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
" WHERE " + Constants.GENERIC_CLIENT_UUID + "= ? " +
" AND " + Constants.GENERIC_PROFILE_ID + " = ?";
statement = sqlConnection.prepareStatement(queryString);
statement.setString(1, clientUUID);
statement.setInt(2, profileId);
statement.executeUpdate();
statement.close();
// clean up request response table for this uuid
queryString = "UPDATE " + Constants.DB_TABLE_REQUEST_RESPONSE +
" SET " + Constants.REQUEST_RESPONSE_CUSTOM_REQUEST + "=?, "
+ Constants.REQUEST_RESPONSE_CUSTOM_RESPONSE + "=?, "
+ Constants.REQUEST_RESPONSE_REPEAT_NUMBER + "=-1, "
+ Constants.REQUEST_RESPONSE_REQUEST_ENABLED + "=0, "
+ Constants.REQUEST_RESPONSE_RESPONSE_ENABLED + "=0 "
+ "WHERE " + Constants.GENERIC_CLIENT_UUID + "=? " +
" AND " + Constants.GENERIC_PROFILE_ID + "=?";
statement = sqlConnection.prepareStatement(queryString);
statement.setString(1, "");
statement.setString(2, "");
statement.setString(3, clientUUID);
statement.setInt(4, profileId);
statement.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
}
}
this.updateActive(profileId, clientUUID, false);
} | java | {
"resource": ""
} |
q8390 | ClientService.getProfileIdFromClientId | train | public String getProfileIdFromClientId(int id) {
return (String) sqlService.getFromTable(Constants.CLIENT_PROFILE_ID, Constants.GENERIC_ID, id, Constants.DB_TABLE_CLIENT);
} | java | {
"resource": ""
} |
q8391 | ScriptController.scriptView | train | @RequestMapping(value = "/scripts", method = RequestMethod.GET)
public String scriptView(Model model) throws Exception {
return "script";
} | java | {
"resource": ""
} |
q8392 | ScriptController.getScripts | train | @RequestMapping(value = "/api/scripts", method = RequestMethod.GET)
public
@ResponseBody
HashMap<String, Object> getScripts(Model model,
@RequestParam(required = false) Integer type) throws Exception {
Script[] scripts = ScriptService.getInstance().getScripts(type);
return Utils.getJQGridJSON(scripts, "scripts");
} | java | {
"resource": ""
} |
q8393 | ScriptController.addScript | train | @RequestMapping(value = "/api/scripts", method = RequestMethod.POST)
public
@ResponseBody
Script addScript(Model model,
@RequestParam(required = true) String name,
@RequestParam(required = true) String script) throws Exception {
return ScriptService.getInstance().addScript(name, script);
} | java | {
"resource": ""
} |
q8394 | GroupController.newGroupGet | train | @RequestMapping(value = "group", method = RequestMethod.GET)
public String newGroupGet(Model model) {
model.addAttribute("groups",
pathOverrideService.findAllGroups());
return "groups";
} | java | {
"resource": ""
} |
q8395 | KeyStoreManager.createKeystore | train | protected void createKeystore() {
java.security.cert.Certificate signingCert = null;
PrivateKey caPrivKey = null;
if(_caCert == null || _caPrivKey == null)
{
try
{
log.debug("Keystore or signing cert & keypair not found. Generating...");
KeyPair caKeypair = getRSAKeyPair();
caPrivKey = caKeypair.getPrivate();
signingCert = CertificateCreator.createTypicalMasterCert(caKeypair);
log.debug("Done generating signing cert");
log.debug(signingCert);
_ks.load(null, _keystorepass);
_ks.setCertificateEntry(_caCertAlias, signingCert);
_ks.setKeyEntry(_caPrivKeyAlias, caPrivKey, _keypassword, new java.security.cert.Certificate[] {signingCert});
File caKsFile = new File(root, _caPrivateKeystore);
OutputStream os = new FileOutputStream(caKsFile);
_ks.store(os, _keystorepass);
log.debug("Wrote JKS keystore to: " +
caKsFile.getAbsolutePath());
// also export a .cer that can be imported as a trusted root
// to disable all warning dialogs for interception
File signingCertFile = new File(root, EXPORTED_CERT_NAME);
FileOutputStream cerOut = new FileOutputStream(signingCertFile);
byte[] buf = signingCert.getEncoded();
log.debug("Wrote signing cert to: " + signingCertFile.getAbsolutePath());
cerOut.write(buf);
cerOut.flush();
cerOut.close();
_caCert = (X509Certificate)signingCert;
_caPrivKey = caPrivKey;
}
catch(Exception e)
{
log.error("Fatal error creating/storing keystore or signing cert.", e);
throw new Error(e);
}
}
else
{
log.debug("Successfully loaded keystore.");
log.debug(_caCert);
}
} | java | {
"resource": ""
} |
q8396 | KeyStoreManager.addCertAndPrivateKey | train | public synchronized void addCertAndPrivateKey(String hostname, final X509Certificate cert, final PrivateKey privKey)
throws KeyStoreException, CertificateException, NoSuchAlgorithmException
{
// String alias = ThumbprintUtil.getThumbprint(cert);
_ks.deleteEntry(hostname);
_ks.setCertificateEntry(hostname, cert);
_ks.setKeyEntry(hostname, privKey, _keypassword, new java.security.cert.Certificate[] {cert});
if(persistImmediately)
{
persist();
}
} | java | {
"resource": ""
} |
q8397 | KeyStoreManager.getCertificateByHostname | train | public synchronized X509Certificate getCertificateByHostname(final String hostname) throws KeyStoreException, CertificateParsingException, InvalidKeyException, CertificateExpiredException, CertificateNotYetValidException, SignatureException, CertificateException, NoSuchAlgorithmException, NoSuchProviderException, UnrecoverableKeyException{
String alias = _subjectMap.get(getSubjectForHostname(hostname));
if(alias != null) {
return (X509Certificate)_ks.getCertificate(alias);
}
return getMappedCertificateForHostname(hostname);
} | java | {
"resource": ""
} |
q8398 | KeyStoreManager.getMappedCertificate | train | public synchronized X509Certificate getMappedCertificate(final X509Certificate cert)
throws CertificateEncodingException,
InvalidKeyException,
CertificateException,
CertificateNotYetValidException,
NoSuchAlgorithmException,
NoSuchProviderException,
SignatureException,
KeyStoreException,
UnrecoverableKeyException
{
String thumbprint = ThumbprintUtil.getThumbprint(cert);
String mappedCertThumbprint = _certMap.get(thumbprint);
if(mappedCertThumbprint == null)
{
// Check if we've already mapped this public key from a KeyValue
PublicKey mappedPk = getMappedPublicKey(cert.getPublicKey());
PrivateKey privKey;
if(mappedPk == null)
{
PublicKey pk = cert.getPublicKey();
String algo = pk.getAlgorithm();
KeyPair kp;
if(algo.equals("RSA")) {
kp = getRSAKeyPair();
}
else if(algo.equals("DSA")) {
kp = getDSAKeyPair();
}
else
{
throw new InvalidKeyException("Key algorithm " + algo + " not supported.");
}
mappedPk = kp.getPublic();
privKey = kp.getPrivate();
mapPublicKeys(cert.getPublicKey(), mappedPk);
}
else
{
privKey = getPrivateKey(mappedPk);
}
X509Certificate replacementCert =
CertificateCreator.mitmDuplicateCertificate(
cert,
mappedPk,
getSigningCert(),
getSigningPrivateKey());
addCertAndPrivateKey(null, replacementCert, privKey);
mappedCertThumbprint = ThumbprintUtil.getThumbprint(replacementCert);
_certMap.put(thumbprint, mappedCertThumbprint);
_certMap.put(mappedCertThumbprint, thumbprint);
_subjectMap.put(replacementCert.getSubjectX500Principal().getName(), thumbprint);
if(persistImmediately) {
persist();
}
return replacementCert;
}
return getCertificateByAlias(mappedCertThumbprint);
} | java | {
"resource": ""
} |
q8399 | KeyStoreManager.getMappedCertificateForHostname | train | public X509Certificate getMappedCertificateForHostname(String hostname) throws CertificateParsingException, InvalidKeyException, CertificateExpiredException, CertificateNotYetValidException, SignatureException, CertificateException, NoSuchAlgorithmException, NoSuchProviderException, KeyStoreException, UnrecoverableKeyException
{
String subject = getSubjectForHostname(hostname);
String thumbprint = _subjectMap.get(subject);
if(thumbprint == null) {
KeyPair kp = getRSAKeyPair();
X509Certificate newCert = CertificateCreator.generateStdSSLServerCertificate(kp.getPublic(),
getSigningCert(),
getSigningPrivateKey(),
subject);
addCertAndPrivateKey(hostname, newCert, kp.getPrivate());
thumbprint = ThumbprintUtil.getThumbprint(newCert);
_subjectMap.put(subject, thumbprint);
if(persistImmediately) {
persist();
}
return newCert;
}
return getCertificateByAlias(thumbprint);
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.