sdk/R/R/RESTService.R

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