name: Crossbow

on:

push:

branches:

- "*-github-*"

jobs:

autobrew:

name: "install from local source"

runs-on: {{ "${{ matrix.os }}" }}

strategy:

fail-fast: false

matrix:

os: [macOS-latest, ubuntu-20.04]

steps:

- name: Checkout Arrow

run: |

- name: Configure non-autobrew dependencies (macos)

run: |

if: contains(matrix.os, 'macOS')

- name: Configure non-autobrew dependencies (linux)

run: |

if: contains(matrix.os, 'ubuntu')

- uses: r-lib/actions/setup-r@v1

- name: Install dependencies

run: |

shell: Rscript {0}

- name: Session info

run: |

shell: Rscript {0}

- name: Install

env:

_R_CHECK_CRAN_INCOMING_: false

ARROW_USE_PKG_CONFIG: false

FORCE_BUNDLED_BUILD: true

LIBARROW_MINIMAL: false

TEST_R_WITH_ARROW: TRUE

ARROW_R_DEV: TRUE

run: |

- name: Run the tests

run: R -e 'if(tools::testInstalledPackage("arrow") != 0L) stop("There was a test failure.")'

- name: Dump test logs

run: cat arrow-tests/testthat.Rout*

if: failure()

- name: Save the test output

uses: actions/upload-artifact@v2

with:

name: test-output

path: arrow-tests/testthat.Rout*

if: always()

template: r/github.macos.autobrew.yml

test-r-install-local:

ci: github

template: r/github.macos-linux.local.yml

# On the M1, we can't use the usual autobrew, which pulls Intel dependencies

apple_m1 <- grepl("arm-apple|aarch64.*darwin", R.Version()$platform)

# On Rosetta, we have to build without JEMALLOC, so we also can't autobrew

rosetta <- identical(sysname, "darwin") && identical(system("sysctl -n sysctl.proc_translated", intern = TRUE), "1")

if (rosetta) {

Sys.setenv(ARROW_JEMALLOC = "OFF")

}

if (apple_m1 || rosetta) {

Sys.setenv(FORCE_BUNDLED_BUILD = "true")

}

opts <- list()

if (apple_m1 || rosetta) {

# Skip binaries (esp. for rosetta)

opts$pkgType <- "source"

} else if (isTRUE(binary)) {

opts$install.packages.check.source <- "no"

opts$install.packages.compile.from.source <- "never"

}

if (length(opts)) {

old <- options(opts)

on.exit(options(old))

FORCE_BUNDLED_BUILD=`echo $FORCE_BUNDLED_BUILD | tr '[:upper:]' '[:lower:]'`

if [ "$FORCE_AUTOBREW" = "true" ] || [ "$FORCE_BUNDLED_BUILD" = "true" ]; then

if [ "$UNAME" = "Darwin" ] && [ "$FORCE_BUNDLED_BUILD" != "true" ]; then

# find openssl on macos. macOS ships with libressl. openssl is installable

# with brew, but it is generally not linked. We can over-ride this and find

# openssl but setting OPENSSL_ROOT_DIR (which cmake will pick up later in

# the installation process). FWIW, arrow's cmake process uses this

# same process to find openssl, but doing it now allows us to catch it in

# nixlibs.R and throw a nicer error.

if [ "$UNAME" = "Darwin" ] && [ "${OPENSSL_ROOT_DIR}" = "" ]; then

brew --prefix openssl >/dev/null 2>&1

if [ $? -eq 0 ]; then

export OPENSSL_ROOT_DIR="$(brew --prefix openssl)"

fi

fi

${R_HOME}/bin/Rscript tools/nixlibs.R $VERSION

# If tools/nixlibs.R fails to produce libs, this dir won't exist

# Assume nixlibs.R has handled and messaged about its failure already

# When using brew's openssl it is not bundled and it is not on the system

# search path and so we must add the lib path to BUNDLED_LIBS if we are

# using it. Note the order is important, this must be after the arrow

# lib path + the pkg and bundled libs above so this is why we're

# appending to BUNDLED_LIBS and not PKG_DIRS

if [ $OPENSSL_ROOT_DIR != "" ]; then

BUNDLED_LIBS="$BUNDLED_LIBS -L$OPENSSL_ROOT_DIR/lib"

fi

invisible(Sys.setlocale("LC_COLLATE", "C"))

if (tolower(Sys.info()[["sysname"]]) %in% "darwin") {

postfix <- "-macos-universal.tar.gz"

} else {

postfix <- "-Linux-x86_64.tar.gz"

}

"/cmake-", CMAKE_VERSION, postfix

"/cmake-", CMAKE_VERSION, sub(".tar.gz", "", postfix, fixed = TRUE),

# curl on macos should be installed, so no need to alter this for macos

cat("**** S3 support requires version >= 1.0.2 of openssl-devel (rpm), libssl-dev (deb), or openssl (brew); building with ARROW_S3=OFF\n")

title: "Installing the Arrow Package"

which calls `tools/nixlibs.R`.

If you need an Arrow installation from a specific repository or at a specific ref,

should work on most platforms (with the notable exception of Windows).

The `build = FALSE` argument is important so that the installation can access the

C++ source in the `cpp/` directory in `apache/arrow`.

As with other installation methods, setting the environment variables `LIBARROW_MINIMAL=false` and `ARROW_R_DEV=true` will provide a more full-featured version of Arrow and provide more verbose output, respectively.

For example, to install from the (fictional) branch `bugfix` from `apache/arrow` one could:

Sys.setenv(LIBARROW_MINIMAL="false")

remotes::install_github("apache/arrow/r@bugfix", build = FALSE)

Developers may wish to use this method of installing a specific commit

separate from another Arrow development environment or system installation

(e.g. we use this in [arrowbench](https://github.com/ursacomputing/arrowbench) to install development versions of arrow isolated from the system install). If you already have Arrow C++ libraries installed system-wide, you may need to set some additional variables in order to isolate this build from your system libraries:

* Setting the environment variable `FORCE_BUNDLED_BUILD` to `true` will skip the `pkg-config` search for Arrow libraries and attempt to build from the same source at the repository+ref given.

* You may also need to set the Makevars `CPPFLAGS` and `LDFLAGS` to `""` in order to prevent the installation process from attempting to link to already installed system versions of Arrow. One way to do this temporarily is wrapping your `remotes::install_github()` call like so: `withr::with_makevars(list(CPPFLAGS = "", LDFLAGS = ""), remotes::install_github(...))`.

will enable some optional features, including compression libraries, S3