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, trimFromStart(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         copy = function(from, to, uuid)
  99         {
 100             collectionURL <- paste0(self$getWebDavHostName(), "c=", uuid, "/")
 101             fromURL <- paste0(collectionURL, from)
 102             toURL <- paste0(collectionURL, trimFromStart(to, "/"))
 103
 104             headers <- list("Authorization" = paste("OAuth2", self$token),
 105                             "Destination" = toURL)
 106
 107             serverResponse <- self$http$exec("COPY", fromURL, headers,
 108                                              retryTimes = self$numRetries)
 109
 110             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 111                 stop(paste("Server code:", serverResponse$status_code))
 112
 113             serverResponse
 114         },
 115
 116         getCollectionContent = function(uuid)
 117         {
 118             collectionURL <- URLencode(paste0(self$getWebDavHostName(),
 119                                               "c=", uuid))
 120
 121             headers <- list("Authorization" = paste("OAuth2", self$token))
 122
 123             response <- self$http$exec("PROPFIND", collectionURL, headers,
 124                                        retryTimes = self$numRetries)
 125
 126             if(all(response == ""))
 127                 stop("Response is empty, request may be misconfigured")
 128
 129             if(response$status_code < 200 || response$status_code >= 300)
 130                 stop(paste("Server code:", response$status_code))
 131
 132             self$httpParser$getFileNamesFromResponse(response, collectionURL)
 133         },
 134
 135         getResourceSize = function(relativePath, uuid)
 136         {
 137             collectionURL <- URLencode(paste0(self$getWebDavHostName(),
 138                                               "c=", uuid))
 139
 140             subcollectionURL <- paste0(collectionURL, "/", relativePath);
 141
 142             headers <- list("Authorization" = paste("OAuth2", self$token))
 143
 144             response <- self$http$exec("PROPFIND", subcollectionURL, headers,
 145                                        retryTimes = self$numRetries)
 146
 147             if(all(response == ""))
 148                 stop("Response is empty, request may be misconfigured")
 149
 150             if(response$status_code < 200 || response$status_code >= 300)
 151                 stop(paste("Server code:", response$status_code))
 152
 153             sizes <- self$httpParser$getFileSizesFromResponse(response,
 154                                                               collectionURL)
 155             as.numeric(sizes)
 156         },
 157
 158         read = function(relativePath, uuid, contentType = "raw", offset = 0, length = 0)
 159         {
 160             fileURL <- paste0(self$getWebDavHostName(),
 161                              "c=", uuid, "/", relativePath);
 162
 163             range <- paste0("bytes=", offset, "-")
 164
 165             if(length > 0)
 166                 range = paste0(range, offset + length - 1)
 167
 168             if(offset == 0 && length == 0)
 169             {
 170                 headers <- list(Authorization = paste("OAuth2", self$token))
 171             }
 172             else
 173             {
 174                 headers <- list(Authorization = paste("OAuth2", self$token),
 175                                 Range = range)
 176             }
 177
 178             if(!(contentType %in% self$httpParser$validContentTypes))
 179                 stop("Invalid contentType. Please use text or raw.")
 180
 181             serverResponse <- self$http$exec("GET", fileURL, headers,
 182                                              retryTimes = self$numRetries)
 183
 184             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 185                 stop(paste("Server code:", serverResponse$status_code))
 186
 187             self$httpParser$parseResponse(serverResponse, contentType)
 188         },
 189
 190         write = function(relativePath, uuid, content, contentType)
 191         {
 192             fileURL <- paste0(self$getWebDavHostName(),
 193                              "c=", uuid, "/", relativePath);
 194             headers <- list(Authorization = paste("OAuth2", self$token),
 195                             "Content-Type" = contentType)
 196             body <- content
 197
 198             serverResponse <- self$http$exec("PUT", fileURL, headers, body,
 199                                              retryTimes = self$numRetries)
 200
 201             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 202                 stop(paste("Server code:", serverResponse$status_code))
 203
 204             self$httpParser$parseResponse(serverResponse, "text")
 205         },
 206
 207         getConnection = function(relativePath, uuid, openMode)
 208         {
 209             fileURL <- paste0(self$getWebDavHostName(),
 210                               "c=", uuid, "/", relativePath);
 211             headers <- list(Authorization = paste("OAuth2", self$token))
 212
 213             conn <- self$http$getConnection(fileURL, headers, openMode)
 214         }
 215     ),
 216
 217     private = list(
 218
 219         webDavHostName = NULL,
 220         rawHostName    = NULL,
 221
 222         createNewFile = function(relativePath, uuid, contentType)
 223         {
 224             fileURL <- paste0(self$getWebDavHostName(), "c=",
 225                               uuid, "/", relativePath)
 226             headers <- list(Authorization = paste("OAuth2", self$token),
 227                             "Content-Type" = contentType)
 228             body <- NULL
 229
 230             serverResponse <- self$http$exec("PUT", fileURL, headers, body,
 231                                              retryTimes = self$numRetries)
 232
 233             if(serverResponse$status_code < 200 || serverResponse$status_code >= 300)
 234                 stop(paste("Server code:", serverResponse$status_code))
 235
 236             paste("File created:", relativePath)
 237         }
 238     ),
 239
 240     cloneable = FALSE
 241 )