launcher

package
v0.0.0-...-67bb87e Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 27, 2022 License: MIT Imports: 29 Imported by: 0

README

Overview

A lib helps to find, launch or download the browser. You can also use it as a standalone lib without Rod.

Documentation

Overview

Package launcher for launching browser utils.

Example (Custom_launch)
package main

import (
	"os/exec"

	"github.com/ScaleChamp/rod"
	"github.com/ScaleChamp/rod/lib/launcher"
	"github.com/ScaleChamp/rod/lib/utils"
	"github.com/ysmood/leakless"
)

func main() {
	// get the browser executable path
	path := launcher.NewBrowser().MustGet()

	// use the FormatArgs to construct args, this line is optional, you can construct the args manually
	args := launcher.New().FormatArgs()

	var cmd *exec.Cmd
	if true { // decide whether to use leakless or not
		cmd = leakless.New().Command(path, args...)
	} else {
		cmd = exec.Command(path, args...)
	}

	parser := launcher.NewURLParser()
	cmd.Stderr = parser
	utils.E(cmd.Start())
	u := launcher.MustResolveURL(<-parser.URL)

	rod.New().ControlURL(u).MustConnect()
}
Output:

Example (Print_browser_CLI_output)
package main

import (
	"os"

	"github.com/ScaleChamp/rod"
	"github.com/ScaleChamp/rod/lib/launcher"
)

func main() {
	// Pipe the browser stderr and stdout to os.Stdout .
	u := launcher.New().Logger(os.Stdout).MustLaunch()
	rod.New().ControlURL(u).MustConnect()
}
Output:

Example (Use_system_browser)
package main

import (
	"github.com/ScaleChamp/rod"
	"github.com/ScaleChamp/rod/lib/launcher"
)

func main() {
	if path, exists := launcher.LookPath(); exists {
		u := launcher.New().Bin(path).MustLaunch()
		rod.New().ControlURL(u).MustConnect()
	}
}
Output:

Index

Examples

Constants

View Source
const (
	// HeaderName for remote launch
	HeaderName = "Rod-Launcher"
)
View Source
const RevisionDefault = 1033860

RevisionDefault for chromium

View Source
const RevisionPlaywright = 1019

RevisionPlaywright for arm linux

Variables

View Source
var DefaultBrowserDir = filepath.Join(map[string]string{
	"windows": filepath.Join(os.Getenv("APPDATA")),
	"darwin":  filepath.Join(os.Getenv("HOME"), ".cache"),
	"linux":   filepath.Join(os.Getenv("HOME"), ".cache"),
}[runtime.GOOS], "rod", "browser")

DefaultBrowserDir for downloaded browser. For unix is "$HOME/.cache/rod/browser", for Windows it's "%APPDATA%\rod\browser"

View Source
var DefaultUserDataDirPrefix = filepath.Join(os.TempDir(), "rod", "user-data")

DefaultUserDataDirPrefix ...

Functions

func HostGoogle

func HostGoogle(revision int) string

HostGoogle to download browser

func HostNPM

func HostNPM(revision int) string

HostNPM to download browser

func HostPlaywright

func HostPlaywright(revision int) string

HostPlaywright to download browser

func LookPath

func LookPath() (found string, has bool)

LookPath searches for the browser executable from often used paths on current operating system.

func MustResolveURL

func MustResolveURL(u string) string

MustResolveURL is similar to ResolveURL

func Open

func Open(url string)

Open tries to open the url via system's default browser.

func ResolveURL

func ResolveURL(u string) (string, error)

ResolveURL by requesting the u, it will try best to normalize the u. The format of u can be "9222", ":9222", "host:9222", "ws://host:9222", "wss://host:9222", "https://host:9222" "http://host:9222". The return string will look like: "ws://host:9222/devtools/browser/4371405f-84df-4ad6-9e0f-eab81f7521cc"

Types

type Browser

type Browser struct {
	Context context.Context

	// Hosts are the candidates to download the browser.
	Hosts []Host

	// Revision of the browser to use
	Revision int

	// Dir to download browser.
	Dir string

	// Log to print output
	Logger utils.Logger

	// LockPort a tcp port to prevent race downloading. Default is 2968 .
	LockPort int
}

Browser is a helper to download browser smartly

func NewBrowser

func NewBrowser() *Browser

NewBrowser with default values

func (*Browser) Destination

func (lc *Browser) Destination() string

Destination of the downloaded browser executable

func (*Browser) Download

func (lc *Browser) Download() (err error)

Download browser from the fastest host. It will race downloading a TCP packet from each host and use the fastest host.

func (*Browser) Exists

func (lc *Browser) Exists() bool

Exists returns true if the browser executable path exists. If the executable is malformed it will return false.

func (*Browser) Get

func (lc *Browser) Get() (string, error)

Get is a smart helper to get the browser executable path. If Destination doesn't exists it will download the browser to Destination.

func (*Browser) MustGet

func (lc *Browser) MustGet() string

MustGet is similar with Get

type Host

type Host func(revision int) string

Host to download browser

type Launcher

type Launcher struct {
	Flags map[flags.Flag][]string `json:"flags"`
	// contains filtered or unexported fields
}

Launcher is a helper to launch browser binary smartly

func MustNewManaged

func MustNewManaged(serviceURL string) *Launcher

MustNewManaged is similar to NewManaged

func New

func New() *Launcher

New returns the default arguments to start browser. Headless will be enabled by default. Leakless will be enabled by default. UserDataDir will use OS tmp dir by default, this folder will usually be cleaned up by the OS after reboot.

func NewAppMode

func NewAppMode(u string) *Launcher

NewAppMode is a preset to run the browser like a native application.

func NewManaged

func NewManaged(serviceURL string) (*Launcher, error)

NewManaged creates a default Launcher instance from launcher.Manager. The serviceURL must point to a launcher.Manager. It will send a http request to the serviceURL to get the default settings of the Launcher instance. For example if the launcher.Manager running on a Linux machine will return different default settings from the one on Mac. If Launcher.Leakless is enabled, the remote browser will be killed after the websocket is closed.

func NewUserMode

func NewUserMode() *Launcher

NewUserMode is a preset to enable reusing current user data. Useful for automation of personal browser. If you see any error, it may because you can't launch debug port for existing browser, the solution is to completely close the running browser. Unfortunately, there's no API for rod to tell it automatically yet.

func (*Launcher) Append

func (l *Launcher) Append(name flags.Flag, values ...string) *Launcher

Append values to the flag

func (*Launcher) Bin

func (l *Launcher) Bin(path string) *Launcher

Bin of the browser binary path to launch, if the path is not empty the auto download will be disabled

func (*Launcher) Cleanup

func (l *Launcher) Cleanup()

Cleanup wait until the Browser exits and remove UserDataDir

func (*Launcher) ClientHeader

func (l *Launcher) ClientHeader() (string, http.Header)

ClientHeader for launching browser remotely via the launcher.Manager.

func (*Launcher) Context

func (l *Launcher) Context(ctx context.Context) *Launcher

Context sets the context

func (*Launcher) Delete

func (l *Launcher) Delete(name flags.Flag) *Launcher

Delete a flag

func (*Launcher) Devtools

func (l *Launcher) Devtools(autoOpenForTabs bool) *Launcher

Devtools switch to auto open devtools for each tab

func (*Launcher) Env

func (l *Launcher) Env(env ...string) *Launcher

Env to launch the browser process. The default value is os.Environ(). Usually you use it to set the timezone env. Such as:

Env(append(os.Environ(), "TZ=Asia/Tokyo")...)

func (*Launcher) FormatArgs

func (l *Launcher) FormatArgs() []string

FormatArgs returns the formated arg list for cli

func (*Launcher) Get

func (l *Launcher) Get(name flags.Flag) string

Get flag's first value

func (*Launcher) GetFlags

func (l *Launcher) GetFlags(name flags.Flag) ([]string, bool)

GetFlags from settings

func (*Launcher) Has

func (l *Launcher) Has(name flags.Flag) bool

Has flag or not

func (*Launcher) Headless

func (l *Launcher) Headless(enable bool) *Launcher

Headless switch. Whether to run browser in headless mode. A mode without visible UI.

func (*Launcher) JSON

func (l *Launcher) JSON() []byte

JSON serialization

func (*Launcher) KeepUserDataDir

func (l *Launcher) KeepUserDataDir() *Launcher

KeepUserDataDir after remote browser is closed. By default launcher.FlagUserDataDir will be removed.

func (*Launcher) Kill

func (l *Launcher) Kill()

Kill the browser process

func (*Launcher) Launch

func (l *Launcher) Launch() (string, error)

Launch a standalone temp browser instance and returns the debug url. bin and profileDir are optional, set them to empty to use the default values. If you want to reuse sessions, such as cookies, set the UserDataDir to the same location.

func (*Launcher) Leakless

func (l *Launcher) Leakless(enable bool) *Launcher

Leakless switch. If enabled, the browser will be force killed after the Go process exits. The doc of leakless: https://github.com/ysmood/leakless.

func (*Launcher) Logger

func (l *Launcher) Logger(w io.Writer) *Launcher

Logger to handle stdout and stderr from browser. For example, pipe all browser output to stdout: launcher.New().Logger(os.Stdout)

func (*Launcher) MustClient

func (l *Launcher) MustClient() *cdp.Client

MustClient for launching browser remotely via the launcher.Manager.

func (*Launcher) MustLaunch

func (l *Launcher) MustLaunch() string

MustLaunch is similar to Launch

func (*Launcher) NoSandbox

func (l *Launcher) NoSandbox(enable bool) *Launcher

NoSandbox switch. Whether to run browser in no-sandbox mode. Linux users may face "running as root without --no-sandbox is not supported" in some Linux/Chrome combinations. This function helps switch mode easily. Be aware disabling sandbox is not trivial. Use at your own risk. Related doc: https://bugs.chromium.org/p/chromium/issues/detail?id=638180

func (*Launcher) PID

func (l *Launcher) PID() int

PID returns the browser process pid

func (*Launcher) ProfileDir

func (l *Launcher) ProfileDir(dir string) *Launcher

ProfileDir is the browser profile the browser will use. When set to empty, the profile 'Default' is used. Related article: https://superuser.com/a/377195

func (*Launcher) Proxy

func (l *Launcher) Proxy(host string) *Launcher

Proxy switch. When disabled leakless will be disabled.

func (*Launcher) RemoteDebuggingPort

func (l *Launcher) RemoteDebuggingPort(port int) *Launcher

RemoteDebuggingPort to launch the browser. Zero for a random port. Zero is the default value. If it's not zero and the Launcher.Leakless is disabled, the launcher will try to reconnect to it first, if the reconnection fails it will launch a new browser.

func (*Launcher) Revision

func (l *Launcher) Revision(rev int) *Launcher

Revision of the browser to auto download

func (*Launcher) Set

func (l *Launcher) Set(name flags.Flag, values ...string) *Launcher

Set a command line argument to launch the browser.

func (*Launcher) StartURL

func (l *Launcher) StartURL(u string) *Launcher

StartURL to launch

func (*Launcher) UserDataDir

func (l *Launcher) UserDataDir(dir string) *Launcher

UserDataDir is where the browser will look for all of its state, such as cookie and cache. When set to empty, browser will use current OS home dir. Related doc: https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md

func (*Launcher) WorkingDir

func (l *Launcher) WorkingDir(path string) *Launcher

WorkingDir to launch the browser process.

func (*Launcher) XVFB

func (l *Launcher) XVFB(args ...string) *Launcher

XVFB enables to run browser in by XVFB. Useful when you want to run headful mode on linux.

type Manager

type Manager struct {
	// Logger for key events
	Logger utils.Logger

	// Defaults should return the default Launcher settings
	Defaults func(http.ResponseWriter, *http.Request) *Launcher

	// BeforeLaunch hook is called right before the launching with the Launcher instance that will be used
	// to launch the browser.
	// Such as use it to filter malicious values of Launcher.UserDataDir, Launcher.Bin, or Launcher.WorkingDir.
	BeforeLaunch func(*Launcher, http.ResponseWriter, *http.Request)
}

Manager is used to launch browsers via http server on another machine. The reason why we have Manager is after we launcher a browser, we can't dynamicall change its CLI arguments, such as "--headless". The Manager allows us to decide what CLI arguments to pass to the browser when launch it remotely. The work flow looks like:

|      Machine X       |                             Machine Y                                    |
| NewManaged("a.com") -|-> http.ListenAndServe("a.com", launcher.NewManager()) --> launch browser |

1. X send a http request to Y, Y respond default Launcher settings based the OS of Y.
2. X start a websocket connect to Y with the Launcher settings
3. Y launches a browser with the Launcher settings X
4. Y transparently proxy the websocket connect between X and the launched browser

func NewManager

func NewManager() *Manager

NewManager instance

func (*Manager) ServeHTTP

func (m *Manager) ServeHTTP(w http.ResponseWriter, r *http.Request)

type URLParser

type URLParser struct {
	URL    chan string
	Buffer string // buffer for the browser stdout
	// contains filtered or unexported fields
}

URLParser to get control url from stderr

func NewURLParser

func NewURLParser() *URLParser

NewURLParser instance

func (*URLParser) Context

func (r *URLParser) Context(ctx context.Context) *URLParser

Context sets the context

func (*URLParser) Err

func (r *URLParser) Err() error

Err returns the common error parsed from stdout and stderr

func (*URLParser) Write

func (r *URLParser) Write(p []byte) (n int, err error)

Write interface

Directories

Path Synopsis
Package flags ...
Package flags ...
Package main ...
Package main ...
A server to help launch browser remotely
A server to help launch browser remotely

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL