He estado leyendo los ejemplos de sockets, pero todo lo que puedo hacer que JMP haga es acusar recibo de una solicitud, no puedo obtener la carga útil o el mensaje de la solicitud.¿Hay una mejor manera que los sockets o el programador para lograr una comunicación sin bloqueos?
Todo está en las ventanas.
Índice de secuencias de comandos: sockets
Orientación detallada sobre el uso de JSL para obtener datos de la API
Comunicación de socket para obtener y registrar mensajes de secuencias de comandos JMP, R y python
Yo tampoco entiendo esto: ((blobdata == Char To Blob( "" )) & (Left(r[2], 11) == "WOULDBLOCK:" ))
¿Qué es r[2]? ¿El valor de estas cosas sigue indexando cosas diferentes? En python, esperaría decir algo como:
r = solicitud
my_data_dict = r .actualizar({ 'último_jmp_datos' :pd.DataFrame(solicitud.json)})
Eso funciona en python para recuperar mis datos, pero cuando trato de volver a pasar a JMP, lo único que se imprime son los encabezados, no puedo acceder a los datos JSON que envié. Supongo que mis datos están en algún r[#] artículo?
Estoy tratando de hacer algo que no bloquee y pueda recibir datos, en este momento estoy usando una solución pirateada con el programador para crear el flujo de trabajo y SÍ funciona, pero es torpe.
Utilizo el programador para mantener esta función programada, esto llega a mi servidor de matraz, recibe datos como JSON y actualiza mi tabla principal. La actualización hace que JMP elimine todos los filtros, por lo que registramos eso en una cadena y luego lo volvemos a aplicar para que el usuario no pierde lo que estaban haciendo.
Lo que me gustaría es poder ENVIAR una solicitud desde javascript y recogerla con JMP:
Esta es mi función de JavaScript, no necesito ninguna respuesta, solo quiero que vaya a JMP. Anteriormente, usaba una solución alternativa de JavaScript diferente para escribir un archivo JSON en mis descargas y usaba mi ciclo de programador para ver la carpeta de descarga de los usuarios para un archivo JSON específico con el que actualizar la tabla.
Esta aplicación es una aplicación de un solo usuario que se ejecuta localmente en la PC de los usuarios y no se comunica con ningún recurso externo, solo necesitaba hacer mi GUI/ciertas interacciones de datos en un navegador, pero aún quiero recuperar esos datos en JMP para mi aplicación quimérica JMP/HTML/JS/CS S.
Código Javascript que uso para enviar datos a mi servidor python desde el navegador
var xhr = new XMLHttpRequest();
xhr.open("POST", 'http://localhost:8088/passdata', true);
xhr.setRequestHeader('Content-Type', 'application/json');
xhr.send([my_json_data]);
Bucle del programador Jmp
//scheduled loop to ping python local server and see if it's time to update:
get_remote_update = Function({},
s = Schedule(.25,
//show("remote update fn");
//check_downloads_folder(); // old routine that was watching download folder
check_downloads_over_ip();
get_remote_update(); //loops by scheduling the event again
);La llamada jmp al servidor python recibe datos JSON y actualiza si es necesario.
//****************************************************************
//check_downloads_OVER_IP();
//****************************************************************
// EXPLORE THIS dt = Open( Char To Blob( request << Send() ), "JSON" );
// see if we can just get the response back into a table without creating it with the weird JMP thing
check_downloads_over_ip = Function({},
request = New HTTP Request(
URL("localhost:8088/get_update"),
Method("Post"),
Timeout( .5 ),
);
data=request << Send;
if((data != "No Update" > 0) & ( isempty(data) != 1 ),
obj = JSON:Parse( data );
dt = JSON:Make Table(obj);
dt << show window(0);
temp_dtf = CHAR(dtf <<GET script=""></GET>
Scripts de socket que no entiendo
Names default to here( 1 );
//Table to hold received data
dtLog = New Table( "Log",
New Column( "Time", Numeric, "Continuous", Format( "m/d/y h:m:s", 23, 0 ),
Input Format( "m/d/y h:m:s", 0 ) ),
New Column( "Client", Character, "Nominal" ),
New Column( "Message", Character, "Nominal" )
);
//Wait for and get data from remote machine
receivedata = Function( {c, waittime = 1, waitcount = 10},
//Varaible to store data received from remote machine
blobdata = Char To Blob( "" );
//Make socket is connected
r = c << GetPeerName();
//While receiving data or waiting to receive data
i = 0;
While(
(
(r[2] == "ok") |
((blobdata == Char To Blob( "" )) & (Left(r[2], 11) == "WOULDBLOCK:" ))
) &
(i < waitcount),
i++;
//Get data
r = c << recv( 100000 );
//If no data is received yet, wait
If(Left(r[2], 11) == "WOULDBLOCK:", Wait( waittime ) );
//Write whatever is received to the log
show("writing to log now");
Write( Blob to Char( r[3] ) );
show("Done writing to log now");
//join data to whatever is already received
blobdata = blobdata || r[3];
);
return( blobdata );
);
//Get log info from remote machine, store it in a data table
processlogconnection = function( {c},
//New row in log table
dtLog << Add Rows( 1 );
rowout = N Rows( dtLog );
Column( dtLog, "Time" )[rowout] = Today();
//Get computer name of remote machine
r = c << GetPeerName();
Column( dtLog, "Client" )[rowout] = r[3];
//Get message from the remote machine
Column( dtLog, "Message" )[rowout] = Blob to Char( receivedata( c ) );
//Close the connection
c << Close;
);
//Function to accept conections from remote machine, calls another
//function to handle communication with that machine
callbackfn = function( {x},
//Call another function with the connection returned from the Accept message
If( x[2] == "ok", processlogconnection( x[4] ) );
);
//Create a socket
con = Socket();
//Use a specific port on this computer
con << Bind( "localhost", "8081" );
//Tell this socket to be ready for other sockets to connect to it
Write( "\!nlistening on ", (con << getSockName)[3]);
con << Listen();
//Verify that the connection is active
con << getsockname;
//When something connects to this socket, call a function to handle
//the connection. Accept connections for the next 5 minutes.
con << Accept(callbackfn, 30000);
//Now messages can be sent to this connection.
//When all done, close the connection
//con << close();
