jak zrobić firefox czytać stdin

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

Te polecenia nie działają.
Jeśli firefox może odczytać standardowe wejście, mogę wysłać html do firefox poprzez potok.
Czy to możliwe, aby firefox odczytał standardowe wejście?

Krótka odpowiedź brzmi: lepiej jest napisać plik tymczasowy i otworzyć go. Zapewnienie prawidłowego działania rur jest bardziej skomplikowane i prawdopodobnie nie zapewni żadnych dodatkowych korzyści. To powiedziawszy, oto co znalazłem.

Jeśli twoje firefoxpolecenie faktycznie uruchamia Firefoksa zamiast rozmawiać z już działającą instancją Firefoksa, możesz to zrobić:

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

Co wyraźnie mówi Firefoksowi, aby przeczytał standardowe dane wejściowe, czyli miejsce, w którym potok umieszcza swoje dane. Ale jeśli Firefox już działa, firefoxpolecenie po prostu przekaże tę nazwę do głównego procesu Firefoksa, który odczyta własne standardowe dane wejściowe, które prawdopodobnie nic nie dadzą i na pewno nie będą podłączone do twojego potoku.

Co więcej, podczas czytania z potoku Firefox dość mocno buforuje rzeczy, więc nie będzie aktualizować strony za każdym razem, gdy dasz jej nową linię HTML, jeśli o to ci chodzi. Spróbuj zamknąć Firefoksa i uruchomić:

cat | firefox /dev/fd/0

(Uwaga: tak naprawdę potrzebujesz cattutaj.) Wklej kilka długich linii do okna powłoki, aż Firefox zdecyduje się zaktualizować stronę i zobaczysz, ile danych to zajmie. Teraz wyślij sygnał końca pliku, uderzając Ctrl+Dw nową linię, i natychmiast obejrzyj aktualizację Firefoksa. Ale wtedy nie możesz dodać więcej danych.

Więc najlepiej jest prawdopodobnie:

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

Możesz użyć identyfikatorów URI danych , takich jak to:

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

&0jest deskryptorem pliku dla stdin, więc koduje stdin na base64, a następnie interpoluje je do identyfikatora URI danych.

Ta sama sztuczka działa również w przypadku innych przeglądarek:

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)"

Jeśli chcesz, możesz umieścić drugą część w skrypcie bash (nazywam to pipefox.sh):

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

Teraz możesz zrobić:

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

Znalazłem to:

bcat - narzędzie do potoku do przeglądarki

... aby zainstalować na Ubuntu Natty, zrobiłem:

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

Myślałem, że działa z własną przeglądarką - ale uruchomienie powyższej otworzyło nową kartę w już działającym Firefoksie, wskazując na adres localhost http://127.0.0.1:53718/btest... Dzięki bcatinstalacji możesz także:

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

... karta ponownie się otworzy, ale Firefox będzie nadal wyświetlał ikonę ładowania (i najwyraźniej zaktualizuje stronę po aktualizacji syslog).

Strona bcatgłówna odwołuje się również do przeglądarki uzbl , która najwyraźniej może obsługiwać standardowe wejście - ale w przypadku własnych poleceń (prawdopodobnie powinna się jednak bardziej temu zainteresować)

EDYCJA: Ponieważ bardzo potrzebowałem czegoś takiego (głównie do przeglądania tabel HTML z danymi generowanymi w locie (a mój Firefox robi się naprawdę powoli przydatny bcat), próbowałem z niestandardowym rozwiązaniem. Ponieważ używam ReText , już miałem zainstalowane python-qt4i powiązania WebKit (i zależności) na moim Ubuntu. Więc stworzyłem skrypt Python / PyQt4 / QWebKit - który działa jak bcat(nie jak btee), ale z własnym oknem przeglądarki - o nazwie Qt4WebKit_singleinst_stdin.py(lub qwksisiw skrócie):

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

Zasadniczo za pomocą pobranego skryptu (i zależności) można go aliasować w bashterminalu w następujący sposób:

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

... i w jednym terminalu (po aliasingu) qwksisipodniesie okno głównej przeglądarki; w innym terminalu (ponownie po aliasingu) można wykonać następujące czynności, aby uzyskać dane standardowe:

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

... jak pokazano niżej:

Nie zapomnij -na końcu, aby odnosić się do stdin; w przeciwnym razie jako ostatni argument może być użyty lokalny plik.

Zasadniczo problemem jest tutaj rozwiązanie:

• problem z pojedynczą instancją (więc pierwsze uruchomienie skryptu staje się „głównym” i podnosi okno przeglądarki - podczas gdy kolejne uruchomienia po prostu przekazują dane do głównego i kończą działanie)
• komunikacja międzyprocesowa w celu współdzielenia zmiennych (dzięki czemu wychodzące procesy mogą przekazywać dane do głównego okna przeglądarki)
• Aktualizacja timera w systemie głównym, który sprawdza nową zawartość, i aktualizuje okno przeglądarki, jeśli pojawi się nowa zawartość.

Jako taki, to samo można zaimplementować, powiedzmy, w Perlu z powiązaniami Gtk i WebKit (lub innym komponentem przeglądarki). Zastanawiam się jednak, czy platforma XUL firmy Mozilla mogłaby zostać wykorzystana do zaimplementowania tej samej funkcjonalności - wydaje mi się, że w takim przypadku można by pracować z komponentem przeglądarki Firefox.

Możesz użyć podstawienia procesu :

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

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

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

Spójrz, co się pojawiło, szukając hasła „przeglądarka standardowa”! , ładny mały skrypt powłoki:

#!/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

Jeśli zapiszesz to w stdin2www, uczyń go wykonywalnym ( chmod +x stdin2www), twoje przykłady powinny działać cat index.html | ./stdin2www. Pamiętaj tylko, że względne linki , obrazy itp. Przestaną działać, ponieważ strona, która zostanie otwarta, jest czymś /tmp/; potrzeba więcej pracy, aby to naprawić.

Napisałem skrypt Pythona, aby zapisać stdin do pliku tymczasowego, a następnie otworzyć plik tymczasowy w przeglądarce 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()

Możesz uruchomić poniższe polecenie z poziomu skryptu powłoki / okna terminala.

Przed uruchomieniem Firefoksa (lub dowolnej innej przeglądarki) odczyta zawartość ze standardowej zawartości do wyświetlenia po otwarciu.

Jeśli nie jest wysyłany HTML, zmień text/htmlciąg w poniższym adresie URL na dowolny typ pliku (na przykład text/plainlub image/png).

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

Prosty ffpipealias.

Rozwiązania URI danych podane przez snowball i luk3yx nie działają dla mnie w systemie GNU / Linux.

Powinien działać następujący alias:

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

na przykład.

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

Ograniczenia

Strona zostanie załadowana dopiero po zamknięciu potoku (tzn. Osiągnięto koniec pliku).

Jeśli wymagane jest renderowanie przyrostowe potokowej zawartości, lepiej użyć czegoś takiego jak wspomniane wcześniej bcatnarzędzie.

Chociaż to pytanie ma siedem lat, jestem zaskoczony, że nikt nie zaproponował rozwiązania obsługującego plik za pośrednictwem serwera WWW. Osiąga się to za pomocą następującego kompaktowego skryptu Python3. Zapisz go jako plik wykonywalny, powiedzmy, 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()

Następnie możesz przekierować standardowe dane wejściowe do domyślnej przeglądarki:

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

Domyślnie serwer działa na porcie 8000, ale to zachowanie można zmienić za pomocą argumentu wiersza poleceń:

./browser.py 9000 < website.html

Testowałem ten skrypt w systemie Linux. Powinien obsługiwać inne systemy UNIX, w tym MacOS, po wyjęciu z pudełka. Zasadniczo jest nawet przygotowany dla systemu Windows (nie mam go do testowania), ale może być konieczne zaimplementowanie funkcji limitu czasu w inny sposób.