App-BrowserUtils
view release on metacpan or search on metacpan
lib/App/BrowserUtils.pm view on Meta::CPAN
schema => $sch_cmd,
default => 'opera',
},
);
our %argopt_vivaldi_cmd = (
vivaldi_cmd => {
schema => $sch_cmd,
default => 'vivaldi',
},
);
our %argsopt_browser_cmd = (
%argopt_firefox_cmd,
%argopt_chrome_cmd,
%argopt_opera_cmd,
%argopt_vivaldi_cmd,
);
our %argsopt_browser_start = (
start_firefox => {
schema => 'bool*',
},
start_chrome => {
schema => 'bool*',
},
start_opera => {
schema => 'bool*',
},
start_vivaldi => {
schema => 'bool*',
},
start_brave => {
schema => 'bool*',
},
);
our %argsopt_browser_restart = (
restart_firefox => {
schema => 'bool*',
},
restart_chrome => {
schema => 'bool*',
},
restart_opera => {
schema => 'bool*',
},
restart_vivaldi => {
schema => 'bool*',
},
restart_brave => {
schema => 'bool*',
},
);
our %argopt_users = (
users => {
'x.name.is_plural' => 1,
'x.name.singular' => 'user',
summary => 'Kill browser processes that belong to certain user(s) only',
schema => ['array*', of=>'unix::uid::exists*', 'x.perl.coerce_rules' => ['From_str::comma_sep']],
},
);
our %argopt_quiet = (
quiet => {
schema => 'true*',
cmdline_aliases => {q=>{}},
},
);
our %argopt_signal = (
signal => {
schema=>'unix::signal*',
cmdline_aliases => {s=>{}},
},
);
our %argopt_periods = (
periods => {
'x.name.is_plural' => 1,
'x.name.singular' => 'period',
summary => 'Pause and unpause times, in seconds',
schema => ['array*', {
of=>'duration',
min_len=>2,
#'x.perl.coerce_rules'=>['From_str::comma_sep'], # not working yet
}],
description => <<'MARKDOWN',
For example, to pause for 5 minutes, then unpause 10 seconds, then pause for 2
minutes, then unpause for 30 seconds (then repeat the pattern), you can use:
300,10,120,30
MARKDOWN
},
);
my $desc_pat = <<'MARKDOWN';
If one of the `*-pat` options are specified, then instead of the default
heuristic rules to find the browser processes, these `*-pat` options are solely
used to determine which processes are the browser processes.
MARKDOWN
my %argopt_cmndline_pat = (
cmndline_pat => {
summary => 'Filter processes using regex against their cmndline',
schema => 're_from_str*',
description => $desc_pat,
tags => ['category:filtering'],
},
);
my %argopt_exec_pat = (
exec_pat => {
summary => 'Filter processes using regex against their exec',
schema => 're_from_str*',
description => $desc_pat,
tags => ['category:filtering'],
},
);
my %argopt_fname_pat = (
fname_pat => {
summary => 'Filter processes using regex against their fname',
schema => 're_from_str*',
description => $desc_pat,
tags => ['category:filtering'],
},
);
my %argopt_pid_pat = (
pid_pat => {
summary => 'Filter processes using regex against their pid',
schema => 're_from_str*',
description => $desc_pat,
tags => ['category:filtering'],
},
);
our %args_common = (
%argopt_users,
%argopt_cmndline_pat,
%argopt_exec_pat,
%argopt_fname_pat,
%argopt_pid_pat,
);
our $desc_pause = <<'MARKDOWN';
A modern browser now runs complex web pages and applications. Despite browser's
power management feature, these pages/tabs on the browser often still eat
considerable CPU cycles even though they only run in the background. Pausing
(kill -STOP) the browser processes is a simple and effective way to stop CPU
eating on Unix and prolong your laptop battery life. It can be performed
whenever you are not using your browser for a little while, e.g. when you are
typing on an editor or watching a movie. When you want to use your browser
again, simply unpause (kill -CONT) it.
MARKDOWN
our $desc_pause_and_unpause = $desc_pause . <<'MARKDOWN';
The `pause-and-unpause` action pause and unpause browser in an alternate
fashion, by default every 5 minutes and 30 seconds. This is a compromise to save
CPU time most of the time but then give time for web applications in the browser
to catch up during the unpause window (e.g. for WhatsApp Web to display new
messages and sound notification.) It can be used when you are not browsing but
still want to be notified by web applications from time to time.
If you run this routine, it will start pausing and unpausing browser. When you
want to use the browser, press Ctrl-C to interrupt the routine. Then after you
are done with the browser and want to pause-and-unpause again, you can re-run
this routine.
You can customize the periods via the `periods` option.
MARKDOWN
sub _do_browser {
require Proc::Find;
my ($which_action, $which_browser, %args) = @_;
my $browser_fname_pat = ($which_browser eq 'all known browsers' || $browsers{$which_browser}{filter})
or return [400, "Unknown browser '$which_browser'"];
my @periods = @{ $args{periods} // [300,30] };
my @stopped_pids;
my $period_idx = -1;
local $SIG{INT} = sub {
if (@stopped_pids) {
log_info "Unpausing stopped PID(s) ...";
kill CONT => @stopped_pids;
}
log_info "Exiting ...";
exit 0;
};
my $filter = (defined $args{cmndline_pat} || defined $args{exec_pat} || defined $args{fname_pat} || defined $args{pid_pat}) ? sub {
my $p = shift;
no warnings 'uninitialized';
for my $f (qw(cmndline exec fname pid)) {
if (defined $args{"${f}_pat"}) {
if ($p->{$f} =~ /$args{"${f}_pat"}/) {
log_trace "Process %s '%s' matches pattern '%s'", $f, $p->{$f}, $args{"${f}_pat"};
} else {
log_trace "Process %s '%s' does NOT match pattern '%s'", $f, $p->{$f}, $args{"${f}_pat"};
return 0;
}
}
}
1;
} : $which_browser eq 'all known browsers' ? sub {
for my $br (keys %browsers) {
lib/App/BrowserUtils.pm view on Meta::CPAN
=back
Supported browsers: Firefox on Linux, Opera on Linux, Chrome on Linux, and
Vivaldi on Linux.
=head1 FUNCTIONS
=head2 browsers_are_paused
Usage:
browsers_are_paused(%args) -> [$status_code, $reason, $payload, \%result_meta]
Check whether browsers are paused.
Browser is defined as paused if I<all> of its processes are in 'stop' state.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<cmndline_pat> => I<re_from_str>
Filter processes using regex against their cmndline.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<exec_pat> => I<re_from_str>
Filter processes using regex against their exec.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<fname_pat> => I<re_from_str>
Filter processes using regex against their fname.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<pid_pat> => I<re_from_str>
Filter processes using regex against their pid.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<quiet> => I<true>
(No description)
=item * B<users> => I<array[unix::uid::exists]>
Kill browser processes that belong to certain user(s) only.
=back
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head2 pause_and_unpause_browsers
Usage:
pause_and_unpause_browsers(%args) -> [$status_code, $reason, $payload, \%result_meta]
Pause and unpause browsers alternately.
A modern browser now runs complex web pages and applications. Despite browser's
power management feature, these pages/tabs on the browser often still eat
considerable CPU cycles even though they only run in the background. Pausing
(kill -STOP) the browser processes is a simple and effective way to stop CPU
eating on Unix and prolong your laptop battery life. It can be performed
whenever you are not using your browser for a little while, e.g. when you are
typing on an editor or watching a movie. When you want to use your browser
again, simply unpause (kill -CONT) it.
The C<pause-and-unpause> action pause and unpause browser in an alternate
fashion, by default every 5 minutes and 30 seconds. This is a compromise to save
CPU time most of the time but then give time for web applications in the browser
to catch up during the unpause window (e.g. for WhatsApp Web to display new
messages and sound notification.) It can be used when you are not browsing but
still want to be notified by web applications from time to time.
If you run this routine, it will start pausing and unpausing browser. When you
want to use the browser, press Ctrl-C to interrupt the routine. Then after you
are done with the browser and want to pause-and-unpause again, you can re-run
this routine.
You can customize the periods via the C<periods> option.
See also the separate C<pause_browsers> and the C<unpause_browsers> routines.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<cmndline_pat> => I<re_from_str>
Filter processes using regex against their cmndline.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<exec_pat> => I<re_from_str>
Filter processes using regex against their exec.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<fname_pat> => I<re_from_str>
Filter processes using regex against their fname.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<periods> => I<array[duration]>
Pause and unpause times, in seconds.
For example, to pause for 5 minutes, then unpause 10 seconds, then pause for 2
minutes, then unpause for 30 seconds (then repeat the pattern), you can use:
300,10,120,30
=item * B<pid_pat> => I<re_from_str>
Filter processes using regex against their pid.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<users> => I<array[unix::uid::exists]>
Kill browser processes that belong to certain user(s) only.
=back
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head2 pause_browsers
Usage:
pause_browsers(%args) -> [$status_code, $reason, $payload, \%result_meta]
Pause (kill -STOP) browsers.
A modern browser now runs complex web pages and applications. Despite browser's
power management feature, these pages/tabs on the browser often still eat
considerable CPU cycles even though they only run in the background. Pausing
(kill -STOP) the browser processes is a simple and effective way to stop CPU
eating on Unix and prolong your laptop battery life. It can be performed
whenever you are not using your browser for a little while, e.g. when you are
typing on an editor or watching a movie. When you want to use your browser
again, simply unpause (kill -CONT) it.
See also the C<unpause_browsers> and the C<pause_and_unpause_browsers> routines.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<cmndline_pat> => I<re_from_str>
Filter processes using regex against their cmndline.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<exec_pat> => I<re_from_str>
Filter processes using regex against their exec.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<fname_pat> => I<re_from_str>
Filter processes using regex against their fname.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<pid_pat> => I<re_from_str>
Filter processes using regex against their pid.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<users> => I<array[unix::uid::exists]>
Kill browser processes that belong to certain user(s) only.
=back
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head2 ps_browsers
Usage:
ps_browsers(%args) -> [$status_code, $reason, $payload, \%result_meta]
List browser processes.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<cmndline_pat> => I<re_from_str>
Filter processes using regex against their cmndline.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<exec_pat> => I<re_from_str>
Filter processes using regex against their exec.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<fname_pat> => I<re_from_str>
Filter processes using regex against their fname.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<pid_pat> => I<re_from_str>
Filter processes using regex against their pid.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<users> => I<array[unix::uid::exists]>
Kill browser processes that belong to certain user(s) only.
=back
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head2 restart_browsers
Usage:
restart_browsers(%args) -> [$status_code, $reason, $payload, \%result_meta]
Restart browsers.
For each of the requested browser, first check whether browser processes (that
run the current user) exist. If they do then terminate the browser first. After
that, start the browser again.
Example on the CLI:
% restart-browsers --restart-firefox
To customize command:
% restart-browsers --start-firefox --firefox-cmd 'firefox -P myprofile'
when starting each browser, console output will be captured and returned in
function metadata. Will wait for 2/5/10 seconds and check if the browsers have
been started. If all browsers can't be started, will return 500; otherwise will
return 200 but report the browsers that failed to start to the STDERR.
This function is not exported.
This function supports dry-run operation.
Arguments ('*' denotes required arguments):
=over 4
=item * B<chrome_cmd> => I<array[str]|str> (default: "google-chrome")
(No description)
=item * B<firefox_cmd> => I<array[str]|str> (default: "firefox")
(No description)
lib/App/BrowserUtils.pm view on Meta::CPAN
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head2 terminate_browsers
Usage:
terminate_browsers(%args) -> [$status_code, $reason, $payload, \%result_meta]
Terminate browsers (by default with -KILL).
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<cmndline_pat> => I<re_from_str>
Filter processes using regex against their cmndline.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<exec_pat> => I<re_from_str>
Filter processes using regex against their exec.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<fname_pat> => I<re_from_str>
Filter processes using regex against their fname.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<pid_pat> => I<re_from_str>
Filter processes using regex against their pid.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<signal> => I<unix::signal>
(No description)
=item * B<users> => I<array[unix::uid::exists]>
Kill browser processes that belong to certain user(s) only.
=back
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head2 unpause_browsers
Usage:
unpause_browsers(%args) -> [$status_code, $reason, $payload, \%result_meta]
Unpause (resume, continue, kill -CONT) browsers.
See also the C<pause_browsers> and the C<pause_and_unpause_browsers> routines.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<cmndline_pat> => I<re_from_str>
Filter processes using regex against their cmndline.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<exec_pat> => I<re_from_str>
Filter processes using regex against their exec.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<fname_pat> => I<re_from_str>
Filter processes using regex against their fname.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<pid_pat> => I<re_from_str>
Filter processes using regex against their pid.
If one of the C<*-pat> options are specified, then instead of the default
heuristic rules to find the browser processes, these C<*-pat> options are solely
used to determine which processes are the browser processes.
=item * B<users> => I<array[unix::uid::exists]>
Kill browser processes that belong to certain user(s) only.
=back
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status code
(200 means OK, 4xx caller error, 5xx function error). Second element
($reason) is a string containing error message, or something like "OK" if status is
200. Third element ($payload) is the actual result, but usually not present when enveloped result is an error response ($status_code is not 2xx). Fourth
element (%result_meta) is called result metadata and is optional, a hash
that contains extra information, much like how HTTP response headers provide additional metadata.
Return value: (any)
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-BrowserUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-BrowserUtils>.
=head1 SEE ALSO
Utilities using this distribution: L<App::FirefoxUtils>, L<App::ChromeUtils>,
L<App::OperaUtils>, L<App::VivaldiUtils>
L<App::BrowserOpenUtils>
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 CONTRIBUTOR
=for stopwords Steven Haryanto
Steven Haryanto <stevenharyanto@gmail.com>
=head1 CONTRIBUTING
To contribute, you can send patches by email/via RT, or send pull requests on
GitHub.
Most of the time, you don't need to build the distribution yourself. You can
simply modify the code, then test via:
% prove -l
If you want to build the distribution (e.g. to try to install it locally on your
system), you can install L<Dist::Zilla>,
L<Dist::Zilla::PluginBundle::Author::PERLANCAR>,
L<Pod::Weaver::PluginBundle::Author::PERLANCAR>, and sometimes one or two other
Dist::Zilla- and/or Pod::Weaver plugins. Any additional steps required beyond
that are considered a bug and can be reported to me.
( run in 1.192 second using v1.01-cache-2.11-cpan-39bf76dae61 )