Retrieving information about a storage fault domain

post /v1/storage_fault_domain/info

Returns detailed information for a specific storage fault domain on your system.

Request headers

X-XSRF-TOKEN String required

XSRF token header for CSRF security. Can be obtained as the value of a cookie by performing a GET on /csrf.

Example: xXSRFTOKEN_example

Cookie String required

XSRF token header for CSRF security. Can be obtained as the value of a cookie by performing a GET on /csrf.

Example: cookie_example

CLIENT REQUEST

          curl -X 'POST'

        -H
        'Accept: application/json'
      
          -H
          'X-XSRF-TOKEN: xXSRFTOKEN_example'
          -H
          'Cookie: cookie_example'
      
      'http://localhost/v1/storage_fault_domain/info'
    
      -d
      '{
  "id" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'

import http.client

conn = http.client.HTTPConnection("undefinedundefined")

headers = {
    'X-XSRF-TOKEN': "SOME_STRING_VALUE",
    'Cookie': "SOME_STRING_VALUE"
    }

conn.request("POST", "/v1/storage_fault_domain/info", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

require 'uri'
require 'net/http'

url = URI("http://undefinedundefined/v1/storage_fault_domain/info")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["X-XSRF-TOKEN"] = 'SOME_STRING_VALUE'
request["Cookie"] = 'SOME_STRING_VALUE'

response = http.request(request)
puts response.read_body

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://undefinedundefined/v1/storage_fault_domain/info");
xhr.setRequestHeader("X-XSRF-TOKEN", "SOME_STRING_VALUE");
xhr.setRequestHeader("Cookie", "SOME_STRING_VALUE");

xhr.send(data);

HttpResponse<String> response = Unirest.post("http://undefinedundefined/v1/storage_fault_domain/info")
  .header("X-XSRF-TOKEN", "SOME_STRING_VALUE")
  .header("Cookie", "SOME_STRING_VALUE")
  .asString();

import Foundation

let headers = [
  "X-XSRF-TOKEN": "SOME_STRING_VALUE",
  "Cookie": "SOME_STRING_VALUE"
]

let request = NSMutableURLRequest(url: NSURL(string: "http://undefinedundefined/v1/storage_fault_domain/info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "http://undefinedundefined/v1/storage_fault_domain/info",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "Cookie: SOME_STRING_VALUE",
    "X-XSRF-TOKEN: SOME_STRING_VALUE"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "http://undefinedundefined/v1/storage_fault_domain/info");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "X-XSRF-TOKEN: SOME_STRING_VALUE");
headers = curl_slist_append(headers, "Cookie: SOME_STRING_VALUE");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

var client = new RestClient("http://undefinedundefined/v1/storage_fault_domain/info");
var request = new RestRequest(Method.POST);
request.AddHeader("X-XSRF-TOKEN", "SOME_STRING_VALUE");
request.AddHeader("Cookie", "SOME_STRING_VALUE");
IRestResponse response = client.Execute(request);

Body parameters

required

*/*

idstringrequireduuid

id of storage fault domain to get.

REQUEST
[*/* content]

Responses

Storage fault domain information

Body

application/json

idstringrequireduuid

ID of the storage fault domain.

namestringrequired

Name of the storage fault domain.

tagsstringrequired

Tags associated with the storage fault domain.

storageComponentsarrayrequired

Storage components in this fault domain

[

idintegerrequired

ID of the storage component

storageTypestringrequired

Type of the S3 storage component

storageComponentConfigobject

labelstring

Name of the storage component

Example:"Cloud AWS Bucket"

storageFaultDomainstring

storage fault domain associated with the storage component

storageClassstring

storage class associated with the storage component

hoststring

Host domain of the storage backend

Example:"URL of an existing storage component backend"

uriSchemestring (Enum)

Set to HTTPS to use a secure https connection to access the storage backend. Set to HTTP to use http

Allowed values:"HTTPS""HTTP"

portintegerint32

S3 HTTP port

bucketstring

Name of the bucket (the bucket must already exist)

regionstring

Specifies the S3 region.

authTypestring (Enum)

AWS Signature Version used for authenticating all interactions with Amazon S3. If this not provided on a create, server will default to V4.

Allowed values:"V2""V4"

siteAffiliationobject

idstringrequireduuid

UUID identifier for metadata.

useProxyboolean

Set to true to use a proxy server. Set to false to opt out. When useProxy is enabled, you must also specify proxyHost and proxyPort.

proxyHoststring

Proxy host (required if useProxy is set to true)

proxyPortintegerint32

Proxy domain port (required if useProxy is set to true)

proxyUserNamestring

User name for the proxy domain.

proxyPasswordstring

Password for the proxy domain.

proxyDomainstring

Proxy domain. This is not supported.

usePathStyleAlwaysboolean

If set to true, the path-style syntax is used for sending requests to the S3 storage. If set to false, the virtual-hosted style is used.

connectionTimeoutintegerint32

The amount of time (in milliseconds) that the HTTP connection will wait to establish a connection before giving up and timing out

socketTimeoutintegerint32

A timeout for reading from a connected socket

connectionTTLintegerint64

A connection time-to-live (TTL) for a request

maxConnectionsintegerint32

The maximum allowed number of open HTTP connections with the storage component

userAgentPrefixstring

The HTTP user agent prefix header used in requests to the storage component

socketSendBufferSizeHintintegerint32

The size hint (in bytes) for the low level TCP receive buffer (socketSendBufferSizeHint must also be specified)

socketRecvBufferSizeHintintegerint32

The size hint (in bytes) for the low level TCP send buffer (socketSendBufferSizeHint must also be specified)

managementProtocolstring

URL protocol definition

Example:"http or https"

managementHoststring

Host to use to establish a management connection

Example:"hostname.acme.org"

namespacestring

The namespace in which the data PersistentVolumeClaims are created in, as well as the Array custom resource.

dataPersistentVolumeNamestring

The name of the PersistentVolume to be used for storing data.

dataClaimCapacitystring

The amount of storage capacity to be used for storing data.

nodestring

The node to schedule taal to run with dynamic volumes.

arrayNamestring

The name of the array being added

arrayStorageTierstring

The storage tier or the underlying storage of the array

arrayNamespacestring

The namespace of the array components

arrayLunstring

The lun of the array

arrayHoststring

The host

arrayPortinteger

The port

statestring (Enum)

State of the storage component that indicates availability to server requests. When the component is ready for server requests, the status is ACTIVE. A PAUSED component is on an administrative pause. Accessibility issues caused by network, authentication, or certificates can cause the component to be INACCESSIBLE. A READ_ONLY component blocks all writes to data disks but allows reads. The component that has not been activated or failed to activate is UNVERIFIED. A component that is permanently unavailable for serving requests is DECOMMISSIONED.

Allowed values:"ACTIVE""PAUSED""INACCESSIBLE""READ_ONLY""UNVERIFIED""DECOMMISSIONED"

encryptedKeyVersionsstring

storageFaultDomainIdstringuuid

Storage fault domain ID of the storage component

storageClassIdinteger

Storage class ID of the storage component

storageCustomMetadataobject

Custom metadata of the storage component as a map of strings.

Additional propertiesstring

]

RESPONSE
{
  "id": "uuid string",
  "name": "example",
  "tags": "example",
  "storageComponents": [
    {
      "id": 0,
      "storageType": "example",
      "storageComponentConfig": {
        "label": "Cloud AWS Bucket",
        "storageFaultDomain": "example",
        "storageClass": "example",
        "host": "URL of an existing storage component backend",
        "uriScheme": "HTTPS",
        "port": 0,
        "bucket": "example",
        "region": "example",
        "authType": "V2",
        "siteAffiliation": {
          "id": "uuid string"
        },
        "useProxy": false,
        "proxyHost": "example",
        "proxyPort": 0,
        "proxyUserName": "example",
        "proxyPassword": "example",
        "proxyDomain": "example",
        "usePathStyleAlways": false,
        "connectionTimeout": 0,
        "socketTimeout": 0,
        "connectionTTL": 0,
        "maxConnections": 0,
        "userAgentPrefix": "example",
        "socketSendBufferSizeHint": 0,
        "socketRecvBufferSizeHint": 0,
        "managementProtocol": "http or https",
        "managementHost": "hostname.acme.org",
        "namespace": "example",
        "dataPersistentVolumeName": "example",
        "dataClaimCapacity": "example",
        "node": "example",
        "arrayName": "example",
        "arrayStorageTier": "example",
        "arrayNamespace": "example",
        "arrayLun": "example",
        "arrayHost": "example",
        "arrayPort": 0,
        "state": "ACTIVE",
        "encryptedKeyVersions": "example"
      },
      "storageFaultDomainId": "uuid string",
      "storageClassId": 0,
      "storageCustomMetadata": {
        "custom1": "data",
        "custom2": "data2"
      }
    }
  ]
}

An error occurred

Body

application/json

codestring

Error code

messagestring

Error message

detailsstring

Error details

RESPONSE
{
  "code": "example",
  "message": "example",
  "details": "example"
}