CODEWITHSUNDEEP
rr-package
harshsinghal
harshsinghal

Reputation: 3780

Creating a local R package repository

I would like to create a local R package repository such that users in my company can install packages from it and the system admins can update the local repo periodically. Access to the CRAN mirrors is currently denied.

Is there a simple way to do this?

Upvotes: 50

Views: 32502

Answers (4)

Ted M.
Ted M.

Reputation: 392

I also don't have access to CRAN mirrors for package installation. As a result, these are some steps I've found to be helpful.

First, you'll want to make sure you have the following path and its directories in your system: "/R/src/contrib". If you don't have this path and these directories, you'll need to create them. All of your R packages files will be stored in the "contrib" directory.

Once you've added package files to the "contrib" directory, you can use the setRepositories function from the utils package to create the repository. I'd recommend adding the following code to your .Rprofile for a local repository:

utils::setRepositories(ind = 0, 
                       addURLs = c(WORK = "file://<your higher directories>/R"))

After editing your .Rprofile, restart R.

ind = 0 will indicate that you only want the local repository. Additional repositories can be included in the addURLs = option and are comma separated within the character vector.

Next, create the repository index with the following code:

tools::write_PACKAGES("/<your higher directories>/R/src/contrib", verbose = TRUE)

This will generate the PACKAGE files that serve as the repository index.

To see what packages are in your repository, run the following code and take a look at the resulting data frame: my_packages <- available.packages()

At this point, you can install packages from the repo without referencing the entire path to the package installation file. For example, to install the dplyr package, you could run the following:

install.packages("dplyr", dependencies = TRUE)

If you want to take it a step further and manage a changing repository, you could install and use the miniCRAN package. Otherwise, you'll need to execute the write_PACKAGES function whenever your repository changes.

After installing the miniCRAN package, you can execute the following code to create the miniCRAN repo:

 my_packages <- available.packages()

 miniCRAN::makeRepo(
  pkgs = my_packages[,1], 
  path = "/<your higher directories>/R",
  repos = getOption("repos"), 
  type = "source",
  Rversion = R.version, 
  download = TRUE, 
  writePACKAGES = TRUE,
  quiet = FALSE
 )

You only need to execute the code above once for each repo.

Then, check to make sure each miniCRAN repo has been created. You only need to do this once for each repo:

 pkgAvail(
  repos = getOption("repos"),
  type = "source",
  Rversion = R.version,
  quiet = FALSE
 )

Whenever new package files are placed into the local repo you can update the local repo's index as follows:

miniCRAN::updateRepoIndex("/<your higher directories>/R/")

Finally, as an optional step to see if the new package is in the index, create a data frame of the available packages and search the data frame:

my_packages <- available.packages(repos = "file://<your higher directories>/R/")

This approach has worked pretty well for me, but perhaps others have comments and suggestions that could improve upon it.

Upvotes: 1

Glen Moutrie
Glen Moutrie

Reputation: 325

The package miniCRAN also provides great functionality for this. The key advantage being that you don't need a full mirror, but can setup a "mini" mirror of CRAN with only the packages distributions you need, including their dependencies.

Upvotes: 4

Dirk is no longer here
Dirk is no longer here

Reputation: 368619

Yes, either a copy of CRAN or a repo with local packages is easy to set up. Presumably you want this for Windows so do this:

  1. Create a top-level directory on your webserver, say R/
  2. Create the usual hierarchy in there: R/bin/windows/contrib/2.11. If you need to support other (earlier) releases, simply create directories 2.10, 2.9, ... next to the 2.11 directory.

  3. Place the packages you need into the directory (say, 2.11), then change into that directory and run the following command to generate PACKAGES and PACKAGES.gz files for the repository:

    tools::write_PACKAGES(".", type="win.binary")

That is all there is to it -- now you can access the repository by pointing to the address given a command such as

update.packages(repos="http://my.local.server/R", ask=FALSE)

which I even do in R/zzz.R for local packages so that they update themselves.

Edit some five+ years later: And the drat package now automates a lot of this, and shines particularly if you also use GitHub to serve the repository over http/https (but is useful for other or local hosting too).

Upvotes: 47

Shane
Shane

Reputation: 100204

Read the section of the Administrator guide.

Upvotes: 19

Related Questions