IPC tra processo C e processo JAVA

[topix93]

Quello che ho bisogno di realizzare è un canale di comunicazione tra un processo scritto in c ed un processo scritto in java. Sto cercando il metodo piu performante per ottenere ciò e mi sono imbattuto in questo articolo: http://homes.cs.ru.ac.za/csgw/Resear...sPDPTA2009.pdf che mostra al fondo un grafico "prestazionale" dei vari metodi per la comunicazione tra processi. Il piu veloce pare che sia il metodo delle Named Pipes (detto anche FIFO).
Con questo metodo volevo fare in modo che:
- Il processo C crea la named pipe;
- Il processo JAVA si mette in ascolto/lettura;
- Il processo C scrive dei dati sulla named pipe;
- il processo JAVA legge i dati;
- il processo C riscrive altri dati... ed il processo si ripete

E possibile fare una cosa di questo tipo?

[Vincenzo1968]

Non conosco bene Java ma se con tale linguaggio puoi utilizzare le named pipe si può fare benissimo.

Attendiamo qualcuno che conosce bene Java(ma intanto googlo un attimino ).

Edit: googlato. Sembrerebbe che si possa fare:

http://stackoverflow.com/questions/4...d-c-c-programs

You can simply start an external process in Java and connect to it's pipes.

// Execute command
String command = "ls";
Process child = Runtime.getRuntime().exec(command);

// Get pipes from process
InputStream in = child.getInputStream();
OutputStream out = child.getOutputStream();
InputStream error = child.getErrorStream();

Ariedit:
un po' più sotto, l'osservazione di un altro utente:

although i find your proposed solution quite usable, what you are describing are not named pipes. named pipes have to be addressable from the outside (in case of *nix systems through the file system).

[topix93]

Quello che hai trovato tu non sono named pipe ma sono bensì pipe la differenza sta nel fatto che le pipe possono essere utilizzate solo se due processi hanno un "antenato" comune...

Non ho ancora avuto l'occasione di provare l'esempio che hai messo tu ma se dovesse funzionare bene potrei anche adottare quel metodo.

il problema piu che altro è che su internet non si trovano molti esempi e quindi non so esattamente come si fa a implementare questa cosa.

cio che voglio fare è lasciare a java la gestione dell'interfaccia grafica e affidare al c i compiti piu pesanti... per fare cio pero ho bisogno di una comunicazione bidirezionale per inviare comandi e ricevere i dati

spero di essermi spiegato

[pabloski]

named pipes o sockets, sono queste le scelte più gettonate

[VICIUS]

Per quanto riguarda java non servono classi speciali. Basta che apri la pipe con un Input/OutputStream e ci puoi fare quello che vuoi. Per crearle da codice però non ti saprei aiutare. Quelle poche volte che le ho usate ho sempre fatto da terminale con mkfifo.

[Vincenzo1968]

Forse ho trovato qualcosa:

http://ubuntuforums.org/showthread.php?t=372505

http://v01ver-howto.blogspot.it/2010...mmunicate.html

Il client in Java proposto nel link precedente:

Java: Echo client

 try {
 // Connect to the pipe
 RandomAccessFile pipe = new RandomAccessFile("\\\\.\\pipe\\testpipe", "rw");
 String echoText = "Hello word\n";
 // write to pipe
 pipe.write ( echoText.getBytes() );
 // read response
 String echoResponse = pipe.readLine();
 System.out.println("Response: " + echoResponse );
 pipe.close();

 } catch (Exception e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }

http://magdalena.thedarkmere.net/~be...Pipe.java.html

[topix93]

Sono riuscito a fare comunicare i due processi attraverso le named pipe... ma ora mi viene un dubbio...

Se il processo C scrive una linea e il processo JAVA la legge, e diciamo che questo processo continua all'infinito, è possibile che i due processi si disincronizzino?

Un'altra cosa, dato che questo processo dovra ciclare all'infinito ci può essere qualche problema? Dato che le named pipe sono come dei file è possibile che dopo un po raggiungano una dimensione molto alta?

[VICIUS]

Originariamente inviato da topix93

Sono riuscito a fare comunicare i due processi attraverso le named pipe... ma ora mi viene un dubbio...

Se il processo C scrive una linea e il processo JAVA la legge, e diciamo che questo processo continua all'infinito, è possibile che i due processi si disincronizzino?

Un'altra cosa, dato che questo processo dovra ciclare all'infinito ci può essere qualche problema? Dato che le named pipe sono come dei file è possibile che dopo un po raggiungano una dimensione molto alta?

Lettura e scrittura da e su una pipe sono operazioni bloccanti. Se java prova a leggere qualcosa dalla pipe ma non c'è niente la read rimane in attesa all'infinito. Stessa cosa per le scritture. Se il programma C prova a scrivere su una pipe piena da cui nessuno legge questa rimane bloccata finché qualcuno non legge i dati che erano già stati scritti.

Per quanto riguarda la dimensione massima che possono raggiungere mi pare di ricordare qualcosa come 4k. Ma prendilo con le pinze. Ti conviene cercare nella documentazione del tuo sistema per sicurezza.

[shinya]

Ma usare ZeroMQ, tipo?

[topix93]

ho provato a fare un ciclo dove il programma in c continua a scrivere e il programma java continua a leggere... dopo un po si nota che il C ha scritto sulla pipe piu linee di quante ne abbi lette java

Questa è l'immagine del test che ho fatto:

Di sopra c'è il programma in c che scrive un progressivo e di sotto il programma java che legge... si nota che si sono sfasati di circa 100 messaggi...

comunque i 4 kb si riferiscono al dimensione del testo massima prima del carattere di fine linea

[Vincenzo1968]

[OT]
Sembra la vecchia freddura sui carabinieri che vanno sempre in coppia perché l'uno sa scrivere e l'altro sa leggere.
[/OT]

[topix93]

zeromq non l'ho avevo mai visto... ma mi interessa molto come soluzione... sapete dove posso trovare un esempio per la comunicazione tra due soli processi?

[shinya]

Originariamente inviato da topix93

zeromq non l'ho avevo mai visto... ma mi interessa molto come soluzione... sapete dove posso trovare un esempio per la comunicazione tra due soli processi?

http://zguide.zeromq.org/page:all
All'inizio c'è un esempio di request-reply pattern. Sostanzialmente è come aprire un socket, ma con gli steroidi. Ci sono esempi in vari linguaggi.

[Vincenzo1968]

Ho provato a compilare l'esempio del link ma quando tento di eseguire il file ClientPipeJava.class ho il seguente errore:



Comando:

java ClientPipeJava

Exception in thread "main" java.lang.NoClassDefFoundError: ClientPipeJava (wrong
 name: clientpipejava/ClientPipeJava)
        at java.lang.ClassLoader.defineClass1(Native Method)
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$100(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package clientpipejava;

import java.io.*;
import java.util.*;

/**
 *
 * @author VLC
 */
public class ClientPipeJava
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        // TODO code application logic here
        try
        {
            // Connect to the pipe
            RandomAccessFile pipe = new RandomAccessFile("\\\\.\\pipe\\mynamedpipe", "rw");
            String echoText = "Hello word\n";
            // write to pipe
            pipe.write ( echoText.getBytes() );
            // read response
            String echoResponse = pipe.readLine();
            System.out.println("Response: " + echoResponse );
            pipe.close();
        }
        catch (Exception e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }        
    }
}

java -version
java version "1.7.0_09"
Java(TM) SE Runtime Environment (build 1.7.0_09-b05)
Java HotSpot(TM) Client VM (build 23.5-b02, mixed mode, sharing)

NetBeans IDE 7.2.1

Perché?

[VICIUS]

Te sei scordato il package. Non ho provato ma se lo lanci così va di sicuro.

java clientpipejava.ClientPipeJava

[Vincenzo1968]

[shinya]

Originariamente inviato da Vincenzo1968

Eh dai, fossero questi i problemi veri...

[VICIUS]

Originariamente inviato da Vincenzo1968

Ti sarai scordato di creare la cartella del package.

[Vincenzo1968]

Che cartella? Dove la debbo creare? Non ci pensa NetBeans automaticamente?

Comunque ho tolto il package

//package clientpipejava;

e funziona quasi tutto. cioè il programma si avvia senza errori ma il server mi stampa "?????" al posto della stringa "Hello word".

Il server, in C, funziona correttamente con un client in C.

[topix93]

Guarda ti metto i miei 2 codici C e JAVA che ho utilizzato:

C:

#include <stdio.h>
#include <conio.h>
#include <windows.h>

int main(int argc, const char **argv)
{
	printf("Creating an instance of a named pipe...");
	// Create a pipe to send data
	HANDLE pipe = CreateNamedPipe(
		"\\\\.\\pipe\\temp", // name of the pipe
		PIPE_ACCESS_DUPLEX | WRITE_DAC, // 1-way pipe -- send only
		PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, // send data as a byte stream
		1, // only allow 1 instance of this pipe
		4096, // OutBufferSize
		4096, // InBuffersize
		2000, // TimeOut
		NULL // use default security attributes
	);

	if (pipe == NULL || pipe == INVALID_HANDLE_VALUE) {
		printf("Failed to create outbound pipe instance.");
		// look up error code here using GetLastError()
		getch();
		return -1;
	}

	printf("Waiting for a client to connect to the pipe...");

	// This call blocks until a client process connects to the pipe
	bool result = ConnectNamedPipe(pipe, NULL);
	if (!result) {
		printf("Failed to make connection on named pipe.");
		// look up error code here using GetLastError()
		CloseHandle(pipe); // close the pipe
		system("pause");
		return 1;
	}
	printf("Sending data to pipe...\n");

	// This call blocks until a client process reads all the data
	char data[1024];
	DWORD numBytesWritten = 0;
	
	sprintf(data, "This is test line 1 so there.\n");
	result = WriteFile(
		pipe, // handle to our outbound pipe
		data, // data to send
		lstrlen(data), // length of data to send (bytes)
		&numBytesWritten, // will store actual amount of data sent
		NULL // not using overlapped IO
	);

	if (result) {
		printf("Number of bytes sent: %d\n\n", numBytesWritten);
	} else {
		printf("Failed to send data.\n\n");
		// look up error code here using GetLastError()
	}
// look up error code here using GetLastError()

	// Close the pipe (automatically disconnects client too)
	CloseHandle(pipe);

	printf("Done.\n\n");
	return 0;
}

JAVA

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Reader {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// Connect to the pipe
		RandomAccessFile pipe;
		try {
			pipe = new RandomAccessFile("\\\\.\\pipe\\temp", "r");

			String echoResponse = null; //= pipe.readLine();

			echoResponse = pipe.readLine();
			
			System.out.println("Response: " + echoResponse );
			
			pipe.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}