public static void collectResourcesSO(Model m, Collection target) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
if (!(st.object() instanceof Literal) && !(st.object() instanceof Statement))
target.add(st.object());
target.add(st.subject());
}
}
// returns list of statements
protected static void replaceMultSPO(
Statement st, NodeFactory f, Map o2n, Collection result, RDFNode toReplace, int position)
throws ModelException {
Collection replacements;
if (toReplace instanceof Statement) {
List l = new ArrayList();
replaceMult((Statement) toReplace, f, o2n, l);
if (l.size() == 1 && toReplace == l.get(0)) {
result.add(st);
return; // keep the same
} else replacements = l;
} else {
Object ro = o2n.get(toReplace);
if (ro instanceof Collection) replacements = (Collection) ro;
else if (ro != null) {
replacements = new ArrayList();
replacements.add(ro);
} else { // no replacement needed
result.add(st); // keep the same statement
return;
}
}
for (Iterator it = replacements.iterator(); it.hasNext(); ) {
Statement rs = null;
Object rr = it.next();
switch (position) {
case 0:
rs = f.createStatement((Resource) rr, st.predicate(), st.object());
break;
case 1:
rs = f.createStatement(st.subject(), (Resource) rr, st.object());
break;
case 2:
rs = f.createStatement(st.subject(), st.predicate(), (RDFNode) rr);
break;
}
result.add(rs);
}
}
/**
* Change topology.
*
* @param parent Grid to execute tasks on.
* @param add New nodes count.
* @param rmv Remove nodes count.
* @param type Type of nodes to manipulate.
*/
private static void changeTopology(Ignite parent, int add, int rmv, String type) {
Collection<ComputeTaskFuture<?>> tasks = new ArrayList<>();
IgniteCompute comp = parent.compute().withAsync();
// Start nodes in parallel.
while (add-- > 0) {
comp.execute(ClientStartNodeTask.class, type);
tasks.add(comp.future());
}
for (ComputeTaskFuture<?> task : tasks) task.get();
// Stop nodes in sequence.
while (rmv-- > 0) parent.compute().execute(ClientStopNodeTask.class, type);
// Wait for node stops.
// U.sleep(1000);
Collection<String> gridNames = new ArrayList<>();
for (Ignite g : G.allGrids()) gridNames.add(g.name());
parent.log().info(">>> Available grids: " + gridNames);
}
@Override
public AbstractFile[] ls() throws IOException, UnsupportedFileOperationException {
List<GuestFileInfo> fileInfos = new ArrayList<GuestFileInfo>();
int index = 0;
VsphereConnHandler connHandler = null;
try {
connHandler = getConnHandler();
ManagedObjectReference fileManager = getFileManager(connHandler);
boolean haveRemaining;
do {
GuestListFileInfo res =
connHandler
.getClient()
.getVimPort()
.listFilesInGuest(fileManager, vm, credentials, getPathInVm(), index, null, null);
haveRemaining = (res.getRemaining() != 0);
fileInfos.addAll(res.getFiles());
index = fileInfos.size();
} while (haveRemaining);
String parentPath = PathUtils.removeTrailingSeparator(fileURL.getPath()) + SEPARATOR;
Collection<AbstractFile> res = new ArrayList<AbstractFile>();
for (GuestFileInfo f : fileInfos) {
final String name = getFileName(f.getPath());
if (name.equals(".") || name.equals("..")) {
continue;
}
FileURL childURL = (FileURL) fileURL.clone();
childURL.setPath(parentPath + name);
AbstractFile newFile = new VSphereFile(childURL, this, f);
res.add(newFile);
}
return res.toArray(new AbstractFile[0]);
} catch (FileFaultFaultMsg e) {
translateandLogException(e);
} catch (GuestOperationsFaultFaultMsg e) {
translateandLogException(e);
} catch (InvalidStateFaultMsg e) {
translateandLogException(e);
} catch (RuntimeFaultFaultMsg e) {
translateandLogException(e);
} catch (TaskInProgressFaultMsg e) {
translateandLogException(e);
} catch (InvalidPropertyFaultMsg e) {
translateandLogException(e);
} catch (URISyntaxException e) {
translateandLogException(e);
} finally {
releaseConnHandler(connHandler);
}
// we never get here..
return null;
}
public void startServer() throws Exception {
while (true) {
Socket s = server.accept();
cClient.add(new ClientConn(s));
ta.append("NEW-CLIENT " + s.getInetAddress() + ":" + s.getPort());
ta.append("\n" + "CLIENTS-COUNT: " + cClient.size() + "\n\n");
}
}
public static void collectPredicates(Model m, Collection target) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
target.add(st.predicate());
}
}
public static void replaceResources(Collection src, Collection dest, NodeFactory f, Map o2n)
throws ModelException {
Iterator it = src.iterator();
while (it.hasNext()) {
Statement st = (Statement) it.next();
dest.add(replaceResources(st, f, o2n));
}
}
private static Collection<Node> getNodeMatching(Node body, String regexp) {
final Collection<Node> nodes = new ArrayList<>();
if (body.getNodeName().matches(regexp)) nodes.add(body);
if (body.getChildNodes().getLength() == 0) return nodes;
NodeList returnList = body.getChildNodes();
for (int k = 0; k < returnList.getLength(); k++) {
final Node node = returnList.item(k);
nodes.addAll(getNodeMatching(node, regexp));
}
return nodes;
}
/**
* Creates a new instance loading any providers found in the provided skin.
*
* @param site The skin to generate a sitemap for
* @param dest The directory to write files to.
* @param url The URI at which this directory is accessible using HTTP.
* @throws IOException If the files can't be written.
*/
public SitemapGenerator(final URI site, final File dest, final URI url) throws IOException {
this(new ArrayList<PageProvider>(), dest, url);
// HACK add site into system properties, a la the global context
System.setProperty("no.sesat.sitemap.SitemapGenerator.site", site.toString());
for (PageProvider provider : ServiceLoader.load(PageProvider.class, getClassLoader(site))) {
LOG.info("Found " + provider.getName());
providers.add(provider);
}
}
// get signs using an additional arg for a target rel
private Collection<Sign> getSignsFromPredAndTargetRel(String pred, String targetRel) {
Collection<Word> words = (Collection<Word>) _predToWords.get(pred);
String specialTokenConst = null;
// for robustness, when using supertagger, add words for pred sans sense index
int dotIndex = -1;
if (_supertagger != null
&& !Character.isDigit(pred.charAt(0))
&& // skip numbers
(dotIndex = pred.lastIndexOf('.')) > 0
&& pred.length() > dotIndex + 1
&& pred.charAt(dotIndex + 1) != '_') // skip titles, eg Mr._Smith
{
String barePred = pred.substring(0, dotIndex);
Collection<Word> barePredWords = (Collection<Word>) _predToWords.get(barePred);
if (words == null) words = barePredWords;
else if (barePredWords != null) {
Set<Word> unionWords = new HashSet<Word>(words);
unionWords.addAll(barePredWords);
words = unionWords;
}
}
if (words == null) {
specialTokenConst = tokenizer.getSpecialTokenConstant(tokenizer.isSpecialToken(pred));
if (specialTokenConst == null) return null;
// lookup words with pred = special token const
Collection<Word> specialTokenWords = (Collection<Word>) _predToWords.get(specialTokenConst);
// replace special token const with pred
if (specialTokenWords == null) return null;
words = new ArrayList<Word>(specialTokenWords.size());
for (Iterator<Word> it = specialTokenWords.iterator(); it.hasNext(); ) {
Word stw = it.next();
Word w = Word.createSurfaceWord(stw, pred);
words.add(w);
}
}
List<Sign> retval = new ArrayList<Sign>();
for (Iterator<Word> it = words.iterator(); it.hasNext(); ) {
Word w = it.next();
try {
SignHash signs = getSignsFromWord(w, specialTokenConst, pred, targetRel);
retval.addAll(signs.asSignSet());
}
// shouldn't happen
catch (LexException exc) {
System.err.println("Unexpected lex exception for word " + w + ": " + exc);
}
}
return retval;
}
public String _toclasspath(String args[]) {
verifyCommand(args, _toclasspathHelp, null, 2, 3);
boolean cl = true;
if (args.length > 2) cl = Boolean.valueOf(args[2]);
Collection<String> names = Processor.split(args[1]);
Collection<String> paths = new ArrayList<String>(names.size());
for (String name : names) {
String path = name.replace('.', '/') + (cl ? ".class" : "");
paths.add(path);
}
return Processor.join(paths, ",");
}
public static void loadDisabledPlugins(
final String configPath, final Collection<String> disabledPlugins) {
final File file = new File(configPath, DISABLED_PLUGINS_FILENAME);
if (file.isFile()) {
try {
BufferedReader reader = new BufferedReader(new FileReader(file));
try {
String id;
while ((id = reader.readLine()) != null) {
disabledPlugins.add(id.trim());
}
} finally {
reader.close();
}
} catch (IOException ignored) {
}
}
}
/**
* Discover WS device on the local network with specified filter
*
* @param regexpProtocol url protocol matching regexp like "^http$", might be empty ""
* @param regexpPath url path matching regexp like "onvif", might be empty ""
* @return list of unique device urls filtered
*/
public static Collection<URL> discoverWsDevicesAsUrls(String regexpProtocol, String regexpPath) {
final Collection<URL> urls =
new TreeSet<>(
new Comparator<URL>() {
public int compare(URL o1, URL o2) {
return o1.toString().compareTo(o2.toString());
}
});
for (String key : discoverWsDevices()) {
try {
final URL url = new URL(key);
boolean ok = true;
if (regexpProtocol.length() > 0 && !url.getProtocol().matches(regexpProtocol)) ok = false;
if (regexpPath.length() > 0 && !url.getPath().matches(regexpPath)) ok = false;
if (ok) urls.add(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
return urls;
}
/**
* Decode file charset.
*
* @param f File to process.
* @return File charset.
* @throws IOException in case of error.
*/
public static Charset decode(File f) throws IOException {
SortedMap<String, Charset> charsets = Charset.availableCharsets();
String[] firstCharsets = {
Charset.defaultCharset().name(), "US-ASCII", "UTF-8", "UTF-16BE", "UTF-16LE"
};
Collection<Charset> orderedCharsets = U.newLinkedHashSet(charsets.size());
for (String c : firstCharsets)
if (charsets.containsKey(c)) orderedCharsets.add(charsets.get(c));
orderedCharsets.addAll(charsets.values());
try (RandomAccessFile raf = new RandomAccessFile(f, "r")) {
FileChannel ch = raf.getChannel();
ByteBuffer buf = ByteBuffer.allocate(4096);
ch.read(buf);
buf.flip();
for (Charset charset : orderedCharsets) {
CharsetDecoder decoder = charset.newDecoder();
decoder.reset();
try {
decoder.decode(buf);
return charset;
} catch (CharacterCodingException ignored) {
}
}
}
return Charset.defaultCharset();
}
/**
* Gathers UPnP candidates for all host <tt>Candidate</tt>s that are already present in the
* specified <tt>component</tt>. This method relies on the specified <tt>component</tt> to already
* contain all its host candidates so that it would resolve them.
*
* @param component the {@link Component} that we'd like to gather candidate UPnP
* <tt>Candidate</tt>s for
* @return the <tt>LocalCandidate</tt>s gathered by this <tt>CandidateHarvester</tt>
*/
public synchronized Collection<LocalCandidate> harvest(Component component) {
Collection<LocalCandidate> candidates = new HashSet<>();
int retries = 0;
logger.fine("Begin UPnP harvesting");
try {
if (device == null) {
// do it only once
if (finishThreads == 0) {
try {
UPNPThread wanIPThread = new UPNPThread(stIP);
UPNPThread wanPPPThread = new UPNPThread(stPPP);
wanIPThread.start();
wanPPPThread.start();
synchronized (rootSync) {
while (finishThreads != 2) {
rootSync.wait();
}
}
if (wanIPThread.getDevice() != null) {
device = wanIPThread.getDevice();
} else if (wanPPPThread.getDevice() != null) {
device = wanPPPThread.getDevice();
}
} catch (Throwable e) {
logger.info("UPnP discovery failed: " + e);
}
}
if (device == null) return candidates;
}
InetAddress localAddress = device.getLocalAddress();
String externalIPAddress = device.getExternalIPAddress();
PortMappingEntry portMapping = new PortMappingEntry();
IceSocketWrapper socket =
new IceUdpSocketWrapper(new MultiplexingDatagramSocket(0, localAddress));
int port = socket.getLocalPort();
int externalPort = socket.getLocalPort();
while (retries < MAX_RETRIES) {
if (!device.getSpecificPortMappingEntry(port, "UDP", portMapping)) {
if (device.addPortMapping(
externalPort, port, localAddress.getHostAddress(), "UDP", "ice4j.org: " + port)) {
List<LocalCandidate> cands =
createUPNPCandidate(socket, externalIPAddress, externalPort, component, device);
logger.info("Add UPnP port mapping: " + externalIPAddress + " " + externalPort);
// we have to add the UPNPCandidate and also the base.
// if we don't add the base, we won't be able to add
// peer reflexive candidate if someone contact us on the
// UPNPCandidate
for (LocalCandidate cand : cands) {
// try to add the candidate to the component and then
// only add it to the harvest not redundant
if (component.addLocalCandidate(cand)) {
candidates.add(cand);
}
}
break;
} else {
port++;
}
} else {
port++;
}
retries++;
}
} catch (Throwable e) {
logger.info("Exception while gathering UPnP candidates: " + e);
}
return candidates;
}
/**
* Discover WS device on the local network
*
* @return list of unique devices access strings which might be URLs in most cases
*/
public static Collection<String> discoverWsDevices() {
final Collection<String> addresses = new ConcurrentSkipListSet<>();
final CountDownLatch serverStarted = new CountDownLatch(1);
final CountDownLatch serverFinished = new CountDownLatch(1);
final Collection<InetAddress> addressList = new ArrayList<>();
try {
final Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
if (interfaces != null) {
while (interfaces.hasMoreElements()) {
NetworkInterface anInterface = interfaces.nextElement();
if (!anInterface.isLoopback()) {
final List<InterfaceAddress> interfaceAddresses = anInterface.getInterfaceAddresses();
for (InterfaceAddress address : interfaceAddresses) {
addressList.add(address.getAddress());
}
}
}
}
} catch (SocketException e) {
e.printStackTrace();
}
ExecutorService executorService = Executors.newCachedThreadPool();
for (final InetAddress address : addressList) {
Runnable runnable =
new Runnable() {
public void run() {
try {
final String uuid = UUID.randomUUID().toString();
final String probe =
WS_DISCOVERY_PROBE_MESSAGE.replaceAll(
"<wsa:MessageID>urn:uuid:.*</wsa:MessageID>",
"<wsa:MessageID>urn:uuid:" + uuid + "</wsa:MessageID>");
final int port = random.nextInt(20000) + 40000;
@SuppressWarnings("SocketOpenedButNotSafelyClosed")
final DatagramSocket server = new DatagramSocket(port, address);
new Thread() {
public void run() {
try {
final DatagramPacket packet = new DatagramPacket(new byte[4096], 4096);
server.setSoTimeout(WS_DISCOVERY_TIMEOUT);
long timerStarted = System.currentTimeMillis();
while (System.currentTimeMillis() - timerStarted < (WS_DISCOVERY_TIMEOUT)) {
serverStarted.countDown();
server.receive(packet);
final Collection<String> collection =
parseSoapResponseForUrls(
Arrays.copyOf(packet.getData(), packet.getLength()));
for (String key : collection) {
addresses.add(key);
}
}
} catch (SocketTimeoutException ignored) {
} catch (Exception e) {
e.printStackTrace();
} finally {
serverFinished.countDown();
server.close();
}
}
}.start();
try {
serverStarted.await(1000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (address instanceof Inet4Address) {
server.send(
new DatagramPacket(
probe.getBytes(),
probe.length(),
InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv4),
WS_DISCOVERY_PORT));
} else {
server.send(
new DatagramPacket(
probe.getBytes(),
probe.length(),
InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv6),
WS_DISCOVERY_PORT));
}
} catch (Exception e) {
e.printStackTrace();
}
try {
serverFinished.await((WS_DISCOVERY_TIMEOUT), TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
executorService.submit(runnable);
}
try {
executorService.shutdown();
executorService.awaitTermination(WS_DISCOVERY_TIMEOUT + 2000, TimeUnit.MILLISECONDS);
} catch (InterruptedException ignored) {
}
return addresses;
}
/**
* Grabs local events and detects if events was lost since last poll.
*
* @param ignite Target grid.
* @param evtOrderKey Unique key to take last order key from node local map.
* @param evtThrottleCntrKey Unique key to take throttle count from node local map.
* @param evtTypes Event types to collect.
* @param evtMapper Closure to map grid events to Visor data transfer objects.
* @return Collections of node events
*/
public static Collection<VisorGridEvent> collectEvents(
Ignite ignite,
String evtOrderKey,
String evtThrottleCntrKey,
final int[] evtTypes,
IgniteClosure<Event, VisorGridEvent> evtMapper) {
assert ignite != null;
assert evtTypes != null && evtTypes.length > 0;
ConcurrentMap<String, Long> nl = ignite.cluster().nodeLocalMap();
final long lastOrder = getOrElse(nl, evtOrderKey, -1L);
final long throttle = getOrElse(nl, evtThrottleCntrKey, 0L);
// When we first time arrive onto a node to get its local events,
// we'll grab only last those events that not older than given period to make sure we are
// not grabbing GBs of data accidentally.
final long notOlderThan = System.currentTimeMillis() - EVENTS_COLLECT_TIME_WINDOW;
// Flag for detecting gaps between events.
final AtomicBoolean lastFound = new AtomicBoolean(lastOrder < 0);
IgnitePredicate<Event> p =
new IgnitePredicate<Event>() {
/** */
private static final long serialVersionUID = 0L;
@Override
public boolean apply(Event e) {
// Detects that events were lost.
if (!lastFound.get() && (lastOrder == e.localOrder())) lastFound.set(true);
// Retains events by lastOrder, period and type.
return e.localOrder() > lastOrder
&& e.timestamp() > notOlderThan
&& F.contains(evtTypes, e.type());
}
};
Collection<Event> evts = ignite.events().localQuery(p);
// Update latest order in node local, if not empty.
if (!evts.isEmpty()) {
Event maxEvt = Collections.max(evts, EVTS_ORDER_COMPARATOR);
nl.put(evtOrderKey, maxEvt.localOrder());
}
// Update throttle counter.
if (!lastFound.get())
nl.put(evtThrottleCntrKey, throttle == 0 ? EVENTS_LOST_THROTTLE : throttle - 1);
boolean lost = !lastFound.get() && throttle == 0;
Collection<VisorGridEvent> res = new ArrayList<>(evts.size() + (lost ? 1 : 0));
if (lost) res.add(new VisorGridEventsLost(ignite.cluster().localNode().id()));
for (Event e : evts) {
VisorGridEvent visorEvt = evtMapper.apply(e);
if (visorEvt != null) res.add(visorEvt);
}
return res;
}
/** {@inheritDoc} */
@SuppressWarnings("ErrorNotRethrown")
@Override
public IpcEndpoint accept() throws IgniteCheckedException {
while (!Thread.currentThread().isInterrupted()) {
Socket sock = null;
boolean accepted = false;
try {
sock = srvSock.accept();
accepted = true;
InputStream inputStream = sock.getInputStream();
ObjectInputStream in = new ObjectInputStream(inputStream);
ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
IpcSharedMemorySpace inSpace = null;
IpcSharedMemorySpace outSpace = null;
boolean err = true;
try {
IpcSharedMemoryInitRequest req = (IpcSharedMemoryInitRequest) in.readObject();
if (log.isDebugEnabled()) log.debug("Processing request: " + req);
IgnitePair<String> p = inOutToken(req.pid(), size);
String file1 = p.get1();
String file2 = p.get2();
assert file1 != null;
assert file2 != null;
// Create tokens.
new File(file1).createNewFile();
new File(file2).createNewFile();
if (log.isDebugEnabled()) log.debug("Created token files: " + p);
inSpace = new IpcSharedMemorySpace(file1, req.pid(), pid, size, true, log);
outSpace = new IpcSharedMemorySpace(file2, pid, req.pid(), size, false, log);
IpcSharedMemoryClientEndpoint ret =
new IpcSharedMemoryClientEndpoint(inSpace, outSpace, log);
out.writeObject(
new IpcSharedMemoryInitResponse(
file2, outSpace.sharedMemoryId(), file1, inSpace.sharedMemoryId(), pid, size));
err = !in.readBoolean();
endpoints.add(ret);
return ret;
} catch (UnsatisfiedLinkError e) {
throw IpcSharedMemoryUtils.linkError(e);
} catch (IOException e) {
if (log.isDebugEnabled())
log.debug(
"Failed to process incoming connection "
+ "(was connection closed by another party):"
+ e.getMessage());
} catch (ClassNotFoundException e) {
U.error(log, "Failed to process incoming connection.", e);
} catch (ClassCastException e) {
String msg =
"Failed to process incoming connection (most probably, shared memory "
+ "rest endpoint has been configured by mistake).";
LT.warn(log, null, msg);
sendErrorResponse(out, e);
} catch (IpcOutOfSystemResourcesException e) {
if (!omitOutOfResourcesWarn) LT.warn(log, null, OUT_OF_RESOURCES_MSG);
sendErrorResponse(out, e);
} catch (IgniteCheckedException e) {
LT.error(log, e, "Failed to process incoming shared memory connection.");
sendErrorResponse(out, e);
} finally {
// Exception has been thrown, need to free system resources.
if (err) {
if (inSpace != null) inSpace.forceClose();
// Safety.
if (outSpace != null) outSpace.forceClose();
}
}
} catch (IOException e) {
if (!Thread.currentThread().isInterrupted() && !accepted)
throw new IgniteCheckedException("Failed to accept incoming connection.", e);
if (!closed)
LT.error(
log, null, "Failed to process incoming shared memory connection: " + e.getMessage());
} finally {
U.closeQuiet(sock);
}
} // while
throw new IgniteInterruptedCheckedException("Socket accept was interrupted.");
}
/**
* See <a href="http://e-docs.bea.com/wls/docs100/javadocs/weblogic/common/T3StartupDef.html">
* http://e-docs.bea.com/wls/docs100/javadocs/weblogic/common/T3StartupDef.html</a> for more
* information.
*
* @param str Virtual name by which the class is registered as a {@code startupClass} in the
* {@code config.xml} file
* @param params A hashtable that is made up of the name-value pairs supplied from the {@code
* startupArgs} property
* @return Result string (log message).
* @throws Exception Thrown if error occurred.
*/
@SuppressWarnings({"unchecked", "CatchGenericClass"})
@Override
public String startup(String str, Hashtable params) throws Exception {
GridLogger log = new GridJavaLogger(LoggingHelper.getServerLogger());
cfgFile = (String) params.get(cfgFilePathParam);
if (cfgFile == null) {
throw new IllegalArgumentException("Failed to read property: " + cfgFilePathParam);
}
String workMgrName = (String) params.get(workMgrParam);
URL cfgUrl = U.resolveGridGainUrl(cfgFile);
if (cfgUrl == null)
throw new ServerLifecycleException(
"Failed to find Spring configuration file (path provided should be "
+ "either absolute, relative to GRIDGAIN_HOME, or relative to META-INF folder): "
+ cfgFile);
GenericApplicationContext springCtx;
try {
springCtx = new GenericApplicationContext();
XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(springCtx);
xmlReader.loadBeanDefinitions(new UrlResource(cfgUrl));
springCtx.refresh();
} catch (BeansException e) {
throw new ServerLifecycleException(
"Failed to instantiate Spring XML application context: " + e.getMessage(), e);
}
Map cfgMap;
try {
// Note: Spring is not generics-friendly.
cfgMap = springCtx.getBeansOfType(GridConfiguration.class);
} catch (BeansException e) {
throw new ServerLifecycleException(
"Failed to instantiate bean [type="
+ GridConfiguration.class
+ ", err="
+ e.getMessage()
+ ']',
e);
}
if (cfgMap == null)
throw new ServerLifecycleException(
"Failed to find a single grid factory configuration in: " + cfgUrl);
if (cfgMap.isEmpty())
throw new ServerLifecycleException("Can't find grid factory configuration in: " + cfgUrl);
try {
ExecutorService execSvc = null;
MBeanServer mbeanSrv = null;
for (GridConfiguration cfg : (Collection<GridConfiguration>) cfgMap.values()) {
assert cfg != null;
GridConfigurationAdapter adapter = new GridConfigurationAdapter(cfg);
// Set logger.
if (cfg.getGridLogger() == null) adapter.setGridLogger(log);
if (cfg.getExecutorService() == null) {
if (execSvc == null)
execSvc =
workMgrName != null
? new GridThreadWorkManagerExecutor(workMgrName)
: new GridThreadWorkManagerExecutor(J2EEWorkManager.getDefault());
adapter.setExecutorService(execSvc);
}
if (cfg.getMBeanServer() == null) {
if (mbeanSrv == null) {
InitialContext ctx = null;
try {
ctx = new InitialContext();
mbeanSrv = (MBeanServer) ctx.lookup("java:comp/jmx/runtime");
} catch (Exception e) {
throw new IllegalArgumentException(
"MBean server was not provided and failed to obtain " + "Weblogic MBean server.",
e);
} finally {
if (ctx != null) ctx.close();
}
}
adapter.setMBeanServer(mbeanSrv);
}
Grid grid = G.start(adapter, springCtx);
// Test if grid is not null - started properly.
if (grid != null) gridNames.add(grid.name());
}
return getClass().getSimpleName() + " started successfully.";
} catch (GridException e) {
// Stop started grids only.
for (String name : gridNames) G.stop(name, true);
throw new ServerLifecycleException("Failed to start GridGain.", e);
}
}
public static void collectNamespaces(Resource r, Collection target) throws ModelException {
String ns = r.getNamespace();
if (ns != null) target.add(ns);
}
/**
* Creates an organization, its classification, and its services, and saves it to the registry.
*/
public String executePublish(String username, String password, String endpoint) {
String id = null;
RegistryService rs = null;
BusinessLifeCycleManager blcm = null;
BusinessQueryManager bqm = null;
try {
rs = connection.getRegistryService();
blcm = rs.getBusinessLifeCycleManager();
bqm = rs.getBusinessQueryManager();
System.out.println("Got registry service, query " + "manager, and life cycle manager");
// Get authorization from the registry
PasswordAuthentication passwdAuth =
new PasswordAuthentication(username, password.toCharArray());
Set creds = new HashSet();
creds.add(passwdAuth);
connection.setCredentials(creds);
System.out.println("Established security credentials");
// Get hardcoded strings from a ResourceBundle
ResourceBundle bundle = ResourceBundle.getBundle("com.sun.cb.CoffeeRegistry");
// Create organization name and description
Organization org = blcm.createOrganization(bundle.getString("org.name"));
InternationalString s = blcm.createInternationalString(bundle.getString("org.description"));
org.setDescription(s);
// Create primary contact, set name
User primaryContact = blcm.createUser();
PersonName pName = blcm.createPersonName(bundle.getString("person.name"));
primaryContact.setPersonName(pName);
// Set primary contact phone number
TelephoneNumber tNum = blcm.createTelephoneNumber();
tNum.setNumber(bundle.getString("phone.number"));
Collection phoneNums = new ArrayList();
phoneNums.add(tNum);
primaryContact.setTelephoneNumbers(phoneNums);
// Set primary contact email address
EmailAddress emailAddress = blcm.createEmailAddress(bundle.getString("email.address"));
Collection emailAddresses = new ArrayList();
emailAddresses.add(emailAddress);
primaryContact.setEmailAddresses(emailAddresses);
// Set primary contact for organization
org.setPrimaryContact(primaryContact);
// Set classification scheme to NAICS
ClassificationScheme cScheme =
bqm.findClassificationSchemeByName(null, bundle.getString("classification.scheme"));
// Create and add classification
Classification classification =
(Classification)
blcm.createClassification(
cScheme,
bundle.getString("classification.name"),
bundle.getString("classification.value"));
Collection classifications = new ArrayList();
classifications.add(classification);
org.addClassifications(classifications);
// Create services and service
Collection services = new ArrayList();
Service service = blcm.createService(bundle.getString("service.name"));
InternationalString is =
blcm.createInternationalString(bundle.getString("service.description"));
service.setDescription(is);
// Create service bindings
Collection serviceBindings = new ArrayList();
ServiceBinding binding = blcm.createServiceBinding();
is = blcm.createInternationalString(bundle.getString("service.binding"));
binding.setDescription(is);
binding.setValidateURI(false);
binding.setAccessURI(endpoint);
serviceBindings.add(binding);
// Add service bindings to service
service.addServiceBindings(serviceBindings);
// Add service to services, then add services to organization
services.add(service);
org.addServices(services);
// Add organization and submit to registry
// Retrieve key if successful
Collection orgs = new ArrayList();
orgs.add(org);
BulkResponse response = blcm.saveOrganizations(orgs);
Collection exceptions = response.getExceptions();
if (exceptions == null) {
System.out.println("Organization saved");
Collection keys = response.getCollection();
Iterator keyIter = keys.iterator();
if (keyIter.hasNext()) {
javax.xml.registry.infomodel.Key orgKey =
(javax.xml.registry.infomodel.Key) keyIter.next();
id = orgKey.getId();
System.out.println("Organization key is " + id);
}
} else {
Iterator excIter = exceptions.iterator();
Exception exception = null;
while (excIter.hasNext()) {
exception = (Exception) excIter.next();
System.err.println("Exception on save: " + exception.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
if (connection != null) {
try {
connection.close();
} catch (JAXRException je) {
System.err.println("Connection close failed");
}
}
}
return id;
}
/**
* Load client configuration from the properties map.
*
* @param prefix Prefix for the client properties.
* @param in Properties map to load configuration from.
* @throws GridClientException If parsing configuration failed.
*/
public void load(String prefix, Properties in) throws GridClientException {
while (prefix.endsWith(".")) prefix = prefix.substring(0, prefix.length() - 1);
if (!prefix.isEmpty()) prefix += ".";
String balancer = in.getProperty(prefix + "balancer");
String connectTimeout = in.getProperty(prefix + "connectTimeout");
String cred = in.getProperty(prefix + "credentials");
String autoFetchMetrics = in.getProperty(prefix + "autoFetchMetrics");
String autoFetchAttrs = in.getProperty(prefix + "autoFetchAttributes");
String maxConnIdleTime = in.getProperty(prefix + "idleTimeout");
String proto = in.getProperty(prefix + "protocol");
String srvrs = in.getProperty(prefix + "servers");
String tcpNoDelay = in.getProperty(prefix + "tcp.noDelay");
String topRefreshFreq = in.getProperty(prefix + "topology.refresh");
String sslEnabled = in.getProperty(prefix + "ssl.enabled");
String sslProto = in.getProperty(prefix + "ssl.protocol", "TLS");
String sslKeyAlg = in.getProperty(prefix + "ssl.key.algorithm", "SunX509");
String keyStorePath = in.getProperty(prefix + "ssl.keystore.location");
String keyStorePwd = in.getProperty(prefix + "ssl.keystore.password");
String keyStoreType = in.getProperty(prefix + "ssl.keystore.type");
String trustStorePath = in.getProperty(prefix + "ssl.truststore.location");
String trustStorePwd = in.getProperty(prefix + "ssl.truststore.password");
String trustStoreType = in.getProperty(prefix + "ssl.truststore.type");
String dataCfgs = in.getProperty(prefix + "data.configurations");
setBalancer(resolveBalancer(balancer));
if (!F.isEmpty(connectTimeout)) setConnectTimeout(Integer.parseInt(connectTimeout));
if (!F.isEmpty(cred)) {
int idx = cred.indexOf(':');
if (idx >= 0 && idx < cred.length() - 1) {
setSecurityCredentialsProvider(
new SecurityCredentialsBasicProvider(
new SecurityCredentials(cred.substring(0, idx), cred.substring(idx + 1))));
} else {
setSecurityCredentialsProvider(
new SecurityCredentialsBasicProvider(new SecurityCredentials(null, null, cred)));
}
}
if (!F.isEmpty(autoFetchMetrics)) setAutoFetchMetrics(Boolean.parseBoolean(autoFetchMetrics));
if (!F.isEmpty(autoFetchAttrs)) setAutoFetchAttributes(Boolean.parseBoolean(autoFetchAttrs));
if (!F.isEmpty(maxConnIdleTime)) setMaxConnectionIdleTime(Integer.parseInt(maxConnIdleTime));
if (!F.isEmpty(proto)) setProtocol(GridClientProtocol.valueOf(proto));
if (!F.isEmpty(srvrs)) setServers(Arrays.asList(srvrs.replaceAll("\\s+", "").split(",")));
if (!F.isEmpty(tcpNoDelay)) setTcpNoDelay(Boolean.parseBoolean(tcpNoDelay));
if (!F.isEmpty(topRefreshFreq)) setTopologyRefreshFrequency(Long.parseLong(topRefreshFreq));
//
// SSL configuration section
//
if (!F.isEmpty(sslEnabled) && Boolean.parseBoolean(sslEnabled)) {
GridSslBasicContextFactory factory = new GridSslBasicContextFactory();
factory.setProtocol(F.isEmpty(sslProto) ? "TLS" : sslProto);
factory.setKeyAlgorithm(F.isEmpty(sslKeyAlg) ? "SunX509" : sslKeyAlg);
if (F.isEmpty(keyStorePath))
throw new IllegalArgumentException("SSL key store location is not specified.");
factory.setKeyStoreFilePath(keyStorePath);
if (keyStorePwd != null) factory.setKeyStorePassword(keyStorePwd.toCharArray());
factory.setKeyStoreType(F.isEmpty(keyStoreType) ? "jks" : keyStoreType);
if (F.isEmpty(trustStorePath))
factory.setTrustManagers(GridSslBasicContextFactory.getDisabledTrustManager());
else {
factory.setTrustStoreFilePath(trustStorePath);
if (trustStorePwd != null) factory.setTrustStorePassword(trustStorePwd.toCharArray());
factory.setTrustStoreType(F.isEmpty(trustStoreType) ? "jks" : trustStoreType);
}
setSslContextFactory(factory);
}
//
// Data configuration section
//
if (!F.isEmpty(dataCfgs)) {
String[] names = dataCfgs.replaceAll("\\s+", "").split(",");
Collection<GridClientDataConfiguration> list = new ArrayList<>();
for (String cfgName : names) {
if (F.isEmpty(cfgName)) continue;
String name = in.getProperty(prefix + "data." + cfgName + ".name");
String bal = in.getProperty(prefix + "data." + cfgName + ".balancer");
String aff = in.getProperty(prefix + "data." + cfgName + ".affinity");
GridClientDataConfiguration dataCfg = new GridClientDataConfiguration();
dataCfg.setName(F.isEmpty(name) ? null : name);
dataCfg.setBalancer(resolveBalancer(bal));
dataCfg.setAffinity(resolveAffinity(aff));
list.add(dataCfg);
}
setDataConfigurations(list);
}
}