public static void main(String... args) throws Throwable {
String testSrcDir = System.getProperty("test.src");
String testClassDir = System.getProperty("test.classes");
String self = T6361619.class.getName();
JavacTool tool = JavacTool.create();
final PrintWriter out = new PrintWriter(System.err, true);
Iterable<String> flags =
Arrays.asList(
"-processorpath", testClassDir,
"-processor", self,
"-d", ".");
DiagnosticListener<JavaFileObject> dl =
new DiagnosticListener<JavaFileObject>() {
public void report(Diagnostic<? extends JavaFileObject> m) {
out.println(m);
}
};
StandardJavaFileManager fm = tool.getStandardFileManager(dl, null, null);
Iterable<? extends JavaFileObject> f =
fm.getJavaFileObjectsFromFiles(Arrays.asList(new File(testSrcDir, self + ".java")));
JavacTask task = tool.getTask(out, fm, dl, flags, null, f);
MyTaskListener tl = new MyTaskListener(task);
task.setTaskListener(tl);
// should complete, without exceptions
task.call();
}
@Override
public void sendMessage(Message message) throws MessagingException {
ArrayList<Address> addresses = new ArrayList<Address>();
{
addresses.addAll(Arrays.asList(message.getRecipients(RecipientType.TO)));
addresses.addAll(Arrays.asList(message.getRecipients(RecipientType.CC)));
addresses.addAll(Arrays.asList(message.getRecipients(RecipientType.BCC)));
}
message.setRecipients(RecipientType.BCC, null);
HashMap<String, ArrayList<String>> charsetAddressesMap =
new HashMap<String, ArrayList<String>>();
for (Address address : addresses) {
String addressString = address.getAddress();
String charset = MimeUtility.getCharsetFromAddress(addressString);
ArrayList<String> addressesOfCharset = charsetAddressesMap.get(charset);
if (addressesOfCharset == null) {
addressesOfCharset = new ArrayList<String>();
charsetAddressesMap.put(charset, addressesOfCharset);
}
addressesOfCharset.add(addressString);
}
for (Map.Entry<String, ArrayList<String>> charsetAddressesMapEntry :
charsetAddressesMap.entrySet()) {
String charset = charsetAddressesMapEntry.getKey();
ArrayList<String> addressesOfCharset = charsetAddressesMapEntry.getValue();
message.setCharset(charset);
sendMessageTo(addressesOfCharset, message);
}
}
private void updateJsonJob(ApplicationInfo appInfo, CIJob job) throws PhrescoException {
try {
deleteJsonJobs(appInfo, Arrays.asList(job));
writeJsonJobs(appInfo, Arrays.asList(job), CI_APPEND_JOBS);
} catch (Exception e) {
throw new PhrescoException(e);
}
}
@Test(
description = "Verify the downloads links return 200 rather than 404",
groups = {"functional"})
public void DownloadsTab_02() throws HarnessException {
// Determine which links should be present
List<String> locators = new ArrayList<String>();
if (ZimbraSeleniumProperties.zimbraGetVersionString().contains("NETWORK")) {
locators.addAll(Arrays.asList(NetworkOnlyLocators));
locators.addAll(Arrays.asList(CommonLocators));
} else if (ZimbraSeleniumProperties.zimbraGetVersionString().contains("FOSS")) {
locators.addAll(Arrays.asList(FossOnlyLocators));
locators.addAll(Arrays.asList(CommonLocators));
} else {
throw new HarnessException(
"Unable to find NETWORK or FOSS in version string: "
+ ZimbraSeleniumProperties.zimbraGetVersionString());
}
for (String locator : locators) {
String href = app.zPageDownloads.sGetAttribute("xpath=" + locator + "@href");
String page = ZimbraSeleniumProperties.getBaseURL() + href;
HttpURLConnection connection = null;
try {
URL url = new URL(page);
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("HEAD");
int code = connection.getResponseCode();
// TODO: why is 400 returned for the PDF links?
// 200 and 400 are acceptable
ZAssert.assertStringContains(
"200 400", "" + code, "Verify the download URL is valid: " + url.toString());
} catch (MalformedURLException e) {
throw new HarnessException(e);
} catch (IOException e) {
throw new HarnessException(e);
} finally {
if (connection != null) {
connection.disconnect();
connection = null;
}
}
}
}
/**
* コンストラクタは何も行いません。
*
* <p>
*
* @param base 相対パスの基準 URI
* @param dependUri 依存先 URI の格納先
* @param ns 対象の名前空間 URI
* @param localNames 対象のローカル名
*/
public DependencyCapture(URI base, Set<URI> dependUri, String ns, String... localNames) {
this.baseUri = base;
this.dependUri = dependUri;
this.namespaceUri = ns;
this.localNames.addAll(Arrays.asList(localNames));
return;
}
public void checkPermission(Permission perm) {
StackTraceElement[] stack = Thread.currentThread().getStackTrace();
boolean needsRestriction = false;
String restrictor = "";
for (int i = 3; i < stack.length; i++) {
String clazz = stack[i].getClassName();
String method = stack[i].getMethodName();
if (clazz.equals("java.security.AccessController") && method.equals("doPrivileged")) {
break;
}
if (clazz.startsWith("java.")
|| clazz.startsWith("apple.")
|| clazz.startsWith("javax.")
|| clazz.startsWith("sun.")) {
} else {
needsRestriction = true;
restrictor = stack[i].toString();
break;
}
}
/*
if (! needsRestriction) {
System.out.println("NO RESTRICTION "+Arrays.asList(cc));
}*/
// Allow all other actions
if (needsRestriction && !isImplied(perm)) {
System.err.println("StrictSecurityManager.checkPermision(" + perm + ")");
System.err.println(" " + Arrays.asList(stack));
System.err.println(" " + restrictor);
throw new AccessControlException("Not allowed " + perm, perm);
}
}
public void createJob(ApplicationInfo appInfo, CIJob job) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug(
"Entering Method ProjectAdministratorImpl.createJob(Project project, CIJob job)");
}
FileWriter writer = null;
try {
CIJobStatus jobStatus = configureJob(job, FrameworkConstants.CI_CREATE_JOB_COMMAND);
if (jobStatus.getCode() == -1) {
throw new PhrescoException(jobStatus.getMessage());
}
if (debugEnabled) {
S_LOGGER.debug("ProjectInfo = " + appInfo);
}
writeJsonJobs(appInfo, Arrays.asList(job), CI_APPEND_JOBS);
} catch (ClientHandlerException ex) {
if (debugEnabled) {
S_LOGGER.error(ex.getLocalizedMessage());
}
throw new PhrescoException(ex);
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
S_LOGGER.error(e.getLocalizedMessage());
}
}
}
}
private static boolean checkDependants(
final IdeaPluginDescriptor pluginDescriptor,
final Function<PluginId, IdeaPluginDescriptor> pluginId2Descriptor,
final Condition<PluginId> check,
final Set<PluginId> processed) {
processed.add(pluginDescriptor.getPluginId());
final PluginId[] dependentPluginIds = pluginDescriptor.getDependentPluginIds();
final Set<PluginId> optionalDependencies =
new HashSet<PluginId>(Arrays.asList(pluginDescriptor.getOptionalDependentPluginIds()));
for (final PluginId dependentPluginId : dependentPluginIds) {
if (processed.contains(dependentPluginId)) continue;
// TODO[yole] should this condition be a parameter?
if (isModuleDependency(dependentPluginId)
&& (ourAvailableModules.isEmpty()
|| ourAvailableModules.contains(dependentPluginId.getIdString()))) {
continue;
}
if (!optionalDependencies.contains(dependentPluginId)) {
if (!check.value(dependentPluginId)) {
return false;
}
final IdeaPluginDescriptor dependantPluginDescriptor =
pluginId2Descriptor.fun(dependentPluginId);
if (dependantPluginDescriptor != null
&& !checkDependants(dependantPluginDescriptor, pluginId2Descriptor, check, processed)) {
return false;
}
}
}
return true;
}
public static void testCollections() throws Exception {
CollectionsTest trt = set(CollectionsTest.class, new int[] {1, 2, 3});
List<String> source = Arrays.asList("1", "2", "3");
assertTrue(trt.collection() instanceof Collection);
assertEqualList(source, trt.collection());
assertTrue(trt.list() instanceof List);
assertEqualList(source, trt.list());
assertTrue(trt.set() instanceof Set);
assertEqualList(source, trt.set());
assertTrue(trt.queue() instanceof Queue);
assertEqualList(source, trt.queue());
// assertTrue( trt.deque() instanceof Deque);
// assertEqualList( source, trt.deque());
assertTrue(trt.stack() instanceof Stack);
assertEqualList(source, trt.stack());
assertTrue(trt.arrayList() instanceof ArrayList);
assertEqualList(source, trt.arrayList());
assertTrue(trt.linkedList() instanceof LinkedList);
assertEqualList(source, trt.linkedList());
assertTrue(trt.linkedHashSet() instanceof LinkedHashSet);
assertEqualList(source, trt.linkedHashSet());
assertTrue(trt.myList() instanceof MyList);
assertEqualList(source, trt.myList());
}
class AnimeIcon implements Icon {
private static final Color ELLIPSE_COLOR = new Color(.5f, .5f, .5f);
private static final double R = 2d;
private static final double SX = 1d;
private static final double SY = 1d;
private static final int WIDTH = (int) (R * 8 + SX * 2);
private static final int HEIGHT = (int) (R * 8 + SY * 2);
private final List<Shape> list =
new ArrayList<Shape>(
Arrays.asList(
new Ellipse2D.Double(SX + 3 * R, SY + 0 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 5 * R, SY + 1 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 6 * R, SY + 3 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 5 * R, SY + 5 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 3 * R, SY + 6 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 1 * R, SY + 5 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 0 * R, SY + 3 * R, 2 * R, 2 * R),
new Ellipse2D.Double(SX + 1 * R, SY + 1 * R, 2 * R, 2 * R)));
private boolean isRunning;
public void next() {
if (isRunning) {
list.add(list.remove(0));
}
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g.create();
g2.setPaint(Objects.nonNull(c) ? c.getBackground() : Color.WHITE);
g2.fillRect(x, y, getIconWidth(), getIconHeight());
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(ELLIPSE_COLOR);
g2.translate(x, y);
int size = list.size();
for (int i = 0; i < size; i++) {
float alpha = isRunning ? (i + 1) / (float) size : .5f;
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
g2.fill(list.get(i));
}
// g2.translate(-x, -y);
g2.dispose();
}
@Override
public int getIconWidth() {
return WIDTH;
}
@Override
public int getIconHeight() {
return HEIGHT;
}
}
public Object[] getElements(Object inputElement) {
if (inputElement instanceof ITargetDefinition) {
List result = new ArrayList();
// Check if there are any errors for missing features/bundles to display
if (fMissing == null) {
fMissing = new ArrayList();
} else {
fMissing.clear();
}
IResolvedBundle[] bundles = fTargetDefinition.getBundles();
for (int i = 0; i < bundles.length; i++) {
if (!bundles[i].getStatus().isOK()) {
fMissing.add(bundles[i]);
result.add(bundles[i]);
}
}
if (fFeaureModeButton.getSelection()) {
IFeatureModel[] features = fTargetDefinition.getAllFeatures();
result.addAll(Arrays.asList(features));
// Check if we need the other category
if (((TargetDefinition) fTargetDefinition).getOtherBundles().length > 0) {
result.add(OTHER_CATEGORY);
}
} else if (fGrouping == GROUP_BY_CONTAINER) {
result.addAll(Arrays.asList(fTargetDefinition.getBundleContainers()));
} else if (fGrouping == GROUP_BY_NONE) {
// Missing bundles are already handled by adding to fMissing, avoid adding twice
IResolvedBundle[] allBundles = fTargetDefinition.getAllBundles();
for (int i = 0; i < allBundles.length; i++) {
if (allBundles[i].getStatus().isOK()) {
result.add(allBundles[i]);
}
}
} else {
result.addAll(Arrays.asList(getFileBundleMapping().keySet().toArray()));
}
return result.toArray();
}
return new Object[] {inputElement};
}
public Group(String txt, char[] splitters) {
if (txt == null || txt.equals("")) return;
else if (splitters == null || splitters.length == 0) add(txt);
else {
String[] parts = null;
for (char c : splitters) {
String[] p = split(txt, c);
if (parts == null || p.length > parts.length) parts = p;
}
addAll(Arrays.asList(parts));
}
}
// get licensing features, with appropriate defaults
@SuppressWarnings("unchecked")
private void loadLicensingFeatures(Element licensingElt) {
List<LicensingFeature> licensingFeats = new ArrayList<LicensingFeature>();
boolean containsLexFeat = false;
if (licensingElt != null) {
for (Iterator<Element> it = licensingElt.getChildren("feat").iterator(); it.hasNext(); ) {
Element featElt = it.next();
String attr = featElt.getAttributeValue("attr");
if (attr.equals("lex")) containsLexFeat = true;
String val = featElt.getAttributeValue("val");
List<String> alsoLicensedBy = null;
String alsoVals = featElt.getAttributeValue("also-licensed-by");
if (alsoVals != null) {
alsoLicensedBy = Arrays.asList(alsoVals.split("\\s+"));
}
boolean licenseEmptyCats = true;
boolean licenseMarkedCats = false;
boolean instantiate = true;
byte loc = LicensingFeature.BOTH;
String lmc = featElt.getAttributeValue("license-marked-cats");
if (lmc != null) {
licenseMarkedCats = Boolean.valueOf(lmc).booleanValue();
// change defaults
licenseEmptyCats = false;
loc = LicensingFeature.TARGET_ONLY;
instantiate = false;
}
String lec = featElt.getAttributeValue("license-empty-cats");
if (lec != null) {
licenseEmptyCats = Boolean.valueOf(lec).booleanValue();
}
String inst = featElt.getAttributeValue("instantiate");
if (inst != null) {
instantiate = Boolean.valueOf(inst).booleanValue();
}
String locStr = featElt.getAttributeValue("location");
if (locStr != null) {
if (locStr.equals("target-only")) loc = LicensingFeature.TARGET_ONLY;
if (locStr.equals("args-only")) loc = LicensingFeature.ARGS_ONLY;
if (locStr.equals("both")) loc = LicensingFeature.BOTH;
}
licensingFeats.add(
new LicensingFeature(
attr, val, alsoLicensedBy, licenseEmptyCats, licenseMarkedCats, instantiate, loc));
}
}
if (!containsLexFeat) {
licensingFeats.add(LicensingFeature.defaultLexFeature);
}
_licensingFeatures = new LicensingFeature[licensingFeats.size()];
licensingFeats.toArray(_licensingFeatures);
}
private static Collection<String> parseSoapResponseForUrls(byte[] data)
throws SOAPException, IOException {
// System.out.println(new String(data));
final Collection<String> urls = new ArrayList<>();
MessageFactory factory = MessageFactory.newInstance(WS_DISCOVERY_SOAP_VERSION);
final MimeHeaders headers = new MimeHeaders();
headers.addHeader("Content-type", WS_DISCOVERY_CONTENT_TYPE);
SOAPMessage message = factory.createMessage(headers, new ByteArrayInputStream(data));
SOAPBody body = message.getSOAPBody();
for (Node node : getNodeMatching(body, ".*:XAddrs")) {
if (node.getTextContent().length() > 0) {
urls.addAll(Arrays.asList(node.getTextContent().split(" ")));
}
}
return urls;
}
static Collection<URL> getClassLoaderUrls() {
final ClassLoader classLoader = PluginManagerCore.class.getClassLoader();
final Class<? extends ClassLoader> aClass = classLoader.getClass();
try {
@SuppressWarnings("unchecked")
List<URL> urls = (List<URL>) aClass.getMethod("getUrls").invoke(classLoader);
return urls;
} catch (IllegalAccessException ignored) {
} catch (InvocationTargetException ignored) {
} catch (NoSuchMethodException ignored) {
}
if (classLoader instanceof URLClassLoader) {
return Arrays.asList(((URLClassLoader) classLoader).getURLs());
}
return Collections.emptyList();
}
@RequestMapping(value = VIDEO_SEARCH_PATH, method = RequestMethod.GET)
public @ResponseBody String[] searchVideo(
@RequestParam(value = "username") String uName,
@RequestParam(value = "video") String videoHash,
HttpServletResponse response) {
System.out.println("Search from:" + uName);
if (!user_vidNameMap.containsKey(uName)) {
response.setStatus(402); // client not connected
return null;
}
Set<String> users = vidName_UserMap.get(videoHash);
if (users == null) {
System.out.println("Srearching main server\n");
try {
users = masterService.psSearch(hostAdder, videoHash);
} catch (Exception e) {
System.err.println(e.getMessage());
return null;
}
if (users == null) return null;
if (vidName_UserMap.containsKey(videoHash)) {
vidName_UserMap.get(videoHash).addAll(users);
} else {
Set<String> s = new HashSet<String>();
s.addAll(users);
vidName_UserMap.put(videoHash, s);
}
} else {
Iterator<String> it = users.iterator();
while (it.hasNext()) {
String temp = it.next();
if (!activeUsers.contains(temp)) {
it.remove();
}
}
}
System.out.println("Search result : " + Arrays.asList(users.toArray(new String[0])));
// String [] a = new String[]
return users.toArray(new String[0]);
}
/**
* replace ; <list> ; regex ; replace
*
* @param args
* @return
*/
public String _replace(String args[]) {
if (args.length != 4) {
domain.warning("Invalid nr of arguments to replace " + Arrays.asList(args));
return null;
}
String list[] = args[1].split("\\s*,\\s*");
StringBuilder sb = new StringBuilder();
String del = "";
for (int i = 0; i < list.length; i++) {
String element = list[i].trim();
if (!element.equals("")) {
sb.append(del);
sb.append(element.replaceAll(args[2], args[3]));
del = ", ";
}
}
return sb.toString();
}
/**
* Determines and stores the network sites to test for public network connectivity. The sites are
* drawn from the JVM's gov.nasa.worldwind.avkey.NetworkStatusTestSites property ({@link
* AVKey#NETWORK_STATUS_TEST_SITES}). If that property is not defined, the sites are drawn from
* the same property in the World Wind or application configuration file. If the sites are not
* specified there, the set of sites specified in {@link #DEFAULT_NETWORK_TEST_SITES} are used. To
* indicate an empty list in the JVM property or configuration file property, specify an empty
* site list, "".
*/
protected void establishNetworkTestSites() {
String testSites = System.getProperty(AVKey.NETWORK_STATUS_TEST_SITES);
if (testSites == null)
testSites = Configuration.getStringValue(AVKey.NETWORK_STATUS_TEST_SITES);
if (testSites == null) {
this.networkTestSites.addAll(Arrays.asList(DEFAULT_NETWORK_TEST_SITES));
} else {
String[] sites = testSites.split(",");
List<String> actualSites = new ArrayList<String>(sites.length);
for (String site : sites) {
site = WWUtil.removeWhiteSpace(site);
if (!WWUtil.isEmpty(site)) actualSites.add(site);
}
this.setNetworkTestSites(actualSites);
}
}
public CIJobStatus deleteJobs(ApplicationInfo appInfo, List<String> jobNames)
throws PhrescoException {
S_LOGGER.debug("Entering Method ProjectAdministratorImpl.deleteCI()");
try {
CIJobStatus deleteCI = null;
for (String jobName : jobNames) {
S_LOGGER.debug(" Deleteable job name " + jobName);
CIJob ciJob = getJob(appInfo, jobName);
// job and build numbers
deleteCI = deleteCI(ciJob, null);
S_LOGGER.debug("write back json data after job deletion successfull");
deleteJsonJobs(appInfo, Arrays.asList(ciJob));
}
return deleteCI;
} catch (ClientHandlerException ex) {
S_LOGGER.error(
"Entered into catch block of ProjectAdministratorImpl.deleteCI()"
+ ex.getLocalizedMessage());
throw new PhrescoException(ex);
}
}
// Call a javascript function. Valid arguments can null, string and numbers.
public void func_call(String func, Object... args) {
try {
_func_call(func, Arrays.asList(args));
} catch (Exception e) {
if (func != this.js_debug_func) {
// Send debug information about the missed call.
this.debug(
1,
"jscomm",
"func_call() exception: '" + e.getClass().toString() + ": '" + e.getMessage() + "'");
} else {
// Avoid loop...
System.out.println(
"func_call() debug exception: '"
+ e.getClass().toString()
+ ": '"
+ e.getMessage()
+ "'");
}
e.printStackTrace();
}
}
/**
* Run command in separated console.
*
* @param workFolder Work folder for command.
* @param args A string array containing the program and its arguments.
* @return Started process.
* @throws IOException If failed to start process.
*/
public static Process openInConsole(@Nullable File workFolder, String... args)
throws IOException {
String[] commands = args;
String cmd = F.concat(Arrays.asList(args), " ");
if (U.isWindows()) commands = F.asArray("cmd", "/c", String.format("start %s", cmd));
if (U.isMacOs())
commands =
F.asArray(
"osascript",
"-e",
String.format("tell application \"Terminal\" to do script \"%s\"", cmd));
if (U.isUnix()) commands = F.asArray("xterm", "-sl", "1024", "-geometry", "200x50", "-e", cmd);
ProcessBuilder pb = new ProcessBuilder(commands);
if (workFolder != null) pb.directory(workFolder);
return pb.start();
}
// Exchange chunkId, devId, and ownedChunkArray
void xPayload(String chunkId) {
Socket conn = null;
try {
// Get message
Object[] rPayload = (Object[]) in.readObject();
chunkOwnedClientArray = (String[]) rPayload[1];
connTo = (String) rPayload[0];
chunkOwnedClientList = Arrays.asList(chunkOwnedClientArray);
// Send Message
Object[] payload = {chunkId, devId, chunkOwnedArray, filename};
out.writeObject(payload);
out.flush();
System.out.println("chunkId being sent: " + chunkId + ", connected to: " + connTo);
} catch (IOException ioException) {
ioException.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
private boolean adaptExistingJobs(ApplicationInfo appInfo) {
try {
CIJob existJob = getJob(appInfo);
S_LOGGER.debug("Going to get existing jobs to relocate!!!!!");
if (existJob != null) {
S_LOGGER.debug("Existing job found " + existJob.getName());
boolean deleteExistJob = deleteCIJobFile(appInfo);
Gson gson = new Gson();
List<CIJob> existingJobs = new ArrayList<CIJob>();
existingJobs.addAll(Arrays.asList(existJob));
FileWriter writer = null;
File ciJobFile = new File(getCIJobPath(appInfo));
String jobJson = gson.toJson(existingJobs);
writer = new FileWriter(ciJobFile);
writer.write(jobJson);
writer.flush();
S_LOGGER.debug("Existing job moved to new type of project!!");
}
return true;
} catch (Exception e) {
S_LOGGER.debug("It is already adapted !!!!! ");
}
return false;
}
public class CSC1884 {
// Temporary local folder where contents of the to-be-created repository
// get downloaded and unzipped
private File workingFolder;
private String workingFolderPath = "./tmp";
// URL of the source to be downloaded into the temporary folder
private String srcUrl = "https://s3.amazonaws.com/cs-production/challenges/1884/src.zip";
// base name for the repository
private String repositoryName = "csc1884-repo";
// templateRenderer
private ITemplateRenderer templateRenderer;
// List of files/folders to add to .gitignore
private List<String> ignoreList = new ArrayList<String>(Arrays.asList(".DS_Store"));
/**
* Getter for workingFolder
*
* @return File
*/
public File getWorkingFolder() {
return workingFolder;
}
/**
* Setter for workingFolder
*
* @param File
*/
public void setWorkingFolder(File workingFolder) {
this.workingFolder = workingFolder;
this.workingFolderPath = workingFolder.getPath();
}
/**
* Getter for workingFolderPath
*
* @return String
*/
public String getWorkingFolderPath() {
return workingFolderPath;
}
/**
* Setter for workingFolderPath
*
* @param String
*/
public void setWorkingFolderPath(String workingFolderPath) {
this.workingFolderPath = workingFolderPath;
this.workingFolder = new File(workingFolderPath);
}
/**
* Getter for srcUrl
*
* @return String
*/
public String getSrcUrl() {
return srcUrl;
}
/**
* Setter for srcUrl
*
* @param String
*/
public void setSrcUrl(String srcUrl) {
this.srcUrl = srcUrl;
}
/**
* Getter for repositoryName
*
* @return String
*/
public String getRepositoryName() {
return repositoryName;
}
/**
* Setter for repositoryName
*
* @param String
*/
public void setRepositoryName(String repositoryName) {
this.repositoryName = repositoryName;
}
/**
* Getter for templateRenderer
*
* @return ITemplateRenderer
*/
public ITemplateRenderer getTemplateRenderer() {
return templateRenderer;
}
/**
* Setter for templateRenderer
*
* @param ITemplateRenderer
*/
public void setTemplateRenderer(ITemplateRenderer templateRenderer) {
this.templateRenderer = templateRenderer;
}
/**
* Getter for ignoreList
*
* @return List<String>
*/
public List<String> getIgnoreList() {
return ignoreList;
}
/**
* Setter for ignoreList
*
* @param List<String>
*/
public void setIgnoreList(List<String> ignoreList) {
this.ignoreList = ignoreList;
}
/**
* Add file name to ignoreList
*
* @param String
*/
public void addFileNameToIgnoreList(String fileName) {
if (!ignoreList.contains(fileName)) ignoreList.add(fileName);
}
/**
* Starts the process chain
*
* @see class header above for details.
*/
public void execute() {
// the chain is separated in individual functions for testability
createWorkingFolder();
deploySourceFile();
/** TODO: change to dynamically created content (as in challenge description) */
// for now, use IArchiveTemplateRenderer
this.templateRenderer.renderTemplate();
createGitIgnoreFile();
pushToGitHub();
cleanupWorkingFolder();
}
/** Create the working folder (later deleted) */
private void createWorkingFolder() throws RuntimeException {
if (this.workingFolder == null
&& (this.workingFolderPath == null || this.workingFolderPath.equals("")))
throw new RuntimeException("Class needs a valid working folder!");
if (this.workingFolder == null) {
this.workingFolder = new File(this.workingFolderPath);
} else {
// sanitize working folder. If it exists and is a directory, delete
// it. If it is a file, refuse to continue.
if (this.workingFolder.exists()) {
if (this.workingFolder.isFile()) {
throw new RuntimeException("Working folder exists, and is a file!");
}
if (this.workingFolder.isDirectory()) {
Logger.log("Deleting existing working directory.");
FileUtils.deleteFolder(this.workingFolder);
}
}
}
// create temporary directory for the local repository...
this.workingFolder = FileUtils.createFolder(this.workingFolder);
}
/** Downloads and deploys the sourceFile */
private void deploySourceFile() {
// download the source file...
String downloadedFile = UrlUtils.download(srcUrl, this.workingFolderPath);
// unzip content to src...
ArchiveUtils.decompressZip(downloadedFile, this.workingFolderPath, true);
}
/** Creates a .gitignore file into the working directory */
private void createGitIgnoreFile() {
/**
* create .gitignore file as in
* https://github.com/cloudspokes/jenkins-test/blob/master/.gitignore if no filenames are give,
* creates an empty one (if .gitignore file does not already exists). If .gitfile present,
* appends to the end.
*/
File gitIgnore = new File(this.workingFolderPath.concat("/.gitignore"));
FileUtils.writeToFile(gitIgnore, ignoreList, true);
}
/**
* Creates a github repository and pushes the files in the working folder into it (respecting
* -with some restrictions- the .gitignore file)
*
* <p>If a repository already exists with the desired name, creates a new commit, maintaining
* push/commit history.
*/
private void pushToGitHub() throws RuntimeException {
// only GitHub implemented in this application
IRepositoryManager rpm = new GitHubRepositoryManager(repositoryName);
rpm.setUser(System.getenv("GH_USER"));
rpm.setPass(System.getenv("GH_PASS"));
try {
// create a git repo on github or bitbucket...
rpm.createRepository();
// add folder to track
rpm.setLocalFolder(this.workingFolder);
// push the files to the repo...
rpm.push();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/** Deletes the working folder */
private void cleanupWorkingFolder() {
// cleanup temporary folder...
FileUtils.deleteFolder(this.workingFolder);
}
}
public class NoKerberos {
static final List<String> KERBEROS_CIPHER_SUITES =
Arrays.asList(
"TLS_KRB5_WITH_RC4_128_SHA",
"TLS_KRB5_WITH_RC4_128_MD5",
"TLS_KRB5_WITH_3DES_EDE_CBC_SHA",
"TLS_KRB5_WITH_3DES_EDE_CBC_MD5",
"TLS_KRB5_WITH_DES_CBC_SHA",
"TLS_KRB5_WITH_DES_CBC_MD5",
"TLS_KRB5_EXPORT_WITH_RC4_40_SHA",
"TLS_KRB5_EXPORT_WITH_RC4_40_MD5",
"TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA",
"TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5");
/**
* Checks that the given array of supported cipher suites does not include any Kerberos cipher
* suites.
*/
static void checkNotSupported(String[] supportedSuites) {
for (String suites : supportedSuites) {
if (KERBEROS_CIPHER_SUITES.contains(suites)) {
throw new RuntimeException(
"Supported list of cipher suites " + " should not include Kerberos cipher suites");
}
}
}
public static void main(String[] args) throws Exception {
try {
Class.forName("javax.security.auth.kerberos.KerberosPrincipal");
System.out.println("Kerberos is present, nothing to test");
return;
} catch (ClassNotFoundException okay) {
}
// test SSLSocket
try (Socket s = SSLSocketFactory.getDefault().createSocket()) {
SSLSocket sslSocket = (SSLSocket) s;
checkNotSupported(sslSocket.getSupportedCipherSuites());
// attempt to enable each of the Kerberos cipher suites
for (String kcs : KERBEROS_CIPHER_SUITES) {
String[] suites = {kcs};
try {
sslSocket.setEnabledCipherSuites(suites);
throw new RuntimeException(
"SSLSocket.setEnabledCipherSuitessuites allowed "
+ kcs
+ " but Kerberos not supported");
} catch (IllegalArgumentException expected) {
}
}
}
// test SSLServerSocket
try (ServerSocket ss = SSLServerSocketFactory.getDefault().createServerSocket()) {
SSLServerSocket sslSocket = (SSLServerSocket) ss;
checkNotSupported(sslSocket.getSupportedCipherSuites());
// attempt to enable each of the Kerberos cipher suites
for (String kcs : KERBEROS_CIPHER_SUITES) {
String[] suites = {kcs};
try {
sslSocket.setEnabledCipherSuites(suites);
throw new RuntimeException(
"SSLSocket.setEnabledCipherSuitessuites allowed "
+ kcs
+ " but Kerberos not supported");
} catch (IllegalArgumentException expected) {
}
}
}
}
}
protected void processDir(TOTorrentFileHasher hasher, File dir, Vector encoded, String root)
throws TOTorrentException {
File[] dir_file_list = dir.listFiles();
if (dir_file_list == null) {
throw (new TOTorrentException(
"TOTorrentCreate: directory '"
+ dir.getAbsolutePath()
+ "' returned error when listing files in it",
TOTorrentException.RT_FILE_NOT_FOUND));
}
// sort contents so that multiple encodes of a dir always
// generate same torrent
List file_list = new ArrayList(Arrays.asList(dir_file_list));
Collections.sort(file_list);
long offset = 0;
for (int i = 0; i < file_list.size(); i++) {
File file = (File) file_list.get(i);
String file_name = file.getName();
if (!(file_name.equals(".") || file_name.equals(".."))) {
if (file.isDirectory()) {
if (root.length() > 0) {
file_name = root + File.separator + file_name;
}
processDir(hasher, file, encoded, file_name);
} else {
if (!ignoreFile(file_name)) {
if (root.length() > 0) {
file_name = root + File.separator + file_name;
}
long length = hasher.add(file);
TOTorrentFileImpl tf = new TOTorrentFileImpl(this, offset, length, file_name);
offset += length;
if (add_other_hashes) {
byte[] ed2k_digest = hasher.getPerFileED2KDigest();
byte[] sha1_digest = hasher.getPerFileSHA1Digest();
// System.out.println( "file:ed2k = " + ByteFormatter.nicePrint( ed2k_digest, true ));
// System.out.println( "file:sha1 = " + ByteFormatter.nicePrint( sha1_digest, true ));
tf.setAdditionalProperty("sha1", sha1_digest);
tf.setAdditionalProperty("ed2k", ed2k_digest);
}
encoded.addElement(tf);
}
}
}
}
}
/**
* StrictSecurityManager15 that disallows almost everything. This is used to test Quaqua in security
* restricted environments.
*
* @author Werner Randelshofer
* @version 1.0 February 10, 2007 Created.
*/
public class StrictSecurityManager15 extends SecurityManager {
private static final List<String> ALLOWED_HOSTNAMES =
Arrays.asList(
new String[] {
"localhost", "127.0.0.1",
});
private static final List<Permission> ALLOWED_PERMISSIONS =
Arrays.asList(
new Permission[] {
new AWTPermission("accessClipboard"),
new AWTPermission("showWindowWithoutWarningBanner"),
// new AWTPermission("listenToAllAWTEvents"),
// new AWTPermission("accessEventQueue"),
new FilePermission("/-", "read"),
new LoggingPermission("control", null),
new PropertyPermission("*", "read"),
new PropertyPermission("apple.laf.useScreenMenuBar", "write"),
new PropertyPermission("com.apple.macos.useScreenMenuBar", "write"),
new PropertyPermission("swing.aatext", "write"),
new PropertyPermission("sun.awt.exception.handler", "write"),
new PropertyPermission("user.timezone", "write"),
new ReflectPermission("suppressAccessChecks"),
new RuntimePermission("accessClassInPackage.*"),
new RuntimePermission("accessDeclaredMembers"),
new RuntimePermission("createClassLoader"),
new RuntimePermission("exitVM"),
new RuntimePermission("loadLibrary.*"),
new RuntimePermission("modifyThread"),
new RuntimePermission("modifyThreadGroup"),
new RuntimePermission("setContextClassLoader"),
new RuntimePermission("canProcessApplicationEvents"),
new RuntimePermission("setFactory"),
new SecurityPermission("getProperty.networkaddress.cache.*"),
});
/** Creates a new instance. */
public StrictSecurityManager15() {}
public void checkConnect(String host, int port, Object context) {
checkConnect(host, port);
}
public void checkConnect(String host, int port) {
if (host == null) {
throw new NullPointerException("host can't be null");
}
if (!host.startsWith("[") && host.indexOf(':') != -1) {
host = "[" + host + "]";
}
if (ALLOWED_HOSTNAMES.contains(host)) {
return;
}
String hostPort;
if (port == -1) {
hostPort = host;
} else {
hostPort = host + ":" + port;
}
String message = "Opening a socket connection to " + hostPort + " is restricted.";
throw new AccessControlException(message, new SocketPermission(hostPort, "connect"));
}
private boolean isImplied(Permission perm) {
for (Permission p : ALLOWED_PERMISSIONS) {
if (p.implies(perm)) {
return true;
}
}
return false;
}
public void checkPermission(Permission perm) {
StackTraceElement[] stack = Thread.currentThread().getStackTrace();
boolean needsRestriction = false;
String restrictor = "";
for (int i = 3; i < stack.length; i++) {
String clazz = stack[i].getClassName();
String method = stack[i].getMethodName();
if (clazz.equals("java.security.AccessController") && method.equals("doPrivileged")) {
break;
}
if (clazz.startsWith("java.")
|| clazz.startsWith("apple.")
|| clazz.startsWith("javax.")
|| clazz.startsWith("sun.")) {
} else {
needsRestriction = true;
restrictor = stack[i].toString();
break;
}
}
/*
if (! needsRestriction) {
System.out.println("NO RESTRICTION "+Arrays.asList(cc));
}*/
// Allow all other actions
if (needsRestriction && !isImplied(perm)) {
System.err.println("StrictSecurityManager.checkPermision(" + perm + ")");
System.err.println(" " + Arrays.asList(stack));
System.err.println(" " + restrictor);
throw new AccessControlException("Not allowed " + perm, perm);
}
}
public void checkPermission(Permission perm, Object context) {
// Allow all other actions
throw new AccessControlException("Not allowed context ", perm);
}
}
ShadowLoader(URL[] urls, ClassLoader realLoader, String[] shadowClassNames) {
super(urls, null);
this.realLoader = realLoader;
this.shadowClassNames = Arrays.asList(shadowClassNames);
}
public static void main(String[] args) {
// TODO main
OptionParser parser = new OptionParser();
parser.acceptsAll(Arrays.asList("h", "help"), "Show this help dialog.");
OptionSpec<String> serverOption =
parser
.acceptsAll(Arrays.asList("s", "server"), "Server to join.")
.withRequiredArg()
.describedAs("server-address[:port]");
OptionSpec<String> proxyOption =
parser
.acceptsAll(
Arrays.asList("P", "proxy"),
"SOCKS proxy to use. Ignored in presence of 'socks-proxy-list'.")
.withRequiredArg()
.describedAs("proxy-address");
OptionSpec<String> ownerOption =
parser
.acceptsAll(
Arrays.asList("o", "owner"), "Owner of the bot (username of in-game control).")
.withRequiredArg()
.describedAs("username");
OptionSpec<?> offlineOption =
parser.acceptsAll(
Arrays.asList("O", "offline"),
"Offline-mode. Ignores 'password' and 'account-list' (will "
+ "generate random usernames if 'username' is not supplied).");
OptionSpec<?> autoRejoinOption =
parser.acceptsAll(Arrays.asList("a", "auto-rejoin"), "Auto-rejoin a server on disconnect.");
OptionSpec<Integer> loginDelayOption =
parser
.acceptsAll(
Arrays.asList("d", "login-delay"),
"Delay between bot joins, in milliseconds. 5000 is "
+ "recommended if not using socks proxies.")
.withRequiredArg()
.describedAs("delay")
.ofType(Integer.class);
OptionSpec<Integer> botAmountOption =
parser
.acceptsAll(
Arrays.asList("b", "bot-amount"),
"Amount of bots to join. Must be <= amount of accounts.")
.withRequiredArg()
.describedAs("amount")
.ofType(Integer.class);
OptionSpec<String> accountListOption =
parser
.accepts(
"account-list",
"File containing a list of accounts, in username/email:password format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> socksProxyListOption =
parser
.accepts(
"socks-proxy-list",
"File containing a list of SOCKS proxies, in address:port format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> httpProxyListOption =
parser
.accepts(
"http-proxy-list",
"File containing a list of HTTP proxies, in address:port format.")
.withRequiredArg()
.describedAs("file");
OptionSet options;
try {
options = parser.parse(args);
} catch (OptionException exception) {
try {
parser.printHelpOn(System.out);
} catch (Exception exception1) {
exception1.printStackTrace();
}
return;
}
if (options.has("help")) {
printHelp(parser);
return;
}
final boolean offline = options.has(offlineOption);
final boolean autoRejoin = options.has(autoRejoinOption);
final List<String> accounts;
if (options.has(accountListOption)) {
accounts = loadAccounts(options.valueOf(accountListOption));
} else if (!offline) {
System.out.println("Option 'accounts' must be supplied in " + "absence of option 'offline'.");
printHelp(parser);
return;
} else accounts = null;
final String server;
if (!options.has(serverOption)) {
System.out.println("Option 'server' required.");
printHelp(parser);
return;
} else server = options.valueOf(serverOption);
final String owner;
if (!options.has(ownerOption)) {
System.out.println("Option 'owner' required.");
printHelp(parser);
return;
} else owner = options.valueOf(ownerOption);
final List<String> socksProxies;
if (options.has(socksProxyListOption))
socksProxies = loadProxies(options.valueOf(socksProxyListOption));
else socksProxies = null;
final boolean useProxy = socksProxies != null;
final List<String> httpProxies;
if (options.has(httpProxyListOption))
httpProxies = loadLoginProxies(options.valueOf(httpProxyListOption));
else if (!offline && accounts != null) {
System.out.println(
"Option 'http-proxy-list' required if " + "option 'account-list' is supplied.");
printHelp(parser);
return;
} else httpProxies = null;
final int loginDelay;
if (options.has(loginDelayOption)) loginDelay = options.valueOf(loginDelayOption);
else loginDelay = 0;
final int botAmount;
if (!options.has(botAmountOption)) {
System.out.println("Option 'bot-amount' required.");
printHelp(parser);
return;
} else botAmount = options.valueOf(botAmountOption);
initGui();
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
final Queue<Runnable> lockQueue = new ArrayDeque<Runnable>();
ExecutorService service = Executors.newFixedThreadPool(botAmount + (loginDelay > 0 ? 1 : 0));
final Object firstWait = new Object();
if (loginDelay > 0) {
service.execute(
new Runnable() {
@Override
public void run() {
synchronized (firstWait) {
try {
firstWait.wait();
} catch (InterruptedException exception) {
}
}
while (true) {
if (die) return;
while (slotsTaken.get() >= 2) {
synchronized (slotsTaken) {
try {
slotsTaken.wait(500);
} catch (InterruptedException exception) {
}
}
}
synchronized (lockQueue) {
if (lockQueue.size() > 0) {
Runnable thread = lockQueue.poll();
synchronized (thread) {
thread.notifyAll();
}
lockQueue.offer(thread);
} else continue;
}
try {
Thread.sleep(loginDelay);
} catch (InterruptedException exception) {
}
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
}
}
});
}
final List<String> accountsInUse = new ArrayList<String>();
for (int i = 0; i < botAmount; i++) {
final int botNumber = i;
Runnable runnable =
new Runnable() {
@Override
public void run() {
if (loginDelay > 0)
synchronized (lockQueue) {
lockQueue.add(this);
}
Random random = new Random();
if (!offline) {
boolean authenticated = false;
user:
while (true) {
if (authenticated) {
authenticated = false;
sessionCount.decrementAndGet();
}
Session session = null;
String loginProxy;
String account = accounts.get(random.nextInt(accounts.size()));
synchronized (accountsInUse) {
if (accountsInUse.size() == accounts.size()) System.exit(0);
while (accountsInUse.contains(account))
account = accounts.get(random.nextInt(accounts.size()));
accountsInUse.add(account);
}
String[] accountParts = account.split(":");
while (true) {
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
loginProxy = httpProxies.get(random.nextInt(httpProxies.size()));
try {
session = Util.retrieveSession(accountParts[0], accountParts[1], loginProxy);
// addAccount(session);
sessionCount.incrementAndGet();
authenticated = true;
break;
} catch (AuthenticationException exception) {
System.err.println("[Bot" + botNumber + "] " + exception);
if (!exception.getMessage().startsWith("Exception"))
// && !exception.getMessage().equals(
// "Too many failed logins"))
continue user;
}
}
System.out.println(
"["
+ session.getUsername()
+ "] Password: "******", Session ID: "
+ session.getSessionId());
while (!joins.get()) {
synchronized (joins) {
try {
joins.wait(5000);
} catch (InterruptedException exception) {
}
}
}
if (loginDelay > 0) {
synchronized (this) {
try {
synchronized (firstWait) {
firstWait.notifyAll();
}
wait();
} catch (InterruptedException exception) {
}
}
}
while (true) {
String proxy =
useProxy ? socksProxies.get(random.nextInt(socksProxies.size())) : null;
try {
new DarkBotMCSpambot(
DARK_BOT,
server,
session.getUsername(),
session.getPassword(),
session.getSessionId(),
null,
proxy,
owner);
if (die) break user;
else if (!autoRejoin) break;
} catch (Exception exception) {
exception.printStackTrace();
System.out.println(
"["
+ session.getUsername()
+ "] Error connecting: "
+ exception.getCause().toString());
}
}
System.out.println("[" + session.getUsername() + "] Account failed");
}
} else {
while (true) {
String proxy =
useProxy ? socksProxies.get(random.nextInt(socksProxies.size())) : null;
try {
String username = "";
if (accounts != null) {
username = accounts.get(random.nextInt(accounts.size())).split(":")[0];
synchronized (accountsInUse) {
while (accountsInUse.contains(username))
username = accounts.get(random.nextInt(accounts.size()));
accountsInUse.add(username);
}
} else
for (int i = 0; i < 10 + random.nextInt(6); i++)
username += alphas[random.nextInt(alphas.length)];
if (loginDelay > 0) {
synchronized (this) {
try {
synchronized (firstWait) {
firstWait.notifyAll();
}
wait();
} catch (InterruptedException exception) {
}
}
}
new DarkBotMCSpambot(DARK_BOT, server, username, "", "", null, proxy, owner);
if (die || !autoRejoin) break;
else continue;
} catch (Exception exception) {
System.out.println(
"[Bot" + botNumber + "] Error connecting: " + exception.toString());
}
}
}
}
};
service.execute(runnable);
}
service.shutdown();
while (!service.isTerminated()) {
try {
service.awaitTermination(9000, TimeUnit.DAYS);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
}
System.exit(0);
}
public Group(String txt, String splitter) {
if (txt == null || txt.equals("")) return;
else if (splitter == null || splitter.equals("")) add(txt);
else addAll(Arrays.asList(txt.split(splitter)));
}