import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
public EventServlet(LeshanServer server, int securePort) {
    server.getRegistrationService().addListener(this.registrationListener);
    server.getObservationService().addListener(this.observationListener);

    // add an interceptor to each endpoint to trace all CoAP messages
    coapMessageTracer = new CoapMessageTracer(server.getRegistrationService());
    for (Endpoint endpoint : server.getCoapServer().getEndpoints()) {
        endpoint.addInterceptor(coapMessageTracer);
    }

    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeHierarchyAdapter(Registration.class, new RegistrationSerializer(securePort));
    gsonBuilder.registerTypeHierarchyAdapter(LwM2mNode.class, new LwM2mNodeSerializer());
    gsonBuilder.setDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    this.gson = gsonBuilder.create();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Returns the effective endpoint that the specified request is supposed to
 * be sent over. If an endpoint has explicitly been set to this CoapClient,
 * this endpoint will be used. If no endpoint has been set, the client will
 * effectively use a default endpoint of the {@link EndpointManager}.
 * 
 * @param request the request to be sent
 * @return the effective endpoint that the request is going o be sent over.
 */
protected Endpoint getEffectiveEndpoint(Request request) {
	Endpoint myEndpoint = getEndpoint();
	
	// custom endpoint
	if (myEndpoint != null) return myEndpoint;
	
	// default endpoints
	if (CoAP.COAP_SECURE_URI_SCHEME.equals(request.getScheme())) {
		// this is the case when secure coap is supposed to be used
		return EndpointManager.getEndpointManager().getDefaultSecureEndpoint();
	} else {
		// this is the normal case
		return EndpointManager.getEndpointManager().getDefaultEndpoint();
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Sets the endpoint this client is supposed to use.
 *
 * @param endpoint the endpoint
 * @return the CoAP client
 */
public CoapClient setEndpoint(Endpoint endpoint) {
			
	this.endpoint = endpoint;
	
	if (!endpoint.isStarted()) {
		try {
			endpoint.start();
			LOGGER.log(Level.INFO, "Started set client endpoint " + endpoint.getAddress());
		} catch (IOException e) {
			LOGGER.log(Level.SEVERE, "Could not set and start client endpoint", e);
		}
		
	}
	
	return this;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
public EventServlet(LeshanServer server, int securePort) {
    this.server = server;
    server.getClientRegistry().addListener(this.clientRegistryListener);
    server.getObservationRegistry().addListener(this.observationRegistryListener);

    // add an interceptor to each endpoint to trace all CoAP messages
    coapMessageTracer = new CoapMessageTracer(server.getClientRegistry());
    for (Endpoint endpoint : server.getCoapServer().getEndpoints()) {
        endpoint.addInterceptor(coapMessageTracer);
    }

    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeHierarchyAdapter(Client.class, new ClientSerializer(securePort));
    gsonBuilder.registerTypeHierarchyAdapter(LwM2mNode.class, new LwM2mNodeSerializer());
    gsonBuilder.setDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    this.gson = gsonBuilder.create();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Creates a new AllInterfacesCoapServer which listens on all available IP addresses.
 */
public AllInterfacesCoapServer() {
	addEndpoints();
	start();

	String interfaces = getEndpoints().stream().
			map(Endpoint::getAddress).
			map(a -> "[" + a.getHostString() + ":" + a.getPort() + "]")
			.collect(Collectors.joining(", "));


	logger.info("DCAF server running on " + interfaces + ".");
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
private CoapResponse synchronous(Request request, Endpoint outEndpoint) {
	try {
		Response response = send(request, outEndpoint).waitForResponse(getTimeout());
		if (response == null) return null;
		else return new CoapResponse(response);
	} catch (InterruptedException e) {
		throw new RuntimeException(e);
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
private CoapObserveRelation observeAndWait(Request request, CoapHandler handler) {
	Endpoint outEndpoint = getEffectiveEndpoint(request);
	CoapObserveRelation relation = new CoapObserveRelation(request, outEndpoint);
	request.addMessageObserver(new ObserveMessageObserverImpl(handler, relation));
	CoapResponse response = synchronous(request, outEndpoint);
	if (response == null || !response.advanced().getOptions().hasObserve())
		relation.setCanceled(true);
	relation.setCurrent(response);
	return relation;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
private CoapObserveRelation observe(Request request, CoapHandler handler) {
	Endpoint outEndpoint = getEffectiveEndpoint(request);
	CoapObserveRelation relation = new CoapObserveRelation(request, outEndpoint);
	request.addMessageObserver(new ObserveMessageObserverImpl(handler, relation));
	send(request, outEndpoint);
	return relation;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Sends the specified request over the specified endpoint.
 * 
 * @param request the request
 * @param outEndpoint the endpoint
 * @return the request
 */
protected Request send(Request request, Endpoint outEndpoint) {
	// use the specified message type
	request.setType(this.type);

	if (blockwise!=0) {
		request.getOptions().setBlock2(new BlockOption(BlockOption.size2Szx(this.blockwise), false, 0));
	}
	
	outEndpoint.sendRequest(request);
	return request;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Constructs a server with the specified configuration that listens to the
 * specified ports after method {@link #start()} is called.
 *
 * @param config the configuration, if <code>null</code> the configuration returned by
 * {@link NetworkConfig#getStandard()} is used.
 * @param ports the ports to bind to
 */
public CoapServer(NetworkConfig config, int... ports) {
	
	// global configuration that is passed down (can be observed for changes)
	if (config != null) {
		this.config = config;
	} else {
		this.config = NetworkConfig.getStandard();
	}
	
	// resources
	this.root = createRoot();
	this.deliverer = new ServerMessageDeliverer(root);
	
	CoapResource well_known = new CoapResource(".well-known");
	well_known.setVisible(false);
	well_known.add(new DiscoveryResource(root));
	root.add(well_known);
	
	// endpoints
	this.endpoints = new ArrayList<Endpoint>();
	// sets the central thread pool for the protocol stage over all endpoints
	this.executor = Executors.newScheduledThreadPool( config.getInt(NetworkConfig.Keys.PROTOCOL_STAGE_THREAD_COUNT) );
	// create endpoint for each port
	for (int port:ports)
		addEndpoint(new CoapEndpoint(port, this.config));
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
public void setExecutor(ScheduledExecutorService executor) {
	
	if (this.executor!=null) this.executor.shutdown();
	
	this.executor = executor;
	for (Endpoint ep:endpoints)
		ep.setExecutor(executor);
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Starts the server by starting all endpoints this server is assigned to.
 * Each endpoint binds to its port. If no endpoint is assigned to the
 * server, an endpoint is started on the port defined in the config.
 */
@Override
public void start() {
	
	LOGGER.info("Starting server");
	
	if (endpoints.isEmpty()) {
		// servers should bind to the configured port (while clients should use an ephemeral port through the default endpoint)
		int port = config.getInt(NetworkConfig.Keys.COAP_PORT);
		LOGGER.info("No endpoints have been defined for server, setting up server endpoint on default port " + port);
		addEndpoint(new CoapEndpoint(port, this.config));
	}
	
	int started = 0;
	for (Endpoint ep:endpoints) {
		try {
			ep.start();
			// only reached on success
			++started;
		} catch (IOException e) {
			LOGGER.severe(e.getMessage() + " at " + ep.getAddress());
		}
	}
	if (started==0) {
		throw new IllegalStateException("None of the server endpoints could be started");
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Stops the server, i.e., unbinds it from all ports. Frees as much system
 * resources as possible to still be able to be re-started with the previous binds.
 */
@Override
public void stop() {
	LOGGER.info("Stopping server");
	for (Endpoint ep:endpoints)
		ep.stop();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Destroys the server, i.e., unbinds from all ports and frees all system resources.
 */
@Override
public void destroy() {
	LOGGER.info("Destroy server");
	for (Endpoint ep:endpoints)
		ep.destroy();
	executor.shutdown(); // cannot be started again
	try {
		boolean succ = executor.awaitTermination(5, TimeUnit.SECONDS);
		if (!succ)
			LOGGER.warning("Server executor did not shutdown in time");
	} catch (InterruptedException e) {
		LOGGER.log(Level.WARNING, "Exception while terminating server executor", e);
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Returns the endpoint with a specific port.
 * @param port the port
 * @return the endpoint 
 */
@Override
public Endpoint getEndpoint(int port) {
	Endpoint endpoint = null;

	for (Endpoint ep : endpoints) {
		if (ep.getAddress().getPort() == port) {
			endpoint = ep;
		}
	}
	return endpoint;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * @param endpoints the CoAP endpoints to use for sending requests
 * @param observationService the service for keeping track of observed resources
 * @param modelProvider provides the supported objects definitions
 */
public CaliforniumLwM2mRequestSender(Set<Endpoint> endpoints, ObservationServiceImpl observationService,
        LwM2mModelProvider modelProvider, LwM2mNodeEncoder encoder, LwM2mNodeDecoder decoder) {
    Validate.notNull(endpoints);
    Validate.notNull(observationService);
    Validate.notNull(modelProvider);
    this.observationService = observationService;
    this.endpoints = endpoints;
    this.modelProvider = modelProvider;
    this.encoder = encoder;
    this.decoder = decoder;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
@Override
public <T extends LwM2mResponse> T send(final Registration destination, final DownlinkRequest<T> request,
        long timeout) throws InterruptedException {

    // Retrieve the objects definition
    final LwM2mModel model = modelProvider.getObjectModel(destination);

    // Create the CoAP request from LwM2m request
    CoapRequestBuilder coapRequestBuilder = new CoapRequestBuilder(destination.getIdentity(), destination.getRootPath(),
            destination.getId(), destination.getEndpoint(), model, encoder);
    request.accept(coapRequestBuilder);
    final Request coapRequest = coapRequestBuilder.getRequest();

    // Send CoAP request synchronously
    SyncRequestObserver<T> syncMessageObserver = new SyncRequestObserver<T>(coapRequest, timeout) {
        @Override
        public T buildResponse(Response coapResponse) {
            // Build LwM2m response
            LwM2mResponseBuilder<T> lwm2mResponseBuilder = new LwM2mResponseBuilder<>(coapRequest, coapResponse,
                    destination, model, observationService, decoder);
            request.accept(lwm2mResponseBuilder);
            return lwm2mResponseBuilder.getResponse();
        }
    };
    coapRequest.addMessageObserver(syncMessageObserver);

    // Store pending request to cancel it on de-registration
    addPendingRequest(destination.getId(), coapRequest);

    // Send CoAP request asynchronously
    Endpoint endpoint = getEndpointForClient(destination);
    endpoint.sendRequest(coapRequest);

    // Wait for response, then return it
    return syncMessageObserver.waitForResponse();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Gets the CoAP endpoint that should be used to communicate with a given client.
 *
 * @param registration the client
 * @return the CoAP endpoint bound to the same network address and port that the client connected to during
 *         registration. If no such CoAP endpoint is available, the first CoAP endpoint from the list of registered
 *         endpoints is returned
 */
private Endpoint getEndpointForClient(Registration registration) {
    for (Endpoint ep : endpoints) {
        InetSocketAddress endpointAddress = ep.getAddress();
        if (endpointAddress.equals(registration.getRegistrationEndpointAddress())) {
            return ep;
        }
    }
    throw new IllegalStateException(
            "can't find the client endpoint for address : " + registration.getRegistrationEndpointAddress());
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
@Test
public void register_with_additional_attributes() throws InterruptedException {
    // Check registration
    helper.assertClientNotRegisterered();

    // HACK to be able to send a Registration request with additional attributes
    LeshanClient lclient = helper.client;
    lclient.getCoapServer().start();
    Endpoint secureEndpoint = lclient.getCoapServer().getEndpoint(lclient.getSecuredAddress());
    Endpoint nonSecureEndpoint = lclient.getCoapServer().getEndpoint(lclient.getUnsecuredAddress());
    CaliforniumLwM2mRequestSender sender = new CaliforniumLwM2mRequestSender(secureEndpoint, nonSecureEndpoint);

    // Create Request with additional attributes
    Map<String, String> additionalAttributes = new HashMap<>();
    additionalAttributes.put("key1", "value1");
    additionalAttributes.put("imei", "2136872368");
    Link[] objectLinks = Link.parse("</>;rt=\"oma.lwm2m\",</1/0>,</2>,</3/0>".getBytes());
    RegisterRequest registerRequest = new RegisterRequest(helper.getCurrentEndpoint(), null, null, null, null,
            objectLinks, additionalAttributes);

    // Send request
    RegisterResponse resp = sender.send(helper.server.getUnsecuredAddress(), false, registerRequest, 5000l);
    helper.waitForRegistration(1);

    // Check we are registered with the expected attributes
    helper.assertClientRegisterered();
    assertNotNull(helper.last_registration);
    assertEquals(additionalAttributes, helper.last_registration.getAdditionalRegistrationAttributes());
    assertArrayEquals(Link.parse("</>;rt=\"oma.lwm2m\",</1/0>,</2>,</3/0>".getBytes()),
            helper.getCurrentRegistration().getObjectLinks());

    sender.send(helper.server.getUnsecuredAddress(), false, new DeregisterRequest(resp.getRegistrationID()), 5000l);
    lclient.getCoapServer().stop();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Create a CoapClient associated with the current server
 *
 * @return
 */
private CoapClient createClient() {
	CoapClient client = new CoapClient();
	List<Endpoint> endpoints = server.getEndpoints();
	client.setExecutor(server.getRoot().getExecutor());
	if (!endpoints.isEmpty()) {
		Endpoint ep = endpoints.get(0);
		client.setEndpoint(ep);
	}
	return client;
}