@Test public void testCreateQueueEndpoint() throws Exception { JmsEndpointComponent component = new JmsEndpointComponent(); reset(applicationContext); expect(applicationContext.containsBean("connectionFactory")).andReturn(true).once(); expect(applicationContext.getBean("connectionFactory", ConnectionFactory.class)) .andReturn(connectionFactory) .once(); replay(applicationContext); Endpoint endpoint = component.createEndpoint("jms:queuename", context); Assert.assertEquals(endpoint.getClass(), JmsEndpoint.class); Assert.assertEquals( ((JmsEndpoint) endpoint).getEndpointConfiguration().getDestinationName(), "queuename"); Assert.assertEquals( ((JmsEndpoint) endpoint).getEndpointConfiguration().isPubSubDomain(), false); Assert.assertEquals( ((JmsEndpoint) endpoint).getEndpointConfiguration().getConnectionFactory(), connectionFactory); Assert.assertNull(((JmsEndpoint) endpoint).getEndpointConfiguration().getDestination()); Assert.assertEquals(((JmsEndpoint) endpoint).getEndpointConfiguration().getTimeout(), 5000L); verify(applicationContext); }
/** * Notifies this instance that there was a change in the value of a property of an * <tt>Endpoint</tt> participating in this multipoint conference. * * @param endpoint the <tt>Endpoint</tt> which is the source of the event/notification and is * participating in this multipoint conference * @param ev a <tt>PropertyChangeEvent</tt> which specifies the source of the event/notification, * the name of the property and the old and new values of that property */ private void endpointPropertyChange(Endpoint endpoint, PropertyChangeEvent ev) { String propertyName = ev.getPropertyName(); boolean maybeRemoveEndpoint; if (Endpoint.SCTP_CONNECTION_PROPERTY_NAME.equals(propertyName)) { // The SctpConnection of/associated with an Endpoint has changed. We // may want to fire initial events over that SctpConnection (as soon // as it is ready). SctpConnection oldValue = (SctpConnection) ev.getOldValue(); SctpConnection newValue = (SctpConnection) ev.getNewValue(); endpointSctpConnectionChanged(endpoint, oldValue, newValue); // The SctpConnection may have expired. maybeRemoveEndpoint = (newValue == null); } else if (Endpoint.CHANNELS_PROPERTY_NAME.equals(propertyName)) { // An RtpChannel may have expired. maybeRemoveEndpoint = true; } else { maybeRemoveEndpoint = false; } if (maybeRemoveEndpoint) { // It looks like there is a chance that the Endpoint may have // expired. Endpoints are held by this Conference via WeakReferences // but WeakReferences are unpredictable. We have functionality // though which could benefit from discovering that an Endpoint has // expired as quickly as possible (e.g. ConferenceSpeechActivity). // Consequently, try to expedite the removal of expired Endpoints. if (endpoint.getSctpConnection() == null && endpoint.getChannelCount(null) == 0) { removeEndpoint(endpoint); } } }
public void init(SynapseEnvironment synapseEnvironment) { ConfigurationContext cc = ((Axis2SynapseEnvironment) synapseEnvironment).getAxis2ConfigurationContext(); if (!initialized) { // The check for clustering environment ClusteringAgent clusteringAgent = cc.getAxisConfiguration().getClusteringAgent(); if (clusteringAgent != null && clusteringAgent.getStateManager() != null) { isClusteringEnabled = Boolean.TRUE; } else { isClusteringEnabled = Boolean.FALSE; } context = new EndpointContext(getName(), getDefinition(), isClusteringEnabled, cc, metricsMBean); } initialized = true; if (children != null) { for (Endpoint e : children) { e.init(synapseEnvironment); } } contentAware = definition != null && ((definition.getFormat() != null && !definition.getFormat().equals(SynapseConstants.FORMAT_REST)) || definition.isSecurityOn() || definition.isReliableMessagingOn() || definition.isAddressingOn() || definition.isUseMTOM() || definition.isUseSwa()); }
@Override public Endpoint createEndpoint(String endpointUri, TestContext context) { try { URI uri = new URI(endpointUri); String path = uri.getSchemeSpecificPart(); if (path.startsWith("//")) { path = path.substring(2); } if (path.contains("?")) { path = path.substring(0, path.indexOf('?')); } Map<String, String> parameters = getParameters(endpointUri); String endpointName = null; if (parameters.containsKey(ENDPOINT_NAME)) { endpointName = parameters.remove(ENDPOINT_NAME); } Endpoint endpoint = createEndpoint(path, parameters, context); if (StringUtils.hasText(endpointName)) { endpoint.setName(endpointName); } return endpoint; } catch (URISyntaxException e) { throw new CitrusRuntimeException( String.format("Unable to parse endpoint uri '%s'", endpointUri), e); } }
/** * Checks whether RTP packets from {@code sourceChannel} should be forwarded to {@link #channel}. * * @param sourceChannel the channel. * @return {@code true} iff RTP packets from {@code sourceChannel} should be forwarded to {@link * #channel}. */ public boolean isForwarded(Channel sourceChannel) { if (lastN < 0 && currentLastN < 0) { // If Last-N is disabled, we forward everything. return true; } if (sourceChannel == null) { logger.warn("Invalid sourceChannel: null."); return false; } Endpoint channelEndpoint = sourceChannel.getEndpoint(); if (channelEndpoint == null) { logger.warn("sourceChannel has no endpoint."); return false; } if (forwardedEndpoints == INITIAL_EMPTY_LIST) { // LastN is enabled, but we haven't yet initialized the list of // endpoints in the conference. initializeConferenceEndpoints(); } // This may look like a place to optimize, because we query an unordered // list (in O(n)) and it executes on each video packet if lastN is // enabled. However, the size of forwardedEndpoints is restricted to // lastN and so small enough that it is not worth optimizing. return forwardedEndpoints.contains(channelEndpoint.getID()); }
/** * Gets an <tt>Endpoint</tt> participating in this <tt>Conference</tt> which has a specific * identifier/ID. If an <tt>Endpoint</tt> participating in this <tt>Conference</tt> with the * specified <tt>id</tt> does not exist at the time the method is invoked, the method optionally * initializes a new <tt>Endpoint</tt> instance with the specified <tt>id</tt> and adds it to the * list of <tt>Endpoint</tt>s participating in this <tt>Conference</tt>. * * @param id the identifier/ID of the <tt>Endpoint</tt> which is to be returned * @return an <tt>Endpoint</tt> participating in this <tt>Conference</tt> which has the specified * <tt>id</tt> or <tt>null</tt> if there is no such <tt>Endpoint</tt> and <tt>create</tt> * equals <tt>false</tt> */ private Endpoint getEndpoint(String id, boolean create) { Endpoint endpoint = null; boolean changed = false; synchronized (endpoints) { for (Iterator<WeakReference<Endpoint>> i = endpoints.iterator(); i.hasNext(); ) { Endpoint e = i.next().get(); if (e == null) { i.remove(); changed = true; } else if (e.getID().equals(id)) { endpoint = e; } } if (create && endpoint == null) { endpoint = new Endpoint(id, this); // The propertyChangeListener will weakly reference this // Conference and will unregister itself from the endpoint // sooner or later. endpoint.addPropertyChangeListener(propertyChangeListener); endpoints.add(new WeakReference<>(endpoint)); changed = true; EventAdmin eventAdmin = videobridge.getEventAdmin(); if (eventAdmin != null) eventAdmin.sendEvent(EventFactory.endpointCreated(endpoint)); } } if (changed) firePropertyChange(ENDPOINTS_PROPERTY_NAME, null, null); return endpoint; }
public Endpoint unmarshall(StaxUnmarshallerContext context) throws Exception { Endpoint endpoint = new Endpoint(); int originalDepth = context.getCurrentDepth(); int targetDepth = originalDepth + 1; if (context.isStartOfDocument()) targetDepth += 2; while (true) { XMLEvent xmlEvent = context.nextEvent(); if (xmlEvent.isEndDocument()) return endpoint; if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) { if (context.testExpression("Address", targetDepth)) { endpoint.setAddress(StringStaxUnmarshaller.getInstance().unmarshall(context)); continue; } if (context.testExpression("Port", targetDepth)) { endpoint.setPort(IntegerStaxUnmarshaller.getInstance().unmarshall(context)); continue; } } else if (xmlEvent.isEndElement()) { if (context.getCurrentDepth() < originalDepth) { return endpoint; } } } }
@Test public void testResolveJmsEndpoint() throws Exception { reset(applicationContext); expect(applicationContext.getBeansOfType(EndpointComponent.class)) .andReturn(Collections.<String, EndpointComponent>emptyMap()) .once(); expect(applicationContext.containsBean("connectionFactory")).andReturn(true).once(); expect(applicationContext.getBean("connectionFactory", ConnectionFactory.class)) .andReturn(EasyMock.createMock(ConnectionFactory.class)) .once(); replay(applicationContext); TestContext context = new TestContext(); context.setApplicationContext(applicationContext); DefaultEndpointFactory factory = new DefaultEndpointFactory(); Endpoint endpoint = factory.create("jms:Sample.Queue.Name", context); Assert.assertEquals(endpoint.getClass(), JmsEndpoint.class); Assert.assertEquals( ((JmsEndpoint) endpoint).getEndpointConfiguration().getDestinationName(), "Sample.Queue.Name"); verify(applicationContext); }
private void init(Interface intf) throws IOException { if (intf == null || intf.getNumEndpoints() != 2) throw new IllegalArgumentException(); // XXX presumably this handles the "multiple devfs claims" case; check. intf.claim(); this.intf = intf; try { for (int i = 0; i < intf.getNumEndpoints(); i++) { Endpoint ep = intf.getEndpoint(i); if (!"bulk".equals(ep.getType())) throw new IllegalArgumentException(); if (ep.isInput()) in = ep.getInputStream(); else out = ep.getOutputStream(); } if (in == null || out == null) throw new IllegalArgumentException(); } catch (IOException e) { try { close(); } catch (Exception x) { intf = null; } throw e; } catch (RuntimeException e) { try { close(); } catch (Exception x) { intf = null; } throw e; } }
public synchronized void unbind(EndOid oid, Ticket ticket) { List<Subscriber> subscribers = routes.get(oid); if (subscribers == null) { System.err.println("NULL Subscribers for: " + oid.toString()); return; } for (Subscriber sub : subscribers) { if (sub.ticket.equals(ticket)) { if (sub.continuation != null) { sub.continuation.resume(); sub.continuation = null; } subscribers.remove(sub); break; } } routes.put(oid, subscribers); if (subscribers.size() == 0) { Endpoint ep = registry.get(oid); if (ep == null) { System.err.println("Cannot find endpont: " + oid.toString()); return; } ep.idle = true; ep.idleTime = System.currentTimeMillis(); } }
private String getAnnotatedEndpoint(Object object) { if (object.getClass().isAnnotationPresent(Endpoint.class)) { Annotation annotation = object.getClass().getAnnotation(Endpoint.class); Endpoint endpoint = (Endpoint) annotation; return endpoint.target(); } return null; }
private void sendNewEndpointNotification(Endpoint endpoint, String name) { Intent intent = new Intent(NEW_ENDPOINT); intent.putExtra(ENDPOINT_ADDRESS, endpoint.toString()); intent.putExtra(ENDPOINT_HARDWARE, endpoint.getHardwareAsString()); intent.putExtra(ENDPOINT_NAME, name == null ? "" : name); mContext.sendBroadcast(intent); }
/** @return the ID of the endpoint of our channel. */ private String getEndpointId() { if (endpointId == null) { Endpoint endpoint = channel.getEndpoint(); if (endpoint != null) { endpointId = endpoint.getID(); } } return endpointId; }
/** * Used to send a message to a subset of endpoints in the call, primary use case being a message * that has originated from an endpoint (as opposed to a message originating from the bridge and * being sent to all endpoints in the call, for that see broadcastMessageOnDataChannels below * * @param msg * @param endpoints */ public void sendMessageOnDataChannels(String msg, List<Endpoint> endpoints) { for (Endpoint endpoint : endpoints) { try { endpoint.sendMessageOnDataChannel(msg); } catch (IOException e) { logger.error("Failed to send message on data channel.", e); } } }
private Endpoint getEndpoint(String name, String component) { Endpoint endpoint = endpointRepository.findOneByComponent(component); if (endpoint == null) { endpoint = new Endpoint(); endpoint.setComponent(component); endpoint.setName(name); return endpointRepository.save(endpoint); } return endpoint; }
private void update(Presence p) { if (!p.type.equals("show")) return; Endpoint ep = registry.get(p.fromOid); if (ep != null) { if (!ep.show.equals(p.show)) ep.show = p.show; if (!ep.status.equals(p.status)) ep.status = p.status; } else { System.err.println("NULL Endpoint when update presence: " + p.fromOid.toString()); } }
/** * Generates assembler classes if the API returns more than one object. * * @param resources * @param templateGroup */ private void generateModelClassesForInput( List<Resource> resources, StringTemplateGroup templateGroup) { List<String> generatedClasses = new ArrayList<String>(); for (Resource resource : resources) { if (resource.getEndPoints() != null) { for (Endpoint endpoint : resource.getEndPoints()) { if (endpoint.getOperations() != null) { for (EndpointOperation operation : endpoint.getOperations()) { ResourceMethod method = operation.generateMethod( endpoint, resource, dataTypeMappingProvider, nameGenerator); if (method.getInputModel() != null) { Model model = method.getInputModel(); if (model != null) { if (!generatedClasses.contains(model.getName())) { List<String> imports = new ArrayList<String>(); imports.addAll(this.config.getDefaultModelImports()); for (ModelField param : model.getFields()) { param.setName(reservedWordMapper.translate(param.getName())); for (String importDef : param .getFieldDefinition( this.getDataTypeMappingProvider(), config, nameGenerator) .getImportDefinitions()) { if (!imports.contains(importDef)) { imports.add(importDef); } } } StringTemplate template = templateGroup.getInstanceOf(MODEL_OBJECT_TEMPLATE); template.setAttribute("fields", model.getFields()); template.setAttribute("imports", imports); template.setAttribute("extends", config.getDefaultModelBaseClass()); template.setAttribute( "annotationPackageName", languageConfig.getAnnotationPackageName()); template.setAttribute("className", model.getGenratedClassName()); template.setAttribute(PACKAGE_NAME, config.getModelPackageName()); File aFile = new File( languageConfig.getModelClassLocation() + model.getGenratedClassName() + languageConfig.getClassFileExtension()); writeFile(aFile, template.toString(), "Input model class"); generatedClasses.add(model.getName()); } } } } } } } } }
/** * Extracts a list of endpoint IDs from a list of {@link Endpoint}s. * * @param endpoints the list of {@link Endpoint}s. * @return the list of IDs of endpoints in {@code endpoints}. */ private List<String> getIDs(List<Endpoint> endpoints) { if (endpoints != null && !endpoints.isEmpty()) { List<String> endpointIds = new LinkedList<>(); for (Endpoint endpoint : endpoints) { endpointIds.add(endpoint.getID()); } return endpointIds; } return null; }
private URI toIpUri(Endpoint endpoint, URI uri) throws URISyntaxException { final URI endpointUri = endpoint.getUri(); final String fullpath = endpointUri.getPath() + uri.getPath(); return new URI( endpointUri.getScheme(), endpointUri.getUserInfo(), endpoint.getIp().getHostAddress(), endpointUri.getPort(), fullpath, uri.getQuery(), null); }
public Endpoint modifyResourceEndpoint(Resource resource, EntityTag entityTag, Date lastModified) throws EndpointNotFoundException { checkNotNull(resource, "ResourceSnapshot cannot be null"); checkNotNull(entityTag, "Entity tag cannot be null"); checkNotNull(lastModified, "Last modified cannot be null"); Endpoint endpoint = endpointRepository.endpointOfResource(resource.id()); if (endpoint == null) { throw new EndpointNotFoundException(resource.id()); } endpoint.modify(entityTag, lastModified); return endpoint; }
@Override public void run() { Endpoint endpoint = (Endpoint) this.parameters; this.log("Starting..."); this.running = true; while (this.running) { try { if (this.connection == null) { this.parameters.setStatus(Endpoint.Status.CONNECTING); this.log("Attempting connection to " + endpoint.toConnectionString() + "..."); Socket socket = new EndpointSocketFactory().createSocket(endpoint); if (socket != null) { this.log("Socket connected."); this.log("Attempting to start Mercury thread..."); this.createConnection(new SocketTransport(socket)); } } else { synchronized (this.connection) { try { this.connection.wait(); } catch (InterruptedException e) { } catch (IllegalMonitorStateException e) { } } if (this.connection.started && !this.connection.running) { this.log("Connection was reset."); this.resetConnection(); } } } catch (UnknownHostException e) { this.log(LogMessage.ERROR, "Unknown Host: " + endpoint.getHost()); this.stopConnector(); } catch (IOException e) { this.log(LogMessage.ERROR, "IO Error. Resetting connection."); this.resetConnection(); } catch (KeyManagementException e) { this.log(LogMessage.ERROR, "Error loading key material for SSL."); this.stopConnector(); } } this.log("Stopped."); }
/* * Creates an endpoint with the wildcard adress (::0) and an ephemeral port. * The new endpoint gets a client message deliverer and is started. * To listen on specific interfaces or ports, set the default endpoint manually. * To distinguish different interfaces, one endpoint per interface must be added. */ private synchronized void createDefaultEndpoint() { if (default_endpoint != null) return; default_endpoint = new CoAPEndpoint(); try { default_endpoint.start(); LOGGER.log(Level.INFO, "Created implicit default endpoint " + default_endpoint.getAddress()); } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not create default endpoint", e); } }
@Test @RunAsClient public void testDate() throws Exception { URL wsdlURL = new URL(baseURL + "/MyService?wsdl"); QName qname = new QName("http://date.jaxws.ws.test.jboss.org/", "MyService"); Service service = Service.create(wsdlURL, qname); Endpoint port = service.getPort(Endpoint.class); Date date = new Date(); Date response = port.echoDate(date); assertEquals(date.toString(), response.toString()); }
/** * * * <pre> * Alice Proxy Bob * 1 | INVITE | | * |----------->| | * 2 | | INVITE | * | |----------->| * 3 | | 180 | * | |<-----------| * 4 | 180 | | * |<-----------| | * 5 | | CANCEL | * | |----------->| * 6 | 408 | | * |<-----------| | * 7 | | 200/CANCEL | * | |<-----------| * 8 | | 487/INVITE | * | |<-----------| * 9 | | ACK | * | |----------->| * 10 | ACK | | * |----------->| | * </pre> */ @Test public void testVirtualBranch() throws Exception { Endpoint bob = createEndpoint("bob"); UaRunnable callB = new UasScript.RingingCanceled(bob.getUserAgent()); callB.start(); SipServletRequest request = _ua.createRequest(SipMethods.INVITE, bob.getUri()); request.setRequestURI(bob.getContact().getURI()); Call callA = _ua.createCall(request); assertThat(callA.waitForResponse(), hasStatus(SipServletResponse.SC_REQUEST_TIMEOUT)); checkForFailure(); }
private String generatePathForAttachment(Resource child, Resource parent) throws EndpointNotFoundException { Attachment attachment = parent.findAttachment(child.id()); if (attachment == null) { return null; } Endpoint endpoint = getResourceEndpoint(parent.id()); ResourceTemplate parentTemplate = this.templateManagementService.findTemplateById(parent.id().templateId()); AttachedTemplate attachedTemplate = parentTemplate.attachedTemplate(attachment.id()); StringBuilder builder = new StringBuilder(); addSegment(builder, endpoint.path()); addSegment(builder, attachedTemplate.path()); return builder.toString(); }
/** {@inheritDoc} */ public void mapLocalToNtp(long ssrc, long localTime, double ntpTime) { SSRCDesc ssrcDesc = getSSRCDesc(ssrc); if (localTime != -1 && ntpTime != -1.0 && ssrcDesc.endpointId != null) { Endpoint endpoint = getEndpoint(ssrcDesc.endpointId); if (endpoint.localTime == -1 || endpoint.ntpTime == -1.0) { synchronized (endpoint) { if (endpoint.localTime == -1 || endpoint.ntpTime == -1.0) { endpoint.localTime = localTime; endpoint.ntpTime = ntpTime; } } } } }
/** * Sends a POST request with a file and returns the response. * * @param endpoint The endpoint to send the request to. * @param file The file to upload * @param responseClass The class to deserialise the Json response to. Can be null if no response * message is expected. * @param fields Any name-value pairs to serialise * @param <T> The type to deserialise the response to. * @return A {@link Response} containing the deserialised body, if any. * @throws IOException If an error occurs. * @see MultipartEntityBuilder */ public <T> Response<T> post( Endpoint endpoint, File file, Class<T> responseClass, NameValuePair... fields) throws IOException { if (file == null) { return post(endpoint, responseClass, fields); } // deal with null case // Create the request HttpPost post = new HttpPost(endpoint.url()); post.setHeaders(combineHeaders()); // Add fields as text pairs MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create(); for (NameValuePair field : fields) { multipartEntityBuilder.addTextBody(field.getName(), field.getValue()); } // Add file as binary FileBody bin = new FileBody(file); multipartEntityBuilder.addPart("file", bin); // Set the body post.setEntity(multipartEntityBuilder.build()); // Send the request and process the response try (CloseableHttpResponse response = httpClient().execute(post)) { T body = deserialiseResponseMessage(response, responseClass); return new Response<>(response.getStatusLine(), body); } }
/** * Sends a POST request with a file and returns the response. * * @param endpoint The endpoint to send the request to. * @param file The file to upload * @param responseClass The class to deserialise the Json response to. Can be null if no response * message is expected. * @param <T> The type to deserialise the response to. * @return A {@link Response} containing the deserialised body, if any. * @throws IOException If an error occurs. * @see MultipartEntityBuilder */ private <T> Response<T> post(Endpoint endpoint, File file, Class<T> responseClass) throws IOException { if (file == null) { return post(endpoint, responseClass); } // deal with null case // Create the request HttpPost post = new HttpPost(endpoint.url()); post.setHeaders(combineHeaders()); // Add fields as text pairs MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create(); // Add file as binary FileBody fileBody = new FileBody(file); multipartEntityBuilder.addPart("file", fileBody); // Set the body post.setEntity(multipartEntityBuilder.build()); // Send the request and process the response try (CloseableHttpResponse response = httpClient().execute(post)) { if (String.class.isAssignableFrom(responseClass)) { String body = getResponseString(response); return new Response(response.getStatusLine(), body); } else { T body = deserialiseResponseMessage(response, responseClass); return new Response<>(response.getStatusLine(), body); } } }
/** * Sends a GET request and returns the response. * * @param endpoint The endpoint to send the request to. * @param headers Any additional headers to send with this request. You can use {@link * org.apache.http.HttpHeaders} constants for header names. * @return A {@link Path} to the downloaded content, if any. * @throws IOException If an error occurs. * @see java.nio.file.Files#probeContentType(Path) */ public Response<Path> get(Endpoint endpoint, NameValuePair... headers) throws IOException { // Create the request HttpGet get = new HttpGet(endpoint.url()); get.setHeaders(combineHeaders(headers)); Path tempFile = null; // Send the request and process the response try (CloseableHttpResponse response = httpClient().execute(get)) { if (response.getStatusLine().getStatusCode() != HttpStatus.OK_200) { return null; } // If bad response return null // Request the content HttpEntity entity = response.getEntity(); // Download the content to a temporary file if (entity != null) { tempFile = Files.createTempFile("download", "file"); try (InputStream input = entity.getContent(); OutputStream output = Files.newOutputStream(tempFile)) { IOUtils.copy(input, output); } } return new Response<>(response.getStatusLine(), tempFile); } }
public void testEntity() throws Exception { int port = PortAllocator.getFreePort(); String address = "http://localhost:" + port + "/entity"; Endpoint endpoint = Endpoint.create(new MyEndpoint()); endpoint.publish(address); try { HTTPResponseInfo rInfo = sendEntity(address); String resp = rInfo.getResponseBody(); if (resp.contains("x1y1")) { fail("Entity is getting resolved"); } int code = rInfo.getResponseCode(); assertEquals(HttpURLConnection.HTTP_INTERNAL_ERROR, code); } finally { endpoint.stop(); } }