Commit Graph

404 Commits

Author SHA1 Message Date
Aram Drevekenin
b1ab4eac10
refactor(messaging): reduce extraneous cross-thread messaging (#1996)
* refactor(messaging): reduce extraneous cross-thread messaging

* style(fmt): rustfmt
2022-12-06 22:29:57 +01:00
Aram Drevekenin
b7adfcc581
refactor(plugins): fix plugin loading data flow (#1995) 2022-12-06 15:34:43 +01:00
Aram Drevekenin
f8fbd8a138
fix(panes): focus change when closing and between tabs (#1966)
* fix(panes): do not forget pane focus when switching tabs or closing panes

* style(fmt): rustfmt

* fix(tests): e2e snapshots
2022-11-23 18:14:24 +01:00
Aram Drevekenin
b0218f4d50
fix(router): handle client empty message (#1965)
* fix(router): handle client empty message

* style(fmt): rustfmt
2022-11-23 10:10:42 +01:00
har7an
11b0210de5
plugins: rework plugin loading (#1924)
* zellij: Move "populate_data_dir" to utils

and rewrite it to take a second, optional parameter. This allows
controlling whether only a specific asset should be installed. We do
this as preparation for being able to recover from a plugin version
mismatch error, where we will need to repopulate the data dir for
offending plugins.

* server/wasm_vm: Recover from PluginVersionMismatch

Adds a global plugin cache that stores, per plugin config, the wasmer
module associated with it. Make `start_plugin` take the pre-populated
module and create only the necessary modifications to the wasm env etc.

* utils: Fix formatting

* zellij: Delete non-existent module

* utils/shared: fix missing "set_permissions"

function when not on unix systems.

* server/wasm_vm: Don't populate cachedir

with serialized versions of the WASM plugins.

* utils/input/plugins: load wasm bytes from assets

for builtin plugin specifications. This foregoes any need to:

- Dump the plugin bytes to disk at all and
- subsequently read the plugin bytes from disk

* zellij: Disable default asset installation

which previously installed only the builtin plugins to disk. This is no
longer necessary because now we can load the builtin plugins directly
from the application binary.

* utils/input/plugins: Update docs

* utils/input/plugins: Add 'is_builtin' method

to `PluginConfig` that returns true if the plugin configuration refers
to a builtin plugin.

* wasm_vm: Remove plugin version mismatch handling

because a version mismatch in an internal plugin is now unfixable, with
the plugins being loaded from the running binary, and we have no control
over external plugins in the first place.

* cargo: Reintroduce feature flag

for `disable_automatic_asset_installation`

* utils/consts: Add `ASSET_MAP`

which currently contains the compiled WASM plugins.

* utils/shared: Fix clippy lint

* utils/errors: Add more `ZellijError` variants

* zellij: Make loading internal plugins optional

by reenabling the `disable_automatic_asset_installation` flag and
utilizing it for this purpose. Changes plugin search behavior to throw
better errors in case the builtin plugins cannot be found, depending on
the state of this feature.

* utils/errors: Apply rustfmt

* utils/setup: Allow dumping builtin plugins

to a specified folder on disk. This is meant to be an "escape hatch" for
users that have accidentally deleted the builtin plugins from disk (in
cases where the plugins aren't loaded from inside the zellij binary).

* utils/input/plugins: Update docs

* utils/setup: Add hint to `setup --check` output

when zellij was built without the `disable_automatic_asset_installation`
flag and will thus not read builtin plugins from the "PLUGIN DIR".

* utils/setup: Refine `setup --dump-plugins`

to dump to:

- The default "DATA DIR" when no option is provided with the argument,
  or
- The provided option, if existent

Also print a message to stdout with the destination folder that the
plugins are dumped to.

* server/wasm_vm: Ignore "NotFound" errors

when attempting to delete the non-existent plugin data directories. This
silences an error message that otherwise ends up in the logs when
quitting zellij.

* utils/errors: Extend "BuiltinPluginMissing" msg

to hint the user to the `zellij setup --dump-plugins` command to fix
their issues for them!

* utils/errors: Track caller in calls to `non_fatal`

which will hopefully, once closures can be annotated, allow us to
display the location of the call to `non_fatal` in log messages.

* utils/input/plugins: Fix plugin lookup

to prefer internal assets if available. It was previously broken because
sorting the paths vector before deduping it would bring the paths into a
wrong order, looking up in the plugin folder first.

Also print a log message when a plugin is being loaded from the internal
assets but exists on disk, too.

* Apply rustfmt

* make: build-e2e depends on wasm-opt-plugins

so it updates the assets when building the binary

* server/qwasm_vm: Remove var

* utils/consts: Add plugins from target folder

and include them in the asset map from there, too. Include plugins from
debug or release builds, depending on the build type.

* utils/consts: Take release plugins from assets

instead of the target/release folder. The latter will break
installations from crates.io, because we currently rely on including the
plugins we pre-compiled and distribute along with the binary.

* server/wasm_vm: Reintroduce .cache folder

to speedup subsequent application launches.

* cargo: Reorder workspace members

to improve behavior with `cargo make` with respect to compilation order.

* Makefile: restructure plugin tasks

* Makefile: Fix CI errors

* Makefile: More CI diagnosis

* github: Install wasm-opt in e2e test workflow

* Makefile: Build plugins for e2e-test target

* server/Wasm_vm: Reorder plugin folder creation

so no folders are created in the plugin cache when loading a plugin
fails due to not being present or similar.

* update plugins testcommit

* makefile: Change job order

* changelog: Add PR #1924
2022-11-22 20:06:02 +00:00
Aram Drevekenin
63e7531c48
performance(rendering): improve rendering performance (#1960)
* refactor(plugins): plugins now need to explicitly ask to be rendered

* performance(render): remove various needless renders

* performance(render): cache boundaries

* performance(render): adjust tests and cache cursor location/shape

* style(comment): remove outdated

* style(fmt): rustfmt
2022-11-21 20:07:24 +01:00
Aram Drevekenin
2afb355e48
fix(router): handle client buffer overflow (#1955)
* fix(router): handle client buffer overflow

* style(fmt): rustfmt
2022-11-18 10:21:59 +01:00
Aram Drevekenin
81b08d6057
fix(panes): ensure ejected pane always has a frame (#1950) 2022-11-16 17:59:52 +01:00
Aram Drevekenin
cc3ac25c74
fix(cli): measure cwd from cli client rather than the zellij server (#1947)
* fix(cli): measure cwd from cli client rather than the zellij server

* style(fmt): rustfmt
2022-11-16 16:25:01 +01:00
Shunsuke Mie
4aae81faf8
fix(pty): use /bin/sh when SHELL env variable is not found (#1769)
This commit fixes #1722.

In some environment, the SHELL environemnt variable is not exists. It
causes a panic that is reported as #1722. Use generic shell (/bin/sh) to
prevent the panic.

This is a same behavior as tmux.
https://github.com/tmux/tmux/blob/master/spawn.c#L329-L331
2022-11-15 15:22:38 +00:00
Aram Drevekenin
3d2a6d6a5a
refactor(plugins): change the data flow (#1934)
* refactor(plugins): do not block render loop

* refactor(plugins): cleanup

* style(fmt): rustfmt

* fix(plugins): various rendering pipeline fixes
2022-11-15 12:21:36 +01:00
har7an
342d1629d0
Errors: Ignore errors from async when quitting (#1918)
* utils/errors: Fix function order in `to_anyhow`

impl for `SendError`. Previously we attached the context to `anyhow!`,
which is wrong (because it doesn't create an `Err` type itself) and
leads to strange behavior where the error seemingly is immediately
panicked upon.

Instead, Wrap `anyhow!` into an `Err()` and then attach the context to
that. This achieves the intended goal and doesn't lead to premature
termination.

* server/terminal_bytes: Ignore error in `listen`

which occurs when quitting zellij with the `Ctrl+q` keybinding. At the
end of the `listen` function we break out of a loop and send a final
`Render` instruction to the Screen. However, when quitting zellij as
mentioned above, the Screen thread is likely dead already and hence we
cannot send it any Instructions. This causes an error in the async tasks
of the panes that handle reading the PTY input.

If we leave the error unhandled, we will have error messages in the log
whenever we quit zellij, even though the application exited normally.
Hence, we now send the final `Render` instruction but do not care
whether it is sent successfully or not.

This is a "workaround" for the fact that we cannot tell whether the
application is quitting or not.

* server/terminal_bytes: Add FIXME note

* changelog: Add PR #1918

don't log errors from async pane threads when quitting zellij
2022-11-12 10:18:15 +00:00
Aram Drevekenin
a71b2ae890 chore(version): bump development version 2022-11-10 11:48:09 +01:00
har7an
48bc2281c7
Fix: better error reporting when failing to load plugins (#1912) (#1914)
* utils/input/plugins: Return `Result` when loading

a plugin and failing to find it. Since we look up the plugin in multiple
locations, make sure we preserve each of these lookup failures and
report them to the user. This way the user can see what locations were
actually checked.

In addition, before performing the lookup, deduplicate the array of
locations to check. This prevents errors where we look up the same
plugin multiple times in the exact same locations, which can leave a bad
impression on anyone reading it who isn't familiar with the code.

* server/wasm_vm: Remove obsolete context

which was previouly required because the function it is attached to
returned only an `Option` instead of a `Result`.
2022-11-09 07:28:02 +00:00
har7an
453142775c
errors: Remove log::error in server (#1881)
* server/wasm_vm: Replace `log::error!`

with better error logging by means of `non_fatal`. This preserves the
original error and allows adding context information on top. Also makes
error formatting more uniform across the application.

* server/tab: Replace `log::error!`

with better error logging by means of `non_fatal`. This preserves the
original error and allows adding context information on top. Also makes
error formatting more uniform across the application.

* server/route: Replace `log::error!`

and propagate the error to the caller instead.

* server/pty: Replace `log::error!`

with better error logging by means of `non_fatal`. This preserves the
original error and allows adding context information on top. Also makes
error formatting more uniform across the application.

Also add per-instruction error context to make it clear what we tried to
accomplish when an error occured.

* server/panes/tiled_panes: Merge dependencies

and sort them into a better order.

* server/panes/tiled_panes: Replace `log::error!`

with better error logging by means of `non_fatal`. This preserves the
original error and allows adding context information on top. Also makes
error formatting more uniform across the application.

* server/os_input_output: Merge depndencies

and sort them into a better order.

* server/logging_pipe: Replace `log::error!`

with better error logging by means of `non_fatal`. This preserves the
original error and allows adding context information on top. Also makes
error formatting more uniform across the application.

* server/os_io: Remove uses of `log::error`

* changelog: Add PR #1881

* server/os_io: Gracefully handle failing resize

for terminals IDs that don't exist, instead of propagating the error to
the user.

* server/lib: Remove leftover log message

* server/pty: Log error cause

rather than providing a hard-coded error reason which is plain wrong in
this context.

* server/screen: Remove calls to `log::error!`

and change `get_active_tab(_mut)?` to return a `Result` instead of an
`Option`. This already makes many places in the code obsolete where
previously "failed to get active tab..." was logged manually.

Rather than logging, use the `anyhow::Error`s we have, along with all
their context information, and log these instead.
2022-11-08 10:56:23 +00:00
Aram Drevekenin
6c3c0f51d0
fix(panes): moving and toggling embed/float with frames (#1909)
* fix(ui): frame broken or missing when embedding/floating without pane frames

* fix(panes): offset properly without pane frames
2022-11-05 14:45:45 +01:00
Aram Drevekenin
8d1a497d10
feat(terminals): send focus in/out events to terminal panes (#1908)
* feat(terminals): send focus in/out events to terminal panes

* style(fmt): rustfmt

* style(fmt): rustfmt
2022-11-04 17:29:41 +01:00
Aram Drevekenin
9ebc9b74ee
fix(edit): treat cwd properly (#1904) 2022-11-03 11:06:37 +01:00
Pedro Fedricci
ece1cbe533
fix(terminal): Reset dim SGR independently from bold (#1803) 2022-11-02 19:24:40 +01:00
Aram Drevekenin
eebbf246b6
fix(ui): clear floating panes indication when closing a command pane (#1897) 2022-11-02 18:11:54 +01:00
哇呜哇呜呀咦耶
f334415d57
fix(search): allow terminating char to clear search term (#1853)
* allow terminating char to clear search term

* format code
2022-11-02 14:35:23 +01:00
har7an
e45a3e5826
errors: Don't unwrap in server::os_input_output (#1895)
* server/os_io: Redefine `ServerOsApi` result types

to use `anyhow::Result` instead. This mostly makes the need of custom
`SpawnTerminalError` obsolete (tbd in subsequent commits) and unifies
error handling across the application.

* utils/errors: Implement new `ZellijError` type

to replace any previously defined, isolated custom error types
throughout the application. Currently implements all error variants
found in `SpawnTerminalError`.

In the long term, this will allow zellij to fall back to a single error
type for all application-specific errors, instead of having different
error types per module.

* server/unit/screen: Impl new `ServerOsApi`

with updated `Result`-types.

* server/tab/unit: Impl new `ServerOsApi`

with updated `Result`-types.

* server/os_io: Impl new `ServerOsApi`

with updated `Result`-types.

* utils/ipc: Return `anyhow::Error` in `send`

rather than a `&'static str`, which isn't compatible with
`anyhow::Context`.

* server/tab: Handle `Result` in `resize_pty!`

which is returned due to the changed return types in `ServerOsApi`.

* server/tab: Handle new `Result`s

originating in the change to the `ServerOsApi` trait definition.

* server/screen: Handle new `Result`s

originating in the change to the `ServerOsApi` trait definition.

* server/panes/tiled: Handle new `Result`s

originating in the change to the `ServerOsApi` trait definition.

* server/panes/floating: Handle new `Result`s

originating in the change to the `ServerOsApi` trait definition.

* server/lib: Unwrap on new `Result`s

originating in the change to the `ServerOsApi` trait definition. The
functions here don't return a `Result` yet, this is better left to a
follow-up PR.

* server: Remove `SpawnTerminalError`

and make use of the new `ZellijError` instead. Make use of `anyhow`s
downcast capabilities to restore the underlying original errors where
necessary, as was done previously. This gives us the flexibility to
attach context information to all errors while still allowing us to
handle specific errors in greater detail.

* server/pty: Fix vars broken in rebase

* server/os_io: Remove last `SpawnTerminalError`

* changelog: Add PR #1895
2022-11-02 05:29:50 +00:00
Aram Drevekenin
abc700fc4d
feat(command-panes): allow to start suspended (#1887)
* feat(command-panes): allow panes to start suspended

* style(fmt): remove unused code

* style(fmt): rustfmt
2022-11-01 09:07:25 +01:00
Thomas Linford
855711ebb8
feat(mouse): allow toggling mouse mode at runtime (#1883) 2022-10-31 17:04:38 +01:00
har7an
417b4a4ec5
errors: Don't unwrap in zellij_server::output (#1878)
* server/output: Don't unwrap

and return `Result` types where appropriate instead.

* server: Handle new `Result`s from `output`

* server/tab/unit: Unwrap new `Result`s

* changelog: Add PR #1878

Don't unwrap in `zellij_server::output`.
2022-10-30 06:02:03 +00:00
har7an
60322e969f
errors: Don't unwrap in server::terminal_bytes (#1876)
* server/terminal_bytes: Don't unwrap

and return `Result`s instead, where appropriate.

* changelog: Add PR #1876

Don't unwrap in `zellij_server::terminal_bytes`.
2022-10-28 17:12:05 +00:00
har7an
6ae18b4187
errors: Don't unwrap in server::pty_writer (#1872)
* server/pty_writer: Don't unwrap

and handle occuring errors instead. Replace calls to `log::error` with
`non_fatal` instead.

* server/pty_writer: Apply rustfmt
2022-10-28 14:43:06 +00:00
哇呜哇呜呀咦耶
c5b1eb0a9e
improve error handling in ui module (#1870)
* improve error handling in ui module

* resolve problems in the review
2022-10-28 14:15:16 +00:00
Aram Drevekenin
c97b972383
feat(command-panes): optionally allow panes to be closed on exit (#1869)
* feat(cli): allow option to close command pane on exit

* feat(layouts): allow option to close command panes on exit

* style(fmt): rustfmt
2022-10-28 13:03:37 +02:00
哇呜哇呜呀咦耶
bb9437ff6c
improve error handling in pty (#1840)
* improve error handling in pty

* improve error handling in pty

* format code

* attach context to remaining result
2022-10-26 06:51:51 +00:00
Aram Drevekenin
5793af7655 chore(version): bump development version 2022-10-25 11:43:53 +02:00
har7an
75801bdb0e
plugins: Improve error handling on plugin version mismatch (#1838)
* server/tab: Don't panic in `Pane::render`

and do not crash the application on failure to receive a render update
from plugins any longer. Instead, will print a simple string with a hint
to check the application logs, where a more thorough error indication
can be found.

* utils/errors: re-export `anyhow::Error`

to create ad-hoc errors with custom error types, without having to wrap
them into a `context()` before to turn the into anyhow errors.

* plugins: Check plugin version on startup

and terminate execution with a descriptive error message in case the
plugin version is incompatible with the version of zellij being run.

* server/wasm_vm: Add plugin path in version error

so the user knows which plugin to look at in case they're using custom
plugins.

* server/wasm_vm: Check plugin version for equality

Previously we would accept cases where the plugin version was newer than
the zellij version, which doesn't make a lot of sense.

* server/wasm_vm: Prettier error handling

in call to `wasmer::Function::call` in case a plugin version mismatch
can occur.

* tile: Install custom panic handler

that will print the panic message to a plugins stdout and then call a
panic handler on the host that turns it into a real application-level
panic.

* tile: Catch errors in event deserialization

and turn them into proper panics. These errors are symptomatic of an
uncaught plugin version mismatch, for example when developing from main
and compiling zellij/the plugins from source. Normal users should never
get to see this error.

* utils/errors: Improve output in `to_stdout`

for anyhow errors. The default anyhow error formatting of `{:?}` is
already very good, and we just made it worse by trying to invent our own
formatting.

* tile: Reword plugin mismatch error message

* zellij: Apply rustfmt

* changelog: Add PR #1838

Improve error handling on plugin version mismatch.

* server/wasm_vm: Rephrase error in passive voice
2022-10-23 13:14:24 +00:00
naosense
e5115e88a7
improve error handling in route (#1808)
* improve error handling in route

* improve error handling in route

* improve error handling in route

* format code

* improve error handling in route
2022-10-21 13:49:39 +00:00
Aram Drevekenin
e62bb93df3
fix(layouts): various bugs and better errors (#1831)
* fix(layout): error on percent size 0

* fix(command): better error on invalid commands

* fix(layouts): better error on unknown pane nodes

* fix(layouts): disallow certain template names

* style(fmt): rustfmt
2022-10-20 20:16:46 +02:00
har7an
27c875b568
server/panes/grid: Fix whitespace error 2022-10-20 16:06:04 +00:00
har7an
d8fcaf8e05
server/panes/grid: Document dropping 0-width chars
and add a reference to the issue discussing/tracking this (https://github.com/zellij-org/zellij/issues/1538).
2022-10-20 15:59:12 +00:00
har7an
a56723f7ce
errors: Don't panic in wasm_vm (#1827)
* server/wasm_vm: Compact module imports

* utils/errors: Impl `to_anyhow` for PoisonError

which is returned by calls to `lock` on various types of locks from
`std`. In our case, some of the locks we try to acquire in `wasm_vm` can
contain an `mpsc::Sender`, which is `!Send` and hence doesn't work with
`anyhow`. Turn the `PoisonError` into an error string instead and
returns that as `anyhow::Err`.

* wasm_vm: Remove calls to `unwrap`

in the WASM VM codes server API. Note that this doesn't include the
Plugin APIs. Mark the error as `fatal` in `server/lib`, where the wasm
thread is created.

This will cause zellij to report a proper error (and log it) when any of
the plugin-related functions fails. Unfortunately, this closes the
channel to the WASM thread. Hence, when loading the plugins upon startup
fails, the error reported in the terminal (visible to the user) hints
towards a call in `plugin_pane` being the culprit. However, the real
error will be contained in the logs.

Also add an error message and print it to the user in case that the
plugin failure was caused by a plugin version mismatch.

* server/wasm_vm: Restore panic on failure to load

plugins.

* server/wasm_vm: Add fix to plugin mismatch error

* server/panes/plugin_pane: Hint to logs

when failing to receive a message from the plugins for rendering pane
contents.
2022-10-20 15:49:04 +00:00
Aram Drevekenin
b94a626959
fix(command): better error when command not found (#1829)
* fix(command): better error when command not found

* fix(cli): open edit file from current cwd

* style(fmt): rustfmt?
2022-10-20 17:27:44 +02:00
Aram Drevekenin
3d0c35489f
fix(terminal): reset scroll region when clearing screen (#1826) 2022-10-19 18:36:17 +02:00
Dan Näsman
2e70a4c672
allow dump_screen() to only dump the viewport (#1794)
* allow dump_screen() to only dump the viewport

* add additional implementations

* set full default as false
2022-10-19 22:49:13 +09:00
Aram Drevekenin
617b52f8f4
fix(editor): default to vi when no editor is set (#1811)
* fix(editor): default to vi when no editor is set

* style(fmt): rustfmt
2022-10-18 17:33:48 +02:00
Aram Drevekenin
abc710e124
feat(panes): change floating window positions (#1810)
* feat(panes): group floating panes

* style(fmt): rustfmt
2022-10-18 16:44:05 +02:00
Aram Drevekenin
271abb3ea2
feat(cli): zellij run improvements (#1804)
* feat(cli): move command to the end of the cli arguments

* feat(cli): allow naming panes from the command line

* fix(cli): adjust actions after pane rename

* feat(cli): zellij run completions for fish

* feat(cli): zellij run completions for bash and zsh

* style(fmt): rustfmt

* fix(e2e): fix run test and snapshot

* style(fmt): rustfmt
2022-10-17 19:39:37 +02:00
Aram Drevekenin
efceb562de
feat(layouts): edit panes (#1799)
* feat(layouts): edit panes

* style(fmt): rustfmt
2022-10-14 17:44:23 +02:00
Aram Drevekenin
d074bb1cda
feat(layouts): global cwd (#1798)
* feat(layouts): allow defining a global cwd

* feat(layouts): allow passing global cwd from cli

* style(fmt): rustfmt

* fix(layouts): error on mixed cwd and pane children
2022-10-14 15:08:32 +02:00
Aram Drevekenin
bece86b95c
fix(layouts): various kdl layout issues and features (#1797)
* fix(layouts): error on non-bare children node

* refactor(layout): consolidate split direction parsing

* refactor(layout): remove unused import

* fix(layouts): log error when there is no room for layout

* fix(layout): error on size 0

* feat(layouts): allow pane templates to override template command attributes

* style(fmt): rustfmt
2022-10-13 13:55:16 +02:00
Thomas Linford
694afd2239
fix(tab): frameless pane size wrong after closing other panes (#1776)
always recompute pane frames after closing a pane
2022-10-12 11:29:17 +02:00
Aram Drevekenin
c64bf5207a
feat(ux): rerun command pane (#1787)
* chore(config): default kdl keybindings config

* tests

* work

* refactor(config): move stuff around

* work

* tab merge layout

* work

* work

* layouts working

* work

* layout tests

* work

* work

* feat(parsing): kdl layouts without config

* refactor(kdl): move stuff around

* work

* tests(layout): add cases and fix bugs

* work

* fix(kdl): various bugs

* chore(layouts): move all layouts to kdl

* feat(kdl): shared keybidns

* fix(layout): do not count fixed panes toward percentile

* fix(keybinds): missing keybinds and actions

* fix(config): adjust default tips

* refactor(config): move stuff around

* fix(tests): make e2e tests pass

* fix(kdl): add verbose parsing errors

* fix(kdl): focused tab

* fix(layout): corret default_tab_template behavior

* style(code): fix compile warnings

* feat(cli): send actions through the cli

* fix(cli): exit only when action is done

* fix(cli): open embedded pane from floating pane

* fix(cli): send actions to other sessions

* feat(cli): command alias

* feat(converter): convert old config

* feat(converter): convert old layout and theme files

* feat(kdl): pretty errors

* feat(client): convert old YAML files on startup

* fix: various bugs and styling issues

* fix: e2e tests

* fix(screen): propagate errors after merge

* style(clippy): lower clippy level

* fix(tests): own session_name variable

* style(fmt): rustfmt

* fix(cli): various action fixes

* style(fmt): rustfmt

* fix(themes): loading of theme files

* style(fmt): rustfmt

* fix(tests): theme fixtures

* fix(layouts): better errors on unknown nodes

* fix(kdl): clarify valid node terminator error

* fix(e2e): adjust close tab test

* fix(e2e): adjust close tab test again

* style(code): cleanup some comments

* get command panes not to exit on command exit

* separate terminal pane_ids from raw_fds

* render frame according to exit status

* re-run command on enter and close pane on ctrl-c

* proper error when command is not found

* make ui nicer

* initial pane title for command panes

* fix pane override bug

* reap terminal_ids from os_input_output on pane close

* bool floating flag

* some ui tweaks

* fix tests

* make rustfmt happy

* e2e test for command pane

* fix various concurrency issues

* rename command to run in the cli

* rustfmt

* style(fmt): rustfmt

* fix(e2e): command => run

* fix(e2e): command => run in snapshot too!
2022-10-11 16:45:46 +02:00
Bohdan Ivashko
39f33a9a9a
zellij-server: improve thread_bus error handling (#1775)
* zellij-server: improve thread_bus error handling

* zellij-server/thread_bus: get rid of option.unwrap

* zellij-utils/errors.rs: generic error in to_anyhow
2022-10-07 09:04:08 +00:00
har7an
6715f4629c
Server: Remove panics in tab module (#1748)
* utils/errors: Add `ToAnyhow` trait

for converting `Result` types that don't satisfy `anyhow`s trait
constraints (`Display + Send + Sync + 'static`) conveniently.

An example of such a Result is the `SendError` returned from
`send_to_plugins`, which sends `PluginInstruction`s as message type.
One of the enum variants can contain a `mpsc::Sender`, which is `!Sync`
and hence makes the whole `SendError` be `!Sync` in this case. Add an
implementation for this case that takes the message and converts it into
an error containing the message formatted as string, with the additional
`ErrorContext` as anyhow context.

* server/tab: Remove calls to `unwrap()`

and apply error reporting via `anyhow` instead. Make all relevant
functions return `Result`s where previously a panic could occur and
attach error context.

* server/screen: Modify `update_tab!`

to accept an optional 4th parameter, a literal "?". If present, this
will append a `?` to the given closure verbatim to handle/propagate
errors from within the generated macro code.

* server/screen: Handle new `Result`s from `Tab`

and apply appropriate error context and propagate errors further up.

* server/tab/unit: `unwrap` on new `Result`s

* server/unit: Unwrap `Results` in screen tests

* server/tab: Better message for ad-hoc errors

created with `anyhow!`. Since these errors don't have an underlying
cause, we describe the cause in the macro instead and then attach the
error context as usual before `?`ing the error back up.

* utils/cargo: Activate `anyhow`s "backtrace" feature

to capture error backtraces at the error origins (i.e. where we first
receive an error and convert it to a `anyhow::Error`). Since we
propagate error back up the call stack now, the place where we `unwrap`
on errors doesn't match the place where the error originated. Hence, the
callstack, too, is quite misleading since it contains barely any
references of the functions that triggered the error.

As a consequence, we have 2 backtraces now when zellij crashes: One from
`anyhow` (that is implicitly attached to anyhows error reports), and one
from the custom panic handler (which is displayed through `miette`).

* utils/errors: Separate stack traces

in the output of miette. Since we record backtraces with `anyhow` now,
we end up having two backtraces in the output: One from the `anyhow`
error and one from the actual call to `panic`. Adds a comment explaining
the situation and another "section" to the error output of miette: We
print the backtrace from anyhow as "Stack backtrace", and the output
from the panic handler as "Panic backtrace". We keep both for the
(hopefully unlikely) case that the anyhow backtrace isn't existent, so
we still have at least something to work with.

* server/screen: Remove calls to `fatal`

and leave the `panic`ing to the calling function instead.

* server/screen: Remove needless macro

which extended `active_tab!` by passing the client IDs to the closure.
However, this isn't necessary because closures capture their environment
already, and the client_id needn't be mutable.

* server/screen: Handle unused result

* server/screen: Reintroduce arcane macro

that defaults to some default client_id if it isn't valid (e.g. when the
ScreenInstruction is sent via CLI).

* server/tab/unit: Unwrap new results
2022-10-06 06:46:18 +00:00