sdk/R/R/RESTService.R

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: Apache-2.0
   4
   5 RESTService <- R6::R6Class(
   6
   7     "RESTService",
   8
   9     public = list(
  10
  11         token      = NULL,
  12         http       = NULL,
  13         httpParser = NULL,
  14         numRetries = NULL,
  15
  16         initialize = function(token, rawHost,
  17                               http, httpParser,
  18                               numRetries     = 0,
  19                               webDavHostName = NULL)
  20         {
  21             self$token      <- token
  22             self$http       <- http
  23             self$httpParser <- httpParser
  24             self$numRetries <- numRetries
  25
  26             private$rawHostName    <- rawHost
  27             private$webDavHostName <- webDavHostName
  28         },
  29
  30         setNumConnRetries = function(newNumOfRetries)
  31         {
  32             self$numRetries <- newNumOfRetries
  33         },
  34
  35         getWebDavHostName = function()
  36         {
  37             if(is.null(private$webDavHostName))
  38             {
  39                 discoveryDocumentURL <- paste0("https://", private$rawHostName,
  40                                                "/discovery/v1/apis/arvados/v1/rest")
  41
  42                 headers <- list(Authorization = paste("OAuth2", self$token))
  43
  44                 serverResponse <- self$http$exec("GET", discoveryDocumentURL, headers,
  45                                                  retryTimes = self$numRetries)
  46
  47                 discoveryDocument <- self$httpParser$parseJSONResponse(serverResponse)
  48                 private$webDavHostName <- discoveryDocument$keepWebServiceUrl
  49
  50                 if(is.null(private$webDavHostName))
  51                     stop("Unable to find WebDAV server.")
  52             }
  53
  54             private$webDavHostName
  55         },
  56
  57         create = function(files, uuid)
  58         {
  59             sapply(files, function(filePath)
  60             {
  61                 private$createNewFile(filePath, uuid, "text/html")
  62             })
  63         },
  64
  65         delete = function(relativePath, uuid)
  66         {
  67             fileURL <- paste0(self$getWebDavHostName(), "c=",
  68                               uuid, "/", relativePath);
  69             headers <- list(Authorization = paste("OAuth2", self$token))
  70
  71             serverResponse <- self$http$exec("DELETE", fileURL, headers,
  72                                              retryTimes = self$numRetries)
  73
  74             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
  75                 stop(paste("Server code:", serverResponse$status_code))
  76
  77             serverResponse
  78         },
  79
  80         move = function(from, to, uuid)
  81         {
  82             collectionURL <- paste0(self$getWebDavHostName(), "c=", uuid, "/")
  83             fromURL <- paste0(collectionURL, from)
  84             toURL <- paste0(collectionURL, to)
  85
  86             headers <- list("Authorization" = paste("OAuth2", self$token),
  87                            "Destination" = toURL)
  88
  89             serverResponse <- self$http$exec("MOVE", fromURL, headers,
  90                                              retryTimes = self$numRetries)
  91
  92             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
  93                 stop(paste("Server code:", serverResponse$status_code))
  94
  95             serverResponse
  96         },
  97
  98         getCollectionContent = function(uuid)
  99         {
 100             collectionURL <- URLencode(paste0(self$getWebDavHostName(),
 101                                               "c=", uuid))
 102
 103             headers <- list("Authorization" = paste("OAuth2", self$token))
 104
 105             response <- self$http$exec("PROPFIND", collectionURL, headers,
 106                                        retryTimes = self$numRetries)
 107
 108             if(all(response == ""))
 109                 stop("Response is empty, request may be misconfigured")
 110
 111             if(response$status_code < 200 || response$status_code >= 300)
 112                 stop(paste("Server code:", response$status_code))
 113
 114             self$httpParser$getFileNamesFromResponse(response, collectionURL)
 115         },
 116
 117         getResourceSize = function(relativePath, uuid)
 118         {
 119             collectionURL <- URLencode(paste0(self$getWebDavHostName(),
 120                                               "c=", uuid))
 121
 122             subcollectionURL <- paste0(collectionURL, "/", relativePath);
 123
 124             headers <- list("Authorization" = paste("OAuth2", self$token))
 125
 126             response <- self$http$exec("PROPFIND", subcollectionURL, headers,
 127                                        retryTimes = self$numRetries)
 128
 129             if(all(response == ""))
 130                 stop("Response is empty, request may be misconfigured")
 131
 132             if(response$status_code < 200 || response$status_code >= 300)
 133                 stop(paste("Server code:", response$status_code))
 134
 135             sizes <- self$httpParser$getFileSizesFromResponse(response,
 136                                                               collectionURL)
 137             as.numeric(sizes)
 138         },
 139
 140         read = function(relativePath, uuid, contentType = "raw", offset = 0, length = 0)
 141         {
 142             fileURL <- paste0(self$getWebDavHostName(),
 143                              "c=", uuid, "/", relativePath);
 144
 145             range <- paste0("bytes=", offset, "-")
 146
 147             if(length > 0)
 148                 range = paste0(range, offset + length - 1)
 149
 150             if(offset == 0 && length == 0)
 151             {
 152                 headers <- list(Authorization = paste("OAuth2", self$token))
 153             }
 154             else
 155             {
 156                 headers <- list(Authorization = paste("OAuth2", self$token),
 157                                 Range = range)
 158             }
 159
 160             if(!(contentType %in% self$httpParser$validContentTypes))
 161                 stop("Invalid contentType. Please use text or raw.")
 162
 163             serverResponse <- self$http$exec("GET", fileURL, headers,
 164                                              retryTimes = self$numRetries)
 165
 166             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 167                 stop(paste("Server code:", serverResponse$status_code))
 168
 169             self$httpParser$parseResponse(serverResponse, contentType)
 170         },
 171
 172         write = function(relativePath, uuid, content, contentType)
 173         {
 174             fileURL <- paste0(self$getWebDavHostName(),
 175                              "c=", uuid, "/", relativePath);
 176             headers <- list(Authorization = paste("OAuth2", self$token),
 177                             "Content-Type" = contentType)
 178             body <- content
 179
 180             serverResponse <- self$http$exec("PUT", fileURL, headers, body,
 181                                              retryTimes = self$numRetries)
 182
 183             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 184                 stop(paste("Server code:", serverResponse$status_code))
 185
 186             self$httpParser$parseResponse(serverResponse, "text")
 187         },
 188
 189         getConnection = function(uuid, relativePath, openMode)
 190         {
 191             fileURL <- paste0(self$getWebDavHostName(),
 192                               "c=", uuid, "/", relativePath);
 193             headers <- list(Authorization = paste("OAuth2", self$token))
 194
 195             h <- curl::new_handle()
 196             curl::handle_setheaders(h, .list = headers)
 197
 198             conn <- curl::curl(url = fileURL, open = openMode, handle = h)
 199
 200             conn
 201         }
 202     ),
 203
 204     private = list(
 205
 206         webDavHostName = NULL,
 207         rawHostName    = NULL,
 208
 209         createNewFile = function(relativePath, uuid, contentType)
 210         {
 211             fileURL <- paste0(self$getWebDavHostName(), "c=",
 212                               uuid, "/", relativePath)
 213             headers <- list(Authorization = paste("OAuth2", self$token),
 214                             "Content-Type" = contentType)
 215             body <- NULL
 216
 217             serverResponse <- self$http$exec("PUT", fileURL, headers, body,
 218                                              retryTimes = self$numRetries)
 219
 220             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 221                 stop(paste("Server code:", serverResponse$status_code))
 222
 223             paste("File created:", relativePath)
 224         }
 225     ),
 226
 227     cloneable = FALSE
 228 )