erl_call - Online nel cloud

PROGRAMMA:

NOME

erl_call - Chiama/avvia un nodo Erlang distribuito

DESCRIZIONE

erl_call rende possibile avviare e/o comunicare con un nodo Erlang distribuito. Esso
è costruito sul erl_interfaccia libreria come applicazione di esempio. Il suo scopo è utilizzare
uno script di shell Unix per interagire con un nodo Erlang distribuito. Esegue tutto
comunicazione con l'Erlang rex server, utilizzando la struttura standard Erlang RPC. Lo fa
non richiede l'esecuzione di alcun software speciale sul nodo di destinazione Erlang.

L'uso principale è avviare un nodo Erlang distribuito o creare una funzione ordinaria
chiamata. Tuttavia è anche possibile collegare tramite pipe un modulo Erlang erl_call e ce l'ho
compilato o per convogliare una sequenza di espressioni Erlang da valutare (simile al
Conchiglia Erlang).

Opzioni, che causano stdin da leggere, possono essere utilizzati con vantaggio come script dall'interno
Script di shell (Unix). Un altro bell'uso di erl_call potrebbe provenire da script (http) CGI-bin.

ESPORTAZIONI

erl_call

Ogni flag di opzione è descritto di seguito con il suo nome, tipo e significato.

-a [Mod [Divertimento [Arg]]]]:
(opzionale): applica la funzione specificata e restituisce il risultato. Modo deve essere
specificato, però inizia a e [] sono assunti per non specificati Divertimento e Argomenti,
rispettivamente. Argomenti dovrebbe essere nello stesso formato di for erlang:applica/3. Nota
che questo flag accetta esattamente un argomento, quindi potrebbe essere necessario citare in ordine
al gruppo Modo, Divertimento e Argomenti, in maniera dipendente dal comportamento del tuo
shell di comando.

-c Cookie:
(opzionale): utilizzare questa opzione per specificare un determinato cookie. Se nessun cookie lo è
specificato, il ~/.erlang.cookie il file viene letto e il suo contenuto viene utilizzato come
biscotto. Il nodo Erlang con cui vogliamo comunicare deve avere lo stesso cookie.

-d:
(opzionale): Modalità di debug. Ciò fa sì che tutti gli I/O vengano inviati al file
~/.erl_call.out.NodenameDurante la serata, Nome nodo è il nome del nodo Erlang in
domanda.

-e:
(opzionale): Legge una sequenza di espressioni Erlang, separate da ',' e finì
con un '.', da stdin fino a EOF (Control-D). Valuta le espressioni e
restituisce il risultato dell'ultima espressione. ritorna {ok,risultato} se ha successo.

-h Nome nascosto:
(opzionale): specifica il nome del nodo nascosto che erl_call rappresenta.

-M:
(opzionale): Legge un modulo Erlang da stdin e lo compila.

-n Nodo:
(uno di -N, -nome, -cognome è obbligatorio): ha lo stesso significato di -nome e può
essere ancora utilizzato per motivi di compatibilità con le versioni precedenti.

-nome Nodo:
(uno di -N, -nome, -cognome è obbligatorio): Nodo è il nome del nodo da essere
avviato o comunicato con. Si presume che Nodo è iniziato con Erl
-nome, il che significa che vengono utilizzati nomi di nodi lunghi completi. Se la -s
viene fornita l'opzione, verrà avviato (se necessario) un nodo Erlang Erl -nome.

-Q:
(opzionale): Arresta il nodo Erlang specificato con l'opzione -n. Questo interruttore
sovrascrive l'opzione -s.

-R:
(opzionale): Genera un nome casuale del nodo nascosto che erl_call
rappresenta.

-S:
(opzionale): avvia, se necessario, un nodo Erlang distribuito. Ciò significa che in a
sequenza di chiamate, dove il '-s'E'-n Nodo' sono costanti, solo il primo
la chiamata avvierà il nodo Erlang. Questo rende il resto della comunicazione molto
veloce. Questo flag è attualmente disponibile solo sulla piattaforma Unix.

-cognome Nodo:
(uno di -N, -nome, -cognome è obbligatorio): Nodo è il nome del nodo da essere
avviato o comunicato con. Si presume che Nodo è iniziato con Erl
-cognome il che significa che vengono utilizzati nomi di nodo brevi. Se -s viene data l'opzione, an
Il nodo Erlang verrà avviato (se necessario) con Erl -cognome.

-in:
(opzionale): ne stampa molte verboso informazione. Questo è utile solo per
sviluppatore e manutentore di erl_call.

-x ErlScript:
(opzionale): Specifica un altro nome dello script di avvio Erlang da utilizzare. Se
non specificato, lo standard Erl viene utilizzato lo script di avvio.

ESEMPI

Avvia un nodo Erlang e chiama erlang:time/0.

erl_call -s -a 'erlang time' -n madonna
{} 18,27,34

Termina un nodo Erlang chiamando erlang:alt/0.

erl_call -s -a 'erlang halt' -n madonna

Una domanda con diversi argomenti.

erl_call -s -a 'elenca mappa [{math,sqrt},[1,4,9,16,25]]' -n madonna

Valuta un paio di espressioni. . ingresso finisce con EOF (Control-D).

erl_call -s -e -n madonna
statistiche (tempo di esecuzione),
X=1,
Y=2,
{_,T}=statistiche(runtime),
{X+Y,T}.
^D
{ok,{3,0}}

Compila un modulo e lo esegue. Ancora, , il ingresso finisce con EOF (Control-D). (Nell'esempio
mostrato, l'output è stato formattato successivamente).

erl_call -s -m -a lolita -n madonna
-modulo(lolita).
-compilare(esporta_tutto).
inizio() ->
P = processi(),
F = fun(X) -> {X,process_info(X,nome_registrato)} fine,
liste:map(F,[],P).
^D
[{[email protected],0,0>,
{nome_registrato,init}},
{<[email protected],2,0>,
{nome_registrato,erl_prim_loader}},
{<[email protected],4,0>,
{nome_registrato,registratore_errori}},
{<[email protected],5,0>,
{nome_registrato,controller_applicazione}},
{<[email protected],6,0>,
{nome_registrato,kernel}},
{<[email protected],7,0>,
[]},
{<[email protected],8,0>,
{nome_registrato,kernel_sup}},
{<[email protected],9,0>,
{nome_registrato,net_sup}},
{<[email protected],10,0>,
{nome_registrato,net_kernel}},
{<[email protected],11,0>,
[]},
{<[email protected],12,0>,
{nome_registrato,nome_globale_server}},
{<[email protected],13,0>,
{nome_registrato,auth}},
{<[email protected],14,0>,
{nome_registrato,rex}},
{<[email protected],15,0>,
[]},
{<[email protected],16,0>,
{nome_registrato,file_server}},
{<[email protected],17,0>,
{nome_registrato,server_codice}},
{<[email protected],20,0>,
{nome_registrato,utente}},
{<[email protected],38,0>,
[]}]

Utilizza erl_call online utilizzando i servizi onworks.net