/** * If the key is to be associated with a valid value, a mutation is created for it with the given * table and columns. In the event the value in the column is missing (i.e., null), then it is * marked for {@link Deletion}. Similarly, if the entire value for a key is missing (i.e., null), * then the entire key is marked for {@link Deletion}. * * @param keyColumns the key to write. * @param values the values to write. * @throws IOException */ @Override public void write(Map<String, ByteBuffer> keyColumns, List<ByteBuffer> values) throws IOException { TokenRange range = ringCache.getRange(getPartitionKey(keyColumns)); // get the client for the given range, or create a new one final InetAddress address = ringCache.getEndpoints(range).get(0); RangeClient client = clients.get(address); if (client == null) { // haven't seen keys for this range: create new client client = new RangeClient(ringCache.getEndpoints(range)); client.start(); clients.put(address, client); } // add primary key columns to the bind variables List<ByteBuffer> allValues = new ArrayList<ByteBuffer>(values); for (ColumnMetadata column : partitionKeyColumns) allValues.add(keyColumns.get(column.getName())); for (ColumnMetadata column : clusterColumns) allValues.add(keyColumns.get(column.getName())); client.put(allValues); if (progressable != null) progressable.progress(); if (context != null) HadoopCompat.progress(context); }
/** * Parse the parameters of a connection into a CoreNLP properties file that can be passed into * {@link StanfordCoreNLP}, and used in the I/O stages. * * @param httpExchange The http exchange; effectively, the request information. * @return A {@link Properties} object corresponding to a combination of default and passed * properties. * @throws UnsupportedEncodingException Thrown if we could not decode the key/value pairs with * UTF-8. */ private Properties getProperties(HttpExchange httpExchange) throws UnsupportedEncodingException { // Load the default properties Properties props = new Properties(); defaultProps .entrySet() .stream() .forEach( entry -> props.setProperty(entry.getKey().toString(), entry.getValue().toString())); // Try to get more properties from query string. Map<String, String> urlParams = getURLParams(httpExchange.getRequestURI()); if (urlParams.containsKey("properties")) { StringUtils.decodeMap(URLDecoder.decode(urlParams.get("properties"), "UTF-8")) .entrySet() .forEach(entry -> props.setProperty(entry.getKey(), entry.getValue())); } else if (urlParams.containsKey("props")) { StringUtils.decodeMap(URLDecoder.decode(urlParams.get("properties"), "UTF-8")) .entrySet() .forEach(entry -> props.setProperty(entry.getKey(), entry.getValue())); } // Make sure the properties compile props.setProperty( "annotators", StanfordCoreNLP.ensurePrerequisiteAnnotators( props.getProperty("annotators").split("[, \t]+"))); return props; }
/** * The gossip digest is built based on randomization rather than just looping through the * collection of live endpoints. * * @param gDigests list of Gossip Digests. */ void makeRandomGossipDigest(List<GossipDigest> gDigests) { /* Add the local endpoint state */ EndpointState epState = endpointStateMap_.get(localEndpoint_); int generation = epState.getHeartBeatState().getGeneration(); int maxVersion = getMaxEndpointStateVersion(epState); gDigests.add(new GossipDigest(localEndpoint_, generation, maxVersion)); List<InetAddress> endpoints = new ArrayList<InetAddress>(endpointStateMap_.keySet()); Collections.shuffle(endpoints, random_); for (InetAddress endpoint : endpoints) { epState = endpointStateMap_.get(endpoint); if (epState != null) { generation = epState.getHeartBeatState().getGeneration(); maxVersion = getMaxEndpointStateVersion(epState); gDigests.add(new GossipDigest(endpoint, generation, maxVersion)); } else { gDigests.add(new GossipDigest(endpoint, 0, 0)); } } /* FOR DEBUG ONLY - remove later */ StringBuilder sb = new StringBuilder(); for (GossipDigest gDigest : gDigests) { sb.append(gDigest); sb.append(" "); } if (logger_.isTraceEnabled()) logger_.trace("Gossip Digests are : " + sb.toString()); }
private void createKafkaAdaptorListener( InputEventAdapterListener inputEventAdapterListener, InputEventAdapterConfiguration inputEventAdapterConfiguration) { Map<String, String> brokerProperties = new HashMap<String, String>(); brokerProperties.putAll(inputEventAdapterConfiguration.getProperties()); String zkConnect = brokerProperties.get(KafkaEventAdapterConstants.ADAPTOR_SUSCRIBER_ZOOKEEPER_CONNECT); String groupID = brokerProperties.get(KafkaEventAdapterConstants.ADAPTOR_SUSCRIBER_GROUP_ID); String threadsStr = brokerProperties.get(KafkaEventAdapterConstants.ADAPTOR_SUSCRIBER_THREADS); String optionalConfiguration = brokerProperties.get(KafkaEventAdapterConstants.ADAPTOR_OPTIONAL_CONFIGURATION_PROPERTIES); int threads = Integer.parseInt(threadsStr); String topic = inputEventAdapterConfiguration .getProperties() .get(KafkaEventAdapterConstants.ADAPTOR_SUSCRIBER_TOPIC); consumerKafkaAdaptor = new ConsumerKafkaAdaptor( topic, tenantId, KafkaEventAdapter.createConsumerConfig(zkConnect, groupID, optionalConfiguration)); consumerKafkaAdaptor.run(threads, inputEventAdapterListener); }
void notifyFailureDetector(List<GossipDigest> gDigests) { IFailureDetector fd = FailureDetector.instance; for (GossipDigest gDigest : gDigests) { EndpointState localEndpointState = endpointStateMap_.get(gDigest.endpoint_); /* * If the local endpoint state exists then report to the FD only * if the versions workout. */ if (localEndpointState != null) { int localGeneration = endpointStateMap_.get(gDigest.endpoint_).getHeartBeatState().generation_; int remoteGeneration = gDigest.generation_; if (remoteGeneration > localGeneration) { fd.report(gDigest.endpoint_); continue; } if (remoteGeneration == localGeneration) { int localVersion = getMaxEndpointStateVersion(localEndpointState); // int localVersion = // endpointStateMap_.get(gDigest.endpoint_).getHeartBeatState().getHeartBeatVersion(); int remoteVersion = gDigest.maxVersion_; if (remoteVersion > localVersion) { fd.report(gDigest.endpoint_); } } } } }
@Test public void removeFromMap() { HazelcastClient hClient = getHazelcastClient(); Map map = hClient.getMap("removeFromMap"); assertNull(map.put("a", "b")); assertEquals("b", map.get("a")); assertEquals("b", map.remove("a")); assertNull(map.remove("a")); assertNull(map.get("a")); }
private ByteBuffer getPartitionKey(Map<String, ByteBuffer> keyColumns) { ByteBuffer partitionKey; if (partitionKeyColumns.size() > 1) { ByteBuffer[] keys = new ByteBuffer[partitionKeyColumns.size()]; for (int i = 0; i < keys.length; i++) keys[i] = keyColumns.get(partitionKeyColumns.get(i).getName()); partitionKey = CompositeType.build(keys); } else { partitionKey = keyColumns.get(partitionKeyColumns.get(0).getName()); } return partitionKey; }
private void handleSpecialCommands(Map<String, Object> arow, DocWrapper doc) { Object value = arow.get("$deleteDocById"); if (value != null) { if (value instanceof Collection) { Collection collection = (Collection) value; for (Object o : collection) { writer.deleteDoc(o.toString()); } } else { writer.deleteDoc(value); } } value = arow.get("$deleteDocByQuery"); if (value != null) { if (value instanceof Collection) { Collection collection = (Collection) value; for (Object o : collection) { writer.deleteByQuery(o.toString()); } } else { writer.deleteByQuery(value.toString()); } } value = arow.get("$docBoost"); if (value != null) { float value1 = 1.0f; if (value instanceof Number) { value1 = ((Number) value).floatValue(); } else { value1 = Float.parseFloat(value.toString()); } doc.setDocumentBoost(value1); } value = arow.get("$skipDoc"); if (value != null) { if (Boolean.parseBoolean(value.toString())) { throw new DataImportHandlerException( DataImportHandlerException.SKIP, "Document skipped :" + arow); } } value = arow.get("$skipRow"); if (value != null) { if (Boolean.parseBoolean(value.toString())) { throw new DataImportHandlerException(DataImportHandlerException.SKIP_ROW); } } }
static { threadPools.put( Stage.TRANSCODER, new ThreadPoolExecutor( 3, 3, 5 * 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactory() { public Thread newThread(Runnable r) { return ThreadPools.newThread( r, "TranscoderThread-" + Stage.TRANSCODER + "-" + (transSeq++)); } })); threadPools.put( Stage.RECOGNIZER, new ThreadPoolExecutor( 3, 3, 5 * 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactory() { public Thread newThread(Runnable r) { return ThreadPools.newThread( r, "TranscoderThread-" + Stage.RECOGNIZER + "-" + (transSeq++)); } })); // register them too ThreadPools.getThreadPools() .put(Executors.class.getName() + "." + Stage.TRANSCODER, threadPools.get(Stage.TRANSCODER)); ThreadPools.getThreadPools() .put(Executors.class.getName() + "." + Stage.RECOGNIZER, threadPools.get(Stage.RECOGNIZER)); // fill the rest of the map too, so we don't have to think about it any more later on. for (Stage s : Stage.values()) { if (!threadPools.containsKey(s)) { threadPools.put(s, ThreadPools.jobsExecutor); } } // default configuration, 5 + 1 executors. for (int i = 0; i < 5; i++) { executorsMap.put(new CommandExecutor.Method(), Stage.TRANSCODER); } executorsMap.put(new CommandExecutor.Method(), Stage.RECOGNIZER); readConfiguration(); }
@Test public void putToTheMap() throws InterruptedException { HazelcastClient hClient = getHazelcastClient(); Map<String, String> clientMap = hClient.getMap("putToTheMap"); assertEquals(0, clientMap.size()); String result = clientMap.put("1", "CBDEF"); assertNull(result); assertEquals("CBDEF", clientMap.get("1")); assertEquals("CBDEF", clientMap.get("1")); assertEquals("CBDEF", clientMap.get("1")); assertEquals(1, clientMap.size()); result = clientMap.put("1", "B"); assertEquals("CBDEF", result); assertEquals("B", clientMap.get("1")); assertEquals("B", clientMap.get("1")); }
private synchronized String allocName(String type, String namePattern) { Map<String, Integer> patterns = nameTypes.get(type); if (patterns == null) { patterns = new HashMap<String, Integer>(); nameTypes.put(type, patterns); } Integer id = patterns.get(namePattern); if (id == null) id = 0; id++; patterns.put(namePattern, id); String agentName = namePattern.replaceFirst("#", id.toString()); if (agentName.equals(namePattern)) Log.warn("AllocName: missing '#' in name pattern '" + namePattern + "'"); else Log.debug( "AllocName: for type=" + type + " assigned '" + agentName + "' from pattern '" + namePattern + "'"); return agentName; }
public static CudaEngine getCudaEngine(CudaObject co) { synchronized (cudaEngines) { if (!isCudaAvailable()) throw new CudaException("No cuda device found"); try { initialization.awaitTermination(100, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } Pheromone p = (Pheromone) co; final int pheroID = cudaObjectID.incrementAndGet(); final CudaEngine ce = cudaEngines.get(pheroID % availableDevicesNb); // final CudaEngine ce = cudaEngines.get(1); // final CudaEngine ce = cudaEngines.get(0); // final CudaEngine ce; // if(p.getName().contains("PRE")){ // ce = cudaEngines.get(0); // } // else{ // ce = cudaEngines.get(1); // } // ce.cudaObjects.add(co); System.err.println(co + "ID " + pheroID + " getting cuda engine Id " + ce.Id); return ce; } }
public void setProperty(final QName pid, final QName propName, final String value) { if (__log.isDebugEnabled()) __log.debug("Setting property " + propName + " on process " + pid); ProcessConfImpl pconf = _processes.get(pid); if (pconf == null) { String msg = __msgs.msgProcessNotFound(pid); __log.info(msg); throw new ContextException(msg); } final DeploymentUnitDir dudir = pconf.getDeploymentUnit(); exec( new ProcessStoreImpl.Callable<Object>() { public Object call(ConfStoreConnection conn) { DeploymentUnitDAO dudao = conn.getDeploymentUnit(dudir.getName()); if (dudao == null) return null; ProcessConfDAO proc = dudao.getProcess(pid); if (proc == null) return null; proc.setProperty(propName, value); return null; } }); fireEvent(new ProcessStoreEvent(ProcessStoreEvent.Type.PROPERTY_CHANGED, pid, dudir.getName())); }
/** {@inheritDoc} */ @Nullable @Override public Map<String, Collection<?>> run(GridStreamerContext ctx, Collection<Bar> bars) throws GridException { ConcurrentMap<String, Bar> loc = ctx.localSpace(); GridStreamerWindow win = ctx.window("stage2"); // Add numbers to window. win.enqueueAll(bars); Collection<Bar> polled = win.pollEvictedBatch(); if (!polled.isEmpty()) { Map<String, Bar> map = new HashMap<>(); for (Bar polledBar : polled) { String symbol = polledBar.symbol(); Bar bar = map.get(symbol); if (bar == null) map.put(symbol, bar = new Bar(symbol)); bar.update(polledBar); } loc.putAll(map); } return null; }
/** {@inheritDoc} */ @Nullable @Override public Map<String, Collection<?>> run(GridStreamerContext ctx, Collection<Quote> quotes) throws GridException { GridStreamerWindow win = ctx.window("stage1"); // Add numbers to window. win.enqueueAll(quotes); Collection<Quote> polled = win.pollEvictedBatch(); if (!polled.isEmpty()) { Map<String, Bar> map = new HashMap<>(); for (Quote quote : polled) { String symbol = quote.symbol(); Bar bar = map.get(symbol); if (bar == null) map.put(symbol, bar = new Bar(symbol)); bar.update(quote.price()); } return Collections.<String, Collection<?>>singletonMap(ctx.nextStageName(), map.values()); } return null; }
private List<TransactionInfo> getTransactions( Address source, Set<Integer> segments, int topologyId) { if (trace) { log.tracef( "Requesting transactions for segments %s of cache %s from node %s", segments, cacheName, source); } // get transactions and locks try { StateRequestCommand cmd = commandsFactory.buildStateRequestCommand( StateRequestCommand.Type.GET_TRANSACTIONS, rpcManager.getAddress(), topologyId, segments); Map<Address, Response> responses = rpcManager.invokeRemotely( Collections.singleton(source), cmd, ResponseMode.SYNCHRONOUS_IGNORE_LEAVERS, timeout); Response response = responses.get(source); if (response instanceof SuccessfulResponse) { return (List<TransactionInfo>) ((SuccessfulResponse) response).getResponseValue(); } log.failedToRetrieveTransactionsForSegments(segments, cacheName, source, null); } catch (CacheException e) { log.failedToRetrieveTransactionsForSegments(segments, cacheName, source, e); } return null; }
/** * Helper function to get value from map. * * @param map Map to take value from. * @param key Key to search in map. * @param ifNull Default value if {@code null} was returned by map. * @param <K> Key type. * @param <V> Value type. * @return Value from map or default value if map return {@code null}. */ public static <K, V> V getOrElse(Map<K, V> map, K key, V ifNull) { assert map != null; V res = map.get(key); return res != null ? res : ifNull; }
private void checkStartup( Map<String, ServiceData> map, List<ServiceData> start, ServiceData sd, Set<ServiceData> cyclic) { if (sd.after.isEmpty() || start.contains(sd)) return; if (cyclic.contains(sd)) { reporter.error("Cyclic dependency for " + sd.name); return; } cyclic.add(sd); for (String dependsOn : sd.after) { if (dependsOn.equals("boot")) continue; ServiceData deps = map.get(dependsOn); if (deps == null) { reporter.error("No such service " + dependsOn + " but " + sd.name + " depends on it"); } else { checkStartup(map, start, deps, cyclic); } } start.add(sd); }
/** * Add a record telling what entity caps node a user has. * * @param user the user (Full JID) * @param node the node (of the caps packet extension) * @param hash the hashing algorithm used to calculate <tt>ver</tt> * @param ver the version (of the caps packet extension) * @param ext the ext (of the caps packet extension) * @param online indicates if the user is online */ private void addUserCapsNode( String user, String node, String hash, String ver, String ext, boolean online) { if ((user != null) && (node != null) && (hash != null) && (ver != null)) { Caps caps = userCaps.get(user); if ((caps == null) || !caps.node.equals(node) || !caps.hash.equals(hash) || !caps.ver.equals(ver)) { caps = new Caps(node, hash, ver, ext); userCaps.put(user, caps); } else return; // Fire userCapsNodeAdded. UserCapsNodeListener[] listeners; synchronized (userCapsNodeListeners) { listeners = userCapsNodeListeners.toArray(NO_USER_CAPS_NODE_LISTENERS); } if (listeners.length != 0) { String nodeVer = caps.getNodeVer(); for (UserCapsNodeListener listener : listeners) listener.userCapsNodeAdded(user, nodeVer, online); } } }
/** * This method is part of IFailureDetectionEventListener interface. This is invoked by the Failure * Detector when it convicts an end point. * * <p>param @ endpoint end point that is convicted. */ public void convict(InetAddress endpoint) { EndpointState epState = endpointStateMap_.get(endpoint); if (epState.isAlive()) { logger_.info("InetAddress {} is now dead.", endpoint); isAlive(endpoint, epState, false); } }
/** * Remove records telling what entity caps node a contact has. * * @param contact the contact */ public void removeContactCapsNode(Contact contact) { Caps caps = null; String lastRemovedJid = null; Iterator<String> iter = userCaps.keySet().iterator(); while (iter.hasNext()) { String jid = iter.next(); if (StringUtils.parseBareAddress(jid).equals(contact.getAddress())) { caps = userCaps.get(jid); lastRemovedJid = jid; iter.remove(); } } // fire only for the last one, at the end the event out // of the protocol will be one and for the contact if (caps != null) { UserCapsNodeListener[] listeners; synchronized (userCapsNodeListeners) { listeners = userCapsNodeListeners.toArray(NO_USER_CAPS_NODE_LISTENERS); } if (listeners.length != 0) { String nodeVer = caps.getNodeVer(); for (UserCapsNodeListener listener : listeners) listener.userCapsNodeRemoved(lastRemovedJid, nodeVer, false); } } }
/** Returns the {@link SegmentCacheIndex} for a given {@link SegmentHeader}. */ private SegmentCacheIndex getIndex(SegmentHeader header) { // First we check the indexes that already exist. // This is fast. for (Entry<RolapStar, SegmentCacheIndex> entry : indexes.entrySet()) { final String factTableName = entry.getKey().getFactTable().getTableName(); final ByteString schemaChecksum = entry.getKey().getSchema().getChecksum(); if (!factTableName.equals(header.rolapStarFactTableName)) { continue; } if (!schemaChecksum.equals(header.schemaChecksum)) { continue; } return entry.getValue(); } // The index doesn't exist. Let's create it. for (RolapSchema schema : RolapSchema.getRolapSchemas()) { if (!schema.getChecksum().equals(header.schemaChecksum)) { continue; } // We have a schema match. RolapStar star = schema.getStar(header.rolapStarFactTableName); if (star != null) { // Found it. indexes.put(star, new SegmentCacheIndexImpl(thread)); } return indexes.get(star); } return null; }
/** Start the gossiper with the generation # retrieved from the System table */ public void start(InetAddress localEndpoint, int generationNbr) { localEndpoint_ = localEndpoint; /* Get the seeds from the config and initialize them. */ Set<InetAddress> seedHosts = DatabaseDescriptor.getSeeds(); for (InetAddress seed : seedHosts) { if (seed.equals(localEndpoint)) continue; seeds_.add(seed); } /* initialize the heartbeat state for this localEndpoint */ EndpointState localState = endpointStateMap_.get(localEndpoint_); if (localState == null) { HeartBeatState hbState = new HeartBeatState(generationNbr); localState = new EndpointState(hbState); localState.isAlive(true); localState.isAGossiper(true); endpointStateMap_.put(localEndpoint_, localState); } // notify snitches that Gossiper is about to start DatabaseDescriptor.getEndpointSnitch().gossiperStarting(); scheduledGossipTask = StorageService.scheduledTasks.scheduleWithFixedDelay( new GossipTask(), Gossiper.intervalInMillis_, Gossiper.intervalInMillis_, TimeUnit.MILLISECONDS); }
/** * Returns default <tt>WebRtcDataStream</tt> if it's ready or <tt>null</tt> otherwise. * * @return <tt>WebRtcDataStream</tt> if it's ready or <tt>null</tt> otherwise. * @throws IOException */ public WebRtcDataStream getDefaultDataStream() throws IOException { WebRtcDataStream def; synchronized (this) { if (sctpSocket == null) { def = null; } else { // Channel that runs on sid 0 def = channels.get(0); if (def == null) { def = openChannel(0, 0, 0, 0, "default"); } // Pawel Domas: Must be acknowledged before use /* * XXX Lyubomir Marinov: We're always sending ordered. According * to "WebRTC Data Channel Establishment Protocol", we can start * sending messages containing user data after the * DATA_CHANNEL_OPEN message has been sent without waiting for * the reception of the corresponding DATA_CHANNEL_ACK message. */ // if (!def.isAcknowledged()) // def = null; } } return def; }
void notifyFailureDetector(Map<InetAddress, EndpointState> remoteEpStateMap) { IFailureDetector fd = FailureDetector.instance; for (Entry<InetAddress, EndpointState> entry : remoteEpStateMap.entrySet()) { InetAddress endpoint = entry.getKey(); EndpointState remoteEndpointState = entry.getValue(); EndpointState localEndpointState = endpointStateMap_.get(endpoint); /* * If the local endpoint state exists then report to the FD only * if the versions workout. */ if (localEndpointState != null) { int localGeneration = localEndpointState.getHeartBeatState().generation_; int remoteGeneration = remoteEndpointState.getHeartBeatState().generation_; if (remoteGeneration > localGeneration) { fd.report(endpoint); continue; } if (remoteGeneration == localGeneration) { int localVersion = getMaxEndpointStateVersion(localEndpointState); // int localVersion = localEndpointState.getHeartBeatState().getHeartBeatVersion(); int remoteVersion = remoteEndpointState.getHeartBeatState().getHeartBeatVersion(); if (remoteVersion > localVersion) { fd.report(endpoint); } } } } }
public ProcessConf getProcessConfiguration(final QName processId) { _rw.readLock().lock(); try { return _processes.get(processId); } finally { _rw.readLock().unlock(); } }
void completed(InetAddress remote, String cfname) { logger.debug("Repair completed for {} on {}", remote, cfname); RepairJob job = activeJobs.get(cfname); if (job.completedSynchronizationJob(remote)) { activeJobs.remove(cfname); if (activeJobs.isEmpty()) completed.signalAll(); } }
public void setRetiredPackage(String packageName, boolean retired) { DeploymentUnitDir duDir = _deploymentUnits.get(packageName); if (duDir == null) throw new ContextException("Could not find package " + packageName); for (QName processName : duDir.getProcessNames()) { setState( toPid(processName, duDir.getVersion()), retired ? ProcessState.RETIRED : ProcessState.ACTIVE); } }
private void fixTimeLimit() { if (timeLimitFuture != null) timeLimitFuture.cancel(true); if (running && limits.containsKey(TIMER_COUNTER)) { long delay = limits.get(TIMER_COUNTER) * 1000 - time; if (delay > 0) { timeLimitFuture = scheduler.schedule(new TimeLimitTask(), delay, TimeUnit.MILLISECONDS); } } }
@Test public void getPuttedValueFromTheMap() { HazelcastClient hClient = getHazelcastClient(); Map<String, String> clientMap = hClient.getMap("getPuttedValueFromTheMap"); int size = clientMap.size(); clientMap.put("1", "Z"); String value = clientMap.get("1"); assertEquals("Z", value); assertEquals(size + 1, clientMap.size()); }