Discussion :

[Invité1]

Bonjour les amis,

C'est très simple...
MAIN:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
   public static void main(String[] args) {
        // Give the Thread we are running on a name for debuggers.
    	t.setName(Main.class.getName() + ".main()");
 
    	try {       
	        t.suspend();
			new Interface().setVisible(true);
 
	        if (blabla){
	        	 server = new PropagatedPipeServer(manager);
	        	 client = new PropagatedPipeClient(manager);
	        }
 
    	} catch (Throwable all) {
            // Something bad happened, print out the failure and quit.
            System.err.println("Uncaught Throwable in main() :");
            all.printStackTrace(System.err);
            System.exit(1);
    	}
    }

Sauf que mon server et mon client ils se lancent jamais en même temps... Le problem c'est que j'ai un wait() dans le server et du coup l'instruction s'arrête au wait() normal...

SERVEUR:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
public class PropagatedPipeServer implements PipeMsgListener {
 
    public PropagatedPipeServer(PeerGroup p) {
        routeAdvElement = null;
        netPeerGroup = p;
        build();
    }
 
    /**
     * Keep running, avoids existing
     */
    private static void waitForever() {
        try {
            System.out.println("Waiting for Messages.");
            synchronized (completeLock) {
                completeLock.wait();
            }
            System.out.println("Done.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public static void build() {
 
        System.out.println("Creating Propagated InputPipe for " + pipeAdv.getPipeID());
        try {
            inputPipe = pipeService.createInputPipe(pipeAdv, app.main.Main.server);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(-1);
        }
        waitForever();
        inputPipe.close();
    }
}

CLIENT:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
public class PropagatedPipeClient implements PipeMsgListener {
 
    public PropagatedPipeClient(PeerGroup p) {
        netPeerGroup = p;
        build();
    }
 
    public static void build() {
        PipeAdvertisement pipeAdv = PropagatedPipeServer.getPipeAdvertisement();
        PipeService pipeService = netPeerGroup.getPipeService();
 
        System.out.println("Creating Propagated InputPipe for " + pipeAdv.getPipeID());
        try {
            client.inputPipe = pipeService.createInputPipe(pipeAdv, client);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(-1);
        }
        MessageTransport endpointRouter = (netPeerGroup.getEndpointService()).getMessageTransport("jxta");
 
        if (endpointRouter != null) {
            client.routeControl = (RouteControl) endpointRouter.transportControl(EndpointRouter.GET_ROUTE_CONTROL, null);
            RouteAdvertisement route = client.routeControl.getMyLocalRoute();
 
            if (route != null) {
                client.routeAdvElement = new TextDocumentMessageElement(ROUTEADV, (XMLDocument) route.getDocument(MimeMediaType.XMLUTF8), null);
            }
        }
 
        System.out.println("Creating Propagated OutputPipe for " + pipeAdv.getPipeID());
        OutputPipe output = null;
 
        try {
            output = pipeService.createOutputPipe(pipeAdv, 1);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(-1);
        }
        int i = 0;
 
        try {
            while (i < 10000000) {
                Message ping = new Message();
                ping.addMessageElement(PropagatedPipeServer.NAMESPACE,
                        new StringMessageElement(PropagatedPipeServer.SRCIDTAG, netPeerGroup.getPeerID().toString(), null));
                ping.addMessageElement(PropagatedPipeServer.NAMESPACE,
                        new StringMessageElement(PropagatedPipeServer.SRCNAMETAG, netPeerGroup.getPeerName() + " #" + i++, null));
                if (client.routeAdvElement != null && client.routeControl != null) {
                    ping.addMessageElement(PropagatedPipeServer.NAMESPACE, client.routeAdvElement);
                }
 
                System.out.println("Sending message :" + (i - 1));
                boolean sucess = output.send(ping);
                System.out.println("Send oing message status :"+sucess);
            }
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

J'ai simplifié le code du mieux que j'ai pu.
Merci.

[dinobogan]

Ton serveur et ton client doivent utiliser ou être des Thread (extends Thread ou implements Runnable, à toi de voir). Ils s'exécuteront ainsi tous les deux en parallèles. Le Thread principal de ton appli va continuer de s'exécuter.

[Invité1]

Du feu de dieu ça marche!