I have two files server.java and client.java. Basically there is no error or message like Client Connected, Connected to server, Message:..., etc.
But if i change localhost to something else client.java does give an error but if it's correct no error or response.
server.java has this:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.ArrayList;
import javax.json.Json;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import org.glassfish.tyrus.server.*;
#ServerEndpoint("/game")
public class socketServer{
public static void main(String[] args) {
new socketServer();
}
public socketServer() {
runServer();
}
public static void runServer() {
Server s = new Server("localhost", 8025, "/websockets", null, socketServer.class);
try {
s.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
#OnMessage
public String onMessage(String message, Session s) throws IOException {
System.out.println("User input: " + message);
s.getBasicRemote().sendText("Hello world Mr. " + message);
return message;
}
#OnOpen
public void onOpen(Session s) throws IOException {
System.out.println("Client connected");
s.getBasicRemote().sendText("wtf");
}
#OnClose
public void onClose() {System.out.println("Connection closed");}
#OnError
public void handleError(Throwable t) {t.printStackTrace();}
}
client.java has this:
import java.net.URI;
import java.net.URISyntaxException;
import javax.websocket.CloseReason;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.ClientEndpoint;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.DeploymentException;
import org.glassfish.tyrus.client.ClientManager;
#ClientEndpoint
public class clientServer {
public static void main(String[] args) {
new clientServer();
}
public clientServer() {
ClientManager client = ClientManager.createClient();
try {
client.connectToServer(clientServer.class, new URI("ws://localhost:8025/websockets/game"));
} catch (Exception e) {
e.printStackTrace();
}
}
#OnOpen
public void onOpen(Session session) {
System.out.println("connected to server");
try {
session.getBasicRemote().sendText("start");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
#OnMessage
public String onMessage(String message, Session session) {
return message;
}
#OnClose
public void onClose(Session session, CloseReason closeReason) {
System.out.println("Client: closed");
}
}
I guess server.java and client.java have to use the same host name. If you change the URI in client.java, for example, from "ws://localhost:8025/websockets/game" to "ws://myhost:8025/websockets/game", try to change the first argument of the constructor of Server from "localhost" to "myhost".
Related
I'm new to Docker and I would like to put my rmi server on docker and to access it using the client which is local, on the laptop. When the server is not on docker the application works, however when it is on docker, I get a "Connection Refused" error. Below is the code for the server:
import org.modelmapper.ModelMapper;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.validation.annotation.Validated;
import ro.tuc.ds2020.services.MedicationPlanService;
import ro.tuc.ds2020.servinterface.IMedicationService;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.*;
#SpringBootApplication
#Validated
public class Ds2020Application extends SpringBootServletInitializer {
private int port;
// private Registry registry;
#Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Ds2020Application.class);
}
public Ds2020Application() throws RemoteException{
this.port = 8889;
Registry registry = null;
try {
registry = LocateRegistry.createRegistry(this.port);
} catch (RemoteException e) {
e.printStackTrace();
}
try {
//MedicationPlanService is the stub // "name",stub
registry.bind(IMedicationService.class.getSimpleName(), new MedicationPlanService());
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
try {
SpringApplication.run(Ds2020Application.class, args);
System.out.println("The server has started.");
} catch (Exception e) {
e.printStackTrace();
}
}
#Bean
public ModelMapper modelMapper() {
return new ModelMapper();
}
}
and client:
package ro.tuc.ds2020.controller;
import ro.tuc.ds2020.DTO.DrugPlanDTO;
import ro.tuc.ds2020.servinterface.IMedicationService;
import ro.tuc.ds2020.view.DisplayTable;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.sql.SQLException;
import java.text.ParseException;
import java.util.ArrayList;
public class ClientController {
private static IMedicationService iMedicationService;
private Registry registry;
private String serverAddress;
private int serverPort;
private DisplayTable displayTable;
public ClientController() throws RemoteException, NotBoundException, SQLException, ParseException {
this.serverAddress = "localhost";
this.serverPort = 8889;
String patientID="334975ea-c90d-4fd2-9a0b-9e2c9f0e4cb9";
//obtain the stub for the registry
registry = LocateRegistry.getRegistry(serverAddress, serverPort);
//obtain stub for remote object from server registry
iMedicationService = (IMedicationService) (registry.lookup(IMedicationService.class.getSimpleName()));
ArrayList<DrugPlanDTO> dto= iMedicationService.getAllMedicationPlans(patientID);
for (DrugPlanDTO drugplans:
dto) {
System.out.println((String)drugplans.getBegin_time());
}
this.displayTable=new DisplayTable(dto,patientID);
System.out.println("Finished");
}
public static void sendMessage(String drugPlanID,String patientID,String medicationName,String begin_time,String end_time) throws RemoteException, SQLException {
if (iMedicationService != null) {
iMedicationService.savePillTakenLog(drugPlanID,patientID,medicationName,begin_time,end_time);
System.out.println("Finished send message"+ patientID);
}
}
}
Im not sure how to bind the client to the server when dockerizing the application.
Docker compose:
version: '3'
services:
tomcat-db-api:
image: ds_a3
ports:
- "8889:8889"
rabbitmq-container:
image: rabbitmq:management
ports:
- 5672:5672
- 15672:15672
Try setting the: this.serverAddress="tomcat-db-api;" at your client.
I am getting nullpointer exception on Connecting to a secured websocket.
PFB the exception:
Exception in thread "main" java.lang.NullPointerException
at org.eclipse.jetty.websocket.common.extensions.AbstractExtension.getName(AbstractExtension.java:90)
at org.eclipse.jetty.websocket.api.extensions.ExtensionFactory.<init>(ExtensionFactory.java:37)
at org.eclipse.jetty.websocket.common.extensions.WebSocketExtensionFactory.<init>(WebSocketExtensionFactory.java:40)
at org.eclipse.jetty.websocket.client.WebSocketClient.<init>(WebSocketClient.java:90)
at com.service.SecureClientSocket.main(SecureClientSocket.java:26)
PFB my code:
package com.service;
import java.net.URI;
import java.util.concurrent.Future;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;
import org.eclipse.jetty.websocket.client.WebSocketClient;
#WebSocket
public class SecureClientSocket {
public static void main(String []args){
String url = "wss://qa.sockets.stackexchange.com/";
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setTrustAll(true); // The magic
WebSocketClient client = new WebSocketClient(sslContextFactory);
try
{
client.start();
SecureClientSocket socket = new SecureClientSocket();
Future<Session> fut = client.connect(socket,URI.create(url));
Session session = fut.get();
session.getRemote().sendString("Hello");
session.getRemote().sendString("155-questions-active");
}
catch (Throwable t)
{
System.out.println(t.getMessage());
}
}
#OnWebSocketConnect
public void onConnect(Session sess)
{
System.out.println("onConnect({})"+sess);
}
#OnWebSocketClose
public void onClose(int statusCode, String reason)
{
System.out.println("onClose({}, {})"+ statusCode+ reason);
}
#OnWebSocketError
public void onError(Throwable cause)
{
System.out.println(cause);
}
#OnWebSocketMessage
public void onMessage(String msg)
{
System.out.println("onMessage() - {}"+ msg);
}
}
I have a requirement to read a file from a folder and place it on a queue.
Here is the code I have:
import java.io.File;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.LoggingLevel;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
public class FileMove{
public static void main(final String[] arguments) {
final CamelContext camelContext = new DefaultCamelContext();
try {
camelContext.addRoutes(new RouteBuilder() {
#Override
public void configure() throws Exception {
from("file://E:/TestingWatch1/input?preMove=staging&move=.completed&scheduler=quartz2&scheduler.cron=00+*/1+*+1/1+*+?+*")
.routeId("testRoute").process(new Processor() {
#Override
public void process(Exchange msg) throws Exception {
File file = msg.getIn().getBody(File.class);
String file1 = msg.getIn().getBody(String.class);
System.out.println("" + file + file1);
}
}).
to("file://E:/TestingWatch1/output");
}
});
camelContext.start();
// Thread.sleep(10*60*1000);
// camelContext.stop();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
I am able to read the file and file contents, but I need to place it on the queue.
How do I move the file or file contents to queue using the Java DSL?
Thanks, I found the solution: Here is the code
import java.io.File;
import javax.jms.ConnectionFactory;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.LoggingLevel;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.jms.JmsComponent;
import org.apache.camel.impl.DefaultCamelContext;
public class CopyTest {
public static void main(final String[] arguments) {
final CamelContext camelContext = new DefaultCamelContext();
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("admin", "admin",
ActiveMQConnection.DEFAULT_BROKER_URL);
camelContext.addComponent("test-jms", JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));
try {
camelContext.addRoutes(new RouteBuilder() {
#Override
public void configure() throws Exception {
from("file://E:/TestingWatch1/input?preMove=staging&move=.completed&scheduler=quartz2&scheduler.cron=00+*/1+*+1/1+*+?+*")
.routeId("testRoute").process(new Processor() {
#Override
public void process(Exchange msg) throws Exception {
File file = msg.getIn().getBody(File.class);
String file1 = msg.getIn().getBody(String.class);
System.out.println("" + file + file1);
}
}).to("test-jms:queue:testMQDestination").
to("file://E:/TestingWatch1/output");
}
});
camelContext.start();
// Thread.sleep(10*60*1000);
// camelContext.stop();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
Here's my server's code
package local.xx.mavenws;
import java.io.IOException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import javax.enterprise.context.ApplicationScoped;
import org.joda.time.DateTime;
#ApplicationScoped
#ServerEndpoint("/")
public class Server {
private final ArrayList<Session> sessions;
public Server() {
this.sessions = new ArrayList<>();
}
#OnOpen
public void onOpen(Session session) {
this.sessions.add(session);
this.echo("Client connected!");
}
#OnClose
public void onClose(Session session) {
this.sessions.remove(session);
this.echo("Client disconnected!");
}
#OnError
public void onError(Throwable error) {
this.echo("Error occured!");
this.echo(error.getLocalizedMessage());
}
#OnMessage
public void onMessage(String message, Session session) {
try {
message = "[" + this.currentDate() + "] " + message;
this.echo(message);
for( Session sess : this.sessions ) {
sess.getBasicRemote().sendText(message);
}
} catch (IOException ex) {
Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void echo(String info) {
System.out.println(info);
}
private String currentDate() {
String dateArray[] = (new DateTime()).toString().split("T");
String date = dateArray[0] + " " + (dateArray[1].split("\\.")[0]);
return date;
}
}
I want it to send received message to all the users connected. The problem is, it treats every connection individually like each one of them had it's own instance of the server. When I connect in two browser windows, messages show separately. Does anybody have any ideas on this?
Finally got this working! The solution is that the sessions variable must be static and I had to call it always by Server scope, not this. That implicates the fact that, despite there's a new instance of Server created for every user connected, the variable is mutual for everyone.
I've played a bit with netty and followed a video(https://www.youtube.com/watch?v=tsz-assb1X8) to build a chat server and client the server works properly(I tested with telnet and here it works) but the client does not recives data. The channelRead method in ChatClinetHandler.java were never called but the channelReadComplete were called.
ChatClient.java
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ChatClient {
public static void main(String args[]) {
try {
new ChatClient(new InetSocketAddress("localhost", 8000)).run();
} catch (Exception ex) {
Logger.getLogger(ChatClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
private final InetSocketAddress server;
public ChatClient(InetSocketAddress server) {
this.server = server;
}
public void run() throws Exception {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap()
.group(group)
.channel(NioSocketChannel.class)
.handler(new ChatClientInitializer());
Channel channel = bootstrap.connect(server).sync().channel();
System.out.println("Connected to Server: " + server.toString());
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
while (channel.isActive()) {
String userMessage = in.readLine();
channel.writeAndFlush(userMessage + "\r\n");
if (userMessage.equalsIgnoreCase("bye")) {
group.shutdownGracefully();
break;
}
}
} finally {
group.shutdownGracefully();
}
}
}
ChatClientInitializer.java
import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.socket.SocketChannel; import io.netty.handler.codec.DelimiterBasedFrameDecoder; import io.netty.handler.codec.Delimiters; import io.netty.handler.codec.string.StringDecoder; import io.netty.handler.codec.string.StringEncoder;
public class ChatClientInitializer extends ChannelInitializer<SocketChannel> {
#Override
protected void initChannel(SocketChannel c) throws Exception {
ChannelPipeline pipeline = c.pipeline();
pipeline.addLast(new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
pipeline.addLast(new ChatClientHandler());
} }
ChatClinetHandler.java
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
public class ChatClientHandler extends ChannelInboundHandlerAdapter {
#Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println(msg.toString());
}
#Override
public void exceptionCaught(ChannelHandlerContext ctx,
Throwable cause) {
cause.printStackTrace();
}
}
Sorry my mistake i forgot to send "\r\n" with each message.
Although shim_ claims to have determined that the problem is not sending "\r\n" with each message, I see the need to provide a clarification here.
In ChatClientInitializer.java you see a handler named framer which is a DelimiterBasedFrameDecoder object with a line delimiter in that specific example (More info on DelimiterBasedFrameDecoder can be found here).
So, that means the client is expecting messages that ends with "\r\n" on that specific channel. If a message not ending with "\r\n" is received, then the channelRead() method will not be provoked.