come fare in modo che Firefox legga stdin

echo '<h1>hello, world</h1>' |  firefox
cat index.html | firefox

Questi comandi non funzionano.
Se firefox riesce a leggere stdin, posso inviare html a firefox tramite pipe.
È possibile fare in modo che Firefox legga stdin?

La risposta breve è che è meglio scrivere un file temporaneo e aprirlo. Far funzionare correttamente i tubi è più complicato e probabilmente non ti darà alcun vantaggio in più. Detto questo, ecco cosa ho trovato.

Se il tuo firefoxcomando sta effettivamente avviando Firefox invece di parlare con un'istanza di Firefox già in esecuzione, puoi farlo:

echo '<h1>hello, world</h1>' | firefox /dev/fd/0

Il che dice a Firefox di leggere esplicitamente il suo input standard, che è dove la pipe sta mettendo i suoi dati. Ma se Firefox è già in esecuzione, il firefoxcomando passerà semplicemente quel nome al processo principale di Firefox, che leggerà il proprio input standard, che probabilmente non gli darà nulla e sicuramente non è collegato alla pipa.

Inoltre, durante la lettura da una pipe, Firefox esegue il buffering delle cose piuttosto pesantemente, quindi non aggiornerà la pagina ogni volta che le dai una nuova linea di HTML, se è quello che stai cercando. Prova a chiudere Firefox e esegui:

cat | firefox /dev/fd/0

(NB in ​​realtà non è necessario il catqui.) Incollare alcune lunghe righe nella finestra della shell ripetutamente fino a quando Firefox non decide di aggiornare la pagina e si può vedere la quantità di dati necessari. Ora invia un segnale di fine file colpendo Ctrl+Dsu una nuova linea e guarda l'aggiornamento di Firefox all'istante. Ma poi non puoi aggiungere altri dati.

Quindi il migliore è probabilmente:

echo '<h1>hello, world</h1>' >my_temporary_file; firefox my_temporary_file

Puoi usare gli URI dei dati , in questo modo:

echo '<h1>hello, world</h1>' |firefox "data:text/html;base64,$(base64 -w 0 <&0)"

&0è il descrittore di file per stdin, quindi codifica stdin in base64, quindi lo interpola nell'URI dei dati.

Lo stesso trucco funziona anche per altri browser:

echo '<h1>hello, world</h1>' |chromium "data:text/html;base64,$(base64 -w 0 <&0)"
echo '<h1>hello, world</h1>' |opera    "data:text/html;base64,$(base64 -w 0 <&0)"

Se vuoi, puoi mettere la seconda parte in uno script bash (lo chiamerò pipefox.sh):

#!/bin/bash
firefox "data:text/html;base64,$(base64 -w 0 <&0)"

Ora puoi fare:

echo '<h1>hello, world</h1>' |pipefox.sh

Ho trovato questo:

bcat - pipe per l'utilità del browser

... per installare su Ubuntu Natty, ho fatto:

sudo apt-get install rubygems1.8
sudo gem install bcat
# to call
ruby -rubygems /var/lib/gems/1.8/gems/bcat-0.6.2/bin/bcat
echo "<b>test</b>" | ruby -rubygems /var/lib/gems/1.8/gems/bcat-0.6.2/bin/bcat

Pensavo che funzionasse con il suo browser, ma eseguendo quanto sopra si apriva una nuova scheda in un Firefox già in esecuzione, che punta a un indirizzo localhost http://127.0.0.1:53718/btest... Con l' bcatinstallazione puoi anche fare:

tail -f /var/log/syslog | ruby -rubygems /var/lib/gems/1.8/gems/bcat-0.6.2/bin/btee

... si aprirà di nuovo una scheda, ma Firefox continuerà a mostrare l'icona di caricamento (e apparentemente aggiornerebbe la pagina quando si aggiorna syslog).

La bcathomepage fa anche riferimento al browser uzbl , che a quanto pare può gestire lo stdin, ma per i suoi comandi (probabilmente dovrebbe esaminare di più questo, però)

EDIT: dato che avevo bisogno di qualcosa del genere (principalmente per visualizzare le tabelle HTML con i dati generati al volo (e il mio Firefox sta diventando molto lento per essere utile con bcat), ho provato con una soluzione personalizzata. Da quando utilizzo ReText , ho già avuto installato python-qt4e collegamenti WebKit (e dipendenze) sul mio Ubuntu. Quindi, ho messo insieme uno script Python / PyQt4 / QWebKit - che funziona come bcat(non come btee), ma con una propria finestra del browser - chiamato Qt4WebKit_singleinst_stdin.py(o qwksisiin breve):

• http://sdaaubckp.svn.sourceforge.net/viewvc/sdaaubckp/single-scripts/Qt4WebKit_singleinst_stdin.py?view=markup

Fondamentalmente, con lo script scaricato (e le dipendenze) è possibile alias in un bashterminale come questo:

$ alias qwksisi="python /path/to/Qt4WebKit_singleinst_stdin.py"

... e in un terminale (dopo l'aliasing), qwksisisi aprirà la finestra del browser principale; mentre in un altro terminale (sempre dopo l'aliasing), si potrebbe fare quanto segue per ottenere dati stdin:

$ echo "<h1>Hello World</h1>" | qwksisi - 

... come mostrato di seguito:

Non dimenticare la -fine per fare riferimento a stdin; in caso contrario, è possibile utilizzare anche un nome file locale come ultimo argomento.

Fondamentalmente, il problema qui è risolvere:

• problema a singola istanza (quindi la prima esecuzione dello script diventa un "master" e solleva una finestra del browser - mentre le successive esecuzioni semplicemente passano i dati al master e terminano)
• comunicazione tra processi per la condivisione di variabili (quindi i processi in uscita possono passare i dati alla finestra del browser principale)
• Aggiornamento del timer nel master che verifica la presenza di nuovi contenuti e aggiorna la finestra del browser se arrivano nuovi contenuti.

Come tale, lo stesso potrebbe essere implementato in, diciamo, Perl con i collegamenti Gtk e WebKit (o altri componenti del browser). Mi chiedo, tuttavia, se il framework XUL di Mozilla possa essere utilizzato per implementare la stessa funzionalità - immagino in tal caso, si funzionerebbe con il componente del browser Firefox.

È possibile utilizzare la sostituzione del processo :

 firefox <( echo '<h1>hello, world</h1>' )

 firefox <( cat page_header.html contents.html footer.html )

 firefox  <( echo "<h1>Hello number "{1..23}"!</h1>" )

Guarda cosa ha cercato 'browser stdin'! , un bel piccolo script di shell:

#!/bin/sh

# read from stdin, write to a temp file, open the temp file in a browser, then delete it
tmpfile=$(tempfile); cat > $tmpfile; x-www-browser $tmpfile; rm $tmpfile

Se lo salvi in stdin2www, rendilo eseguibile ( chmod +x stdin2www), i tuoi esempi dovrebbero funzionare tramite cat index.html | ./stdin2www. Basta notare che i relativi collegamenti , immagini, ecc. Falliranno poiché la pagina che verrà aperta è qualcosa /tmp/; sarebbe necessario più lavoro per risolvere questo problema.

Ho scritto uno script Python per scrivere stdin in un file temporaneo e quindi aprire il file temporaneo con Firefox.

#!/usr/bin/env python
import sys
import tempfile
import subprocess

with tempfile.NamedTemporaryFile() as f:
  f.write(sys.stdin.read())
  f.flush()
  process = subprocess.Popen(['firefox', f.name])
  process.wait()

È possibile eseguire il comando seguente da una shell script / finestra del terminale.

Prima di avviare Firefox (o qualsiasi altro browser), leggerà dal suo contenuto il contenuto da visualizzare all'apertura.

Se non si invia HTML, modificare la text/htmlstringa nell'URL seguente in qualunque sia il tipo di file (ad esempio text/plaino image/png).

firefox "data:text/html;base64,$(base64)"

Un semplice ffpipealias.

Le soluzioni URI di dati fornite da snowball e luk3yx non funzionano per me su GNU / Linux.

Il seguente alias dovrebbe funzionare:

alias ffpipe='base64 -w0 <&0 | read -r x; firefox "data:text/html;base64,$x"'

per esempio.

echo '<h1>hello, world</h1>' | ffpipe

limitazioni

La pagina verrà caricata solo una volta chiusa la pipe (ovvero è stata raggiunta la fine del file).

Se è richiesto il rendering incrementale del contenuto inoltrato, è meglio usare qualcosa come l' bcatutilità menzionata in precedenza .

Sebbene questa domanda abbia sette anni, sono sorpreso che nessuno abbia proposto una soluzione che serva il file tramite un server web. Ciò si ottiene con il seguente script Python3 compatto. Salvalo come file eseguibile, ad esempio, browse.py:

#!/usr/bin/env python3
import sys, os, time, platform, signal
from subprocess import Popen
from http.server import HTTPServer, BaseHTTPRequestHandler
sys.stderr = open(os.devnull, 'w')
def timeoutHandler(signum, frame):
    sys.exit("")
signal.signal(signal.SIGALRM, timeoutHandler)
signal.alarm(2)
html = sys.stdin.read()
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8000
class Handler(BaseHTTPRequestHandler):
    def _set_headers(self):
        self.send_response(200)
        self.send_header("content-type", "text/html")
        self.end_headers()
    def do_GET(self):
        self._set_headers()
        self.wfile.write(b = bytes(html, "utf-8"))
platform = platform.system().lower()
if platform.find("win") >= 0: command = "start"
elif platform.find("mac") >= 0 or platform.find("darwin") >= 0: command = "open"
else: command = "xdg-open"
p = Popen([command, "http://localhost:" + str(port) + "/"])
httpd = HTTPServer(("localhost", port), Handler)
httpd.serve_forever()

Quindi è possibile reindirizzare l'input standard al browser predefinito:

./browser.py < somewebpage.html
echo "<html><body><h1>Hello</h1></body></html>" | browse.py

Per impostazione predefinita, il server funziona sulla porta 8000, ma tale comportamento può essere modificato con un argomento della riga di comando:

./browser.py 9000 < website.html

Ho testato questo script su Linux. Dovrebbe gestire immediatamente altri sistemi UNIX, incluso MacOS. In linea di principio è anche predisposto per Windows (non ne ho uno per i test), ma potrebbe essere necessario implementare la funzionalità di timeout in modo diverso.