-
Notifications
You must be signed in to change notification settings - Fork 6
/
develop.Rmd
129 lines (97 loc) · 4.73 KB
/
develop.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
---
title: "Developing rirods"
output:
rmarkdown::html_vignette:
md_extensions: [
"-autolink_bare_uris"
]
vignette: >
%\VignetteIndexEntry{Developing rirods}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
```{r, include = FALSE}
knitr::opts_chunk$set(
collapse = TRUE,
comment = "#>"
)
```
## Contributing to rirods development
To contribute to `{rirods}` fork the source files from:
https://github.com/irods/irods_client_library_rirods, and make a Pull Request.
## Prerequisites R
The following R packages are furthermore required for development: `xml2`,
`purrr`, `readr`, `testthat` (>= 3.0.0), `knitr`, `rmarkdown`, `spelling`,
`kableExtra`, and `httptest2`. For convenience, one can also use `renv` () and
`renv::restore()` to install all dependencies. The `usethis` and the `devtools`
packages are further suggestions to streamline development. See [devtools](https://devtools.r-lib.org/) and [usethis](https://usethis.r-lib.org/)
for common development tasks and setups covered by these packages.
Development of `rirods` relies on the `httptest2` which enables testing of the
logic on the R side of the API without requiring access to the remote service.
It does this by recording the API response as mock files. These mock files are
stored in several directories under `tests/testthat/`.
## Prerequisites iRODS
The unit test included in the source files can either be run against a local or
remote iRODS C++ HTTP API service -
https://github.com/irods/irods_client_http_api.
### Local server
Launch a local demonstration iRODS service (including the HTTP API):
```{bash, eval=FALSE}
# clone the repository (and submodule "irods_demo")
# or use `git submodule update --init` when already cloned without submodules
git clone --recurse-submodules https://github.com/irods/irods_demo
# start the REST API
cd irods_demo
docker compose up -d nginx-reverse-proxy irods-client-http-api irods-client-icommands
```
Alternatively, one can use the R function `use_irods_demo()`.
Note, that both options can only be used if Docker and the Docker-compose plugin are installed.
This will result in the demonstration HTTP API running at `r rirods:::.irods_host` (or later version).
No further configuration in R is needed for development (except for removing
possible mock files). For example, to run the unit tests against this local
server use: `devtools::test()`.
For miscellaneous development tasks one can, furthermore, use: `usethis::local_project`.
This test fixture uses an alternative directory as the working directory thereby preventing
cluttering of the package source files (defaults to a temporary directory). The working directory can be restored to the
package directory by restarting the R session (possibly with `CTRL + SHIFT + F10`) or by running `withr::deferred_run()`.
### Remote server
Testing against a remote server requires the specification of server
information. This information needs to be entered in the `.Rprofile` file:
```{r prof, eval=FALSE}
# dependency management
options(renv.settings.snapshot.type = "explicit")
source("renv/activate.R")
# development key (create key with httr2::secret_make_key() and place in user
# level environment variables. One can use usethis::edit_r_environ() for this.
# Store the key under "DEV_KEY_IRODS")
# iRODS environment variables for development
Sys.setenv(DEV_HOST_IRODS = "nLO8T0IpHCT2kXklYE-IB0HjYpNkg5wN4ZKk7TPSvkwGf9FauDR-O5mVI-mmD2_zNFGLoaVcAgYl")
Sys.setenv(DEV_USER = "ZGlORquE2G6BIPS5JAcuPcngmBB6Wg")
Sys.setenv(DEV_PASS = "ZGlORquE2G6BIPS5JAcuPcngmBB6Wg")
```
The server information is stored in the environmental variables `DEV_HOST_IRODS`
, `DEV_USER`, and `DEV_PASS`. Server information is
provided in scrambled format to prevent leakage of sensitive information to
GitHub.
The following step are needed to scramble this information.
1) Generate package development key:
```{r key, eval=FALSE}
httr2::secret_make_key()
```
2) Store the package development key as an environmental variable at the user
level. For convenience one can use `usethis::edit_r_environ()` which opens the
`.Renviron` file. Enter your key by replacing `<key>` as follows:
```
DEV_KEY_IRODS="<key>"
```
3) Scramble the iRODS server information with `httr2::secret_encrypt()`.
For example, scramble the host name as follows:
```{r host, eval=FALSE}
httr2::secret_encrypt("http://localhost:9001/irods-http-api/0.1.0" ,"DEV_KEY_IRODS")
```
4) Store the scrambled information at the designated places in the project level
`.Rprofile`: host name under `DEV_HOST_IRODS`, user name under `DEV_USER`,
and password under `DEV_PASS`.
5) Restart the R sessions (possibly with `CTRL + SHIFT + F10`).
Note that the unit tests are built against a clean server with only one user
(i.e., `DEV_USER`).