Logo
NAV Navigation
Shell HTTP JavaScript Node.JS Ruby Python Java Go

Nasuni Management Console API v1.1.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Welcome to the Nasuni Management Console API Documentation.

The NMC API allows you to monitor and configure the Nasuni resources managed by your Nasuni Management Console in a simple programmatic way using conventional HTTP requests.

All endpoints described below should be prefixed with the base URL to your Nasuni Management console. The base URL for this version of the API is https://hostname/api/v1.1

Requests

The NMC API is based on REST principles and data resources are only accessable via HTTPS to ensure all communication is encrypted. In general, the API uses standard HTTP methods as described below:

MethodUsage
GETUsed for retrieving resources.
POSTUsed for creating resources.
PATCHUsed for updating resources.
DELETEUsed for deleting resources.
HEADUsed to determine a resource exists.

Responses

When a request is successful, a response body will typically be sent back in the form of a JSON object. Data returned in a JSON object is described for each endpoint below. A typical successful request will return with a status code in the 200 range.

Return codes in the 400 range typically indicate that there was an issue with the request that was sent. A status code in the 500 range generally indicates a server-side problem.

Pagination

When listing resources that contain many items, the result may be paginated. By default, 50 objects are returned per page. You may include both a limit and an offset query parameter. The limit indicates the maximum number of items to return. The offset indicates the starting position of the query in relation to the complete set of unpaginated items. For instance, to show only two results per page, you could add ?limit=2 to the end of your query.

Refer to the schema definition for additional information on Paging objects below.

Rate Limit

The number of authentication requests that can be made through the NMC API is currently limited to 10 per minute.

Most POST/PUT/PATCH/DELETE requests are limited to 1 request per second, all others are limited to 5 per second.

If a request was denied due to exceeding the rate limit, a response code of 429 is returned and an error named "throttled". To continue using the NMC API, the user will have to wait the duration of time noted in the description.

Non-Blocking API

The NMC API is non-blocking. In other words, any request made gets an immediate response.

Any request that isn't a listing will result in a message that is sent to the Filer. Generally, if a message is sent, you will get a 202 status code response with a message in the response body. This is the case for creating or updating resources.

To poll a message for its status, perform a GET request on the resource. A "synced" status means that the action was successfully performed. Otherwise, you will see that the resource has a "failed" or "error" status with appropriate detail on why the message failed.

Additionally, when creating or updating resources, there will be an applied resource in the response body that becomes available once the message is "synced".

Version History

Certain endpoints are now only usable with specific Filer and NMC releases. To use the endpoints listed in the specified versions, one must upgrade their Filer and NMC to that release.

Version 8.5

Bring path into cache
List AMQP Destinations
List AMQP Destinations for a Filer
Create an AMQP Destination
Get a single AMQP destination
Update an AMQP destination
Delete an AMQP destination
Try to make the given directory path
Set pinning mode
Set auto caching mode
Disable pinning mode on a folder
Disable auto cache mode on a folder

Version 8.8

List health status for all Filers
List health status for a Filer

Authentication

Before any calls to NMC API can be made, the 'Enable NMC API Access' permission must be set within the Nasuni Management Console on the group of any user wishing to have access.

To recieve an authentication token, you must first issue a POST request to the /auth/login/ endpoint passing username and password as request body parameters. A successful response will return a JSON object containing a token and expires date time. At this point the token should be used for all future requests and the username/password no longer needed. The format of the Authorization header is: Authorization: Token [TOKEN]

Auth

Login

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/auth/login/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'
POST https://hostname/api/v1.1/auth/login/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};
$.ajax({
  url: 'https://hostname/api/v1.1/auth/login/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "username": "string",
  "password": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};
fetch('https://hostname/api/v1.1/auth/login/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}
result = RestClient.post 'https://hostname/api/v1.1/auth/login/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}
r = requests.post('https://hostname/api/v1.1/auth/login/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/auth/login/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/auth/login/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /auth/login/

Authenticate a user's credentials to get an access token.

Body parameter

{
  "username": "string",
  "password": "string"
}

Parameters

Name In Type Required Description
body body object false none
» username body string true none
» password body string true none

Example responses

200 Response

{
  "token": "string",
  "expires": "string"
}

Responses

Status Meaning Description Schema
200 OK Success AuthToken
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Logout

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/auth/logout/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/auth/logout/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/auth/logout/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/auth/logout/',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/auth/logout/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/auth/logout/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/auth/logout/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/auth/logout/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /auth/logout/

De-authenticate user access token.

Example responses

200 Response

{
  "logged_out": true
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Status Code 200

Name Type Required Restrictions Description
» logged_out boolean false none If true, the user access token was successfully de-authenticated.

Index

View top-level endpoints

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /

Example responses

200 Response

{
  "auth": "string",
  "account": "string",
  "volumes": "string",
  "filers": "string",
  "messages": "string",
  "notifications": "string"
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Status Code 200

Name Type Required Restrictions Description
» auth string false none A link to the authentication resource.
» account string false none A link to the account resource.
» volumes string false none A link to the volumes resource.
» filers string false none A link to the filers resource.
» messages string false none A link to the messages resource.
» notifications string false none A link to the notifications resource.

Account

List cloud credentials

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/account/cloud-credentials/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/account/cloud-credentials/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/account/cloud-credentials/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/account/cloud-credentials/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/account/cloud-credentials/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/account/cloud-credentials/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/account/cloud-credentials/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/account/cloud-credentials/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /account/cloud-credentials/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "cred_id": "string",
      "name": "string",
      "filer_serial_number": "string",
      "cloud_provider": "string",
      "account": "string",
      "hostname": "string",
      "status": "string",
      "note": "string",
      "in_use": true,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Get a cloud credentials

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/account/cloud-credentials/{cred_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /account/cloud-credentials/{cred_id}/

Parameters

Name In Type Required Description
cred_id path string true Cloud Credential object identifier

Example responses

200 Response

{
  "cred_id": "string",
  "name": "string",
  "filer_serial_number": "string",
  "cloud_provider": "string",
  "account": "string",
  "hostname": "string",
  "status": "string",
  "note": "string",
  "in_use": true,
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success CloudCredential
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Filers

List Filers

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "build": "string",
      "description": "string",
      "guid": "string",
      "management_state": "self",
      "serial_number": "string",
      "settings": {
        "alert_thresholds": {
          "cpu_alert_settings": {
            "cpu_enabled": true,
            "cpu_threshold": 0,
            "cpu_duration": 0
          },
          "memory_alert_settings": {
            "memory_enabled": true,
            "memory_threshold": 0,
            "memory_duration": 0
          },
          "snapshot_alert_settings": {
            "snapshot_enabled": true,
            "snapshot_duration": 0
          }
        },
        "autoupdate": {
          "hour": 0,
          "sun": true,
          "mon": true,
          "tue": true,
          "wed": true,
          "thu": true,
          "fri": true,
          "sat": true
        },
        "cache_reserved": {
          "reserved": "unset",
          "maxv": 0,
          "minv": 0
        },
        "cifs": {
          "aio_support": true,
          "deny_access": true,
          "fruit_support": true,
          "proto_level": "SMB3",
          "restrict_anonymous": true,
          "roundup_size": "string",
          "smb3": true,
          "smb_encrypt": true,
          "unix_ext": true,
          "veto_files": true
        },
        "ftp": {
          "masq_address": "string",
          "idle_timeout": 0,
          "anon_user": "string",
          "anon_group": "string",
          "protocols": [
            "string"
          ]
        },
        "gl_settings": {
          "degrade_to_read_locks": true
        },
        "mobile_service": {
          "limit_single_device": true,
          "additional_api_port": 0,
          "session_expiration_time": 0,
          "allowed_devices": [
            "OSX"
          ]
        },
        "qos": {
          "rules": [
            {
              "days": {
                "mon": true,
                "tue": true,
                "wed": true,
                "thu": true,
                "fri": true,
                "sat": true,
                "sun": true
              },
              "start": 0,
              "stop": 0,
              "limit": 0,
              "ingress_limit": 0
            }
          ]
        },
        "quota_report_schedule": {
          "schedules": [
            {
              "days": {
                "sun": true,
                "mon": true,
                "tue": true,
                "wed": true,
                "thu": true,
                "fri": true,
                "sat": true
              },
              "activation_hour": 0,
              "admin_report": true,
              "user_report": true,
              "threshold": 0
            }
          ]
        },
        "remote_support": {
          "connected": true,
          "enabled": true,
          "running": true,
          "timeout": 0
        },
        "snmp": {
          "v2_enabled": true,
          "v2_community": "string",
          "v3_enabled": true,
          "v3_username": "string",
          "v3_password": "string",
          "sys_location": "string",
          "sys_contact": "string",
          "trap_ips": [
            "string"
          ]
        },
        "time": {
          "ntpservers": [
            "string"
          ],
          "timezone": "string",
          "current_time_utc": "string"
        }
      },
      "status": {
        "offline": true,
        "osversion": "string",
        "platform": {
          "platform_name": "string",
          "cpu": {
            "model": "string",
            "frequency": 0,
            "sockets": 0,
            "cores": 0
          },
          "memory": "string",
          "cache_status": {
            "size": 0,
            "used": 0,
            "dirty": 0,
            "free": 0,
            "percent_used": 0
          }
        },
        "updates": {
          "updates_available": true,
          "current_version": "string",
          "new_version": "string"
        },
        "uptime": 0
      },
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "cifsclients": {
          "href": "string",
          "method": "string"
        },
        "cifslocks": {
          "href": "string",
          "method": "string"
        },
        "ftpclients": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - Return status and configuration for all managed Filers. Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
management_state self
management_state nmc
management_state pending_self
management_state pending_nmc
reserved unset
reserved 5
reserved 10
reserved 15
reserved 20
reserved 25
reserved 30
reserved 35
reserved 40
reserved 45
reserved 50
reserved 55
reserved 60
reserved 65
reserved 70
reserved 75
reserved 80
reserved 85
reserved 90
proto_level SMB3
proto_level SMB2
proto_level

Get Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier

Example responses

200 Response

{
  "build": "string",
  "description": "string",
  "guid": "string",
  "management_state": "self",
  "serial_number": "string",
  "settings": {
    "alert_thresholds": {
      "cpu_alert_settings": {
        "cpu_enabled": true,
        "cpu_threshold": 0,
        "cpu_duration": 0
      },
      "memory_alert_settings": {
        "memory_enabled": true,
        "memory_threshold": 0,
        "memory_duration": 0
      },
      "snapshot_alert_settings": {
        "snapshot_enabled": true,
        "snapshot_duration": 0
      }
    },
    "autoupdate": {
      "hour": 0,
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "cache_reserved": {
      "reserved": "unset",
      "maxv": 0,
      "minv": 0
    },
    "cifs": {
      "aio_support": true,
      "deny_access": true,
      "fruit_support": true,
      "proto_level": "SMB3",
      "restrict_anonymous": true,
      "roundup_size": "string",
      "smb3": true,
      "smb_encrypt": true,
      "unix_ext": true,
      "veto_files": true
    },
    "ftp": {
      "masq_address": "string",
      "idle_timeout": 0,
      "anon_user": "string",
      "anon_group": "string",
      "protocols": [
        "string"
      ]
    },
    "gl_settings": {
      "degrade_to_read_locks": true
    },
    "mobile_service": {
      "limit_single_device": true,
      "additional_api_port": 0,
      "session_expiration_time": 0,
      "allowed_devices": [
        "OSX"
      ]
    },
    "qos": {
      "rules": [
        {
          "days": {
            "mon": true,
            "tue": true,
            "wed": true,
            "thu": true,
            "fri": true,
            "sat": true,
            "sun": true
          },
          "start": 0,
          "stop": 0,
          "limit": 0,
          "ingress_limit": 0
        }
      ]
    },
    "quota_report_schedule": {
      "schedules": [
        {
          "days": {
            "sun": true,
            "mon": true,
            "tue": true,
            "wed": true,
            "thu": true,
            "fri": true,
            "sat": true
          },
          "activation_hour": 0,
          "admin_report": true,
          "user_report": true,
          "threshold": 0
        }
      ]
    },
    "remote_support": {
      "connected": true,
      "enabled": true,
      "running": true,
      "timeout": 0
    },
    "snmp": {
      "v2_enabled": true,
      "v2_community": "string",
      "v3_enabled": true,
      "v3_username": "string",
      "v3_password": "string",
      "sys_location": "string",
      "sys_contact": "string",
      "trap_ips": [
        "string"
      ]
    },
    "time": {
      "ntpservers": [
        "string"
      ],
      "timezone": "string",
      "current_time_utc": "string"
    }
  },
  "status": {
    "offline": true,
    "osversion": "string",
    "platform": {
      "platform_name": "string",
      "cpu": {
        "model": "string",
        "frequency": 0,
        "sockets": 0,
        "cores": 0
      },
      "memory": "string",
      "cache_status": {
        "size": 0,
        "used": 0,
        "dirty": 0,
        "free": 0,
        "percent_used": 0
      }
    },
    "updates": {
      "updates_available": true,
      "current_version": "string",
      "new_version": "string"
    },
    "uptime": 0
  },
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "cifsclients": {
      "href": "string",
      "method": "string"
    },
    "cifslocks": {
      "href": "string",
      "method": "string"
    },
    "ftpclients": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK - Return status and configuration for the specified managed Filer. Filer
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Update a Filer

Code samples

# You can also use wget
curl -X PATCH https://hostname/api/v1.1/filers/{filer_serial}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
PATCH https://hostname/api/v1.1/filers/{filer_serial}/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/',
  method: 'patch',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "description": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.patch 'https://hostname/api/v1.1/filers/{filer_serial}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.patch('https://hostname/api/v1.1/filers/{filer_serial}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://hostname/api/v1.1/filers/{filer_serial}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /filers/{filer_serial}/

Body parameter

{
  "description": "string"
}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
body body Filer true none

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message

List AMQP Destinations

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/amqp-audit-destinations/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/amqp-audit-destinations/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/amqp-audit-destinations/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/amqp-audit-destinations/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/amqp-audit-destinations/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/amqp-audit-destinations/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/amqp-audit-destinations/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/amqp-audit-destinations/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/amqp-audit-destinations/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "name": "string",
      "filer_serial_number": "string",
      "hostname": "string",
      "port": 0,
      "ca_cert": "string",
      "username": "string",
      "password": "string",
      "vhost": "string",
      "exchange": "string",
      "routing_key": "string",
      "headers": {},
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of all AMQP Destination across all Filers Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List AMQP Destinations for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/amqp-audit-destinations/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "name": "string",
      "filer_serial_number": "string",
      "hostname": "string",
      "port": 0,
      "ca_cert": "string",
      "username": "string",
      "password": "string",
      "vhost": "string",
      "exchange": "string",
      "routing_key": "string",
      "headers": {},
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of AMQP Destinations on a specific Filer Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Create an AMQP Destination

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "filer_serial_number": "string",
  "hostname": "string",
  "port": 0,
  "ca_cert": "string",
  "username": "string",
  "password": "string",
  "vhost": "string",
  "exchange": "string",
  "routing_key": "string",
  "headers": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /filers/{filer_serial}/amqp-audit-destinations/

Body parameter

{
  "name": "string",
  "filer_serial_number": "string",
  "hostname": "string",
  "port": 0,
  "ca_cert": "string",
  "username": "string",
  "password": "string",
  "vhost": "string",
  "exchange": "string",
  "routing_key": "string",
  "headers": {}
}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
body body any true none

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Get a single AMQP destination

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
amqp_destination_name path string true AMQP Destination name

Example responses

200 Response

{
  "name": "string",
  "filer_serial_number": "string",
  "hostname": "string",
  "port": 0,
  "ca_cert": "string",
  "username": "string",
  "password": "string",
  "vhost": "string",
  "exchange": "string",
  "routing_key": "string",
  "headers": {},
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK - Information about the specified AMQP Destination AMQPAuditDestination
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Update an AMQP destination

Code samples

# You can also use wget
curl -X PATCH https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
PATCH https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name} HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
  method: 'patch',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "filer_serial_number": "string",
  "hostname": "string",
  "port": 0,
  "ca_cert": "string",
  "username": "string",
  "password": "string",
  "vhost": "string",
  "exchange": "string",
  "routing_key": "string",
  "headers": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.patch 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.patch('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}

Body parameter

{
  "name": "string",
  "filer_serial_number": "string",
  "hostname": "string",
  "port": 0,
  "ca_cert": "string",
  "username": "string",
  "password": "string",
  "vhost": "string",
  "exchange": "string",
  "routing_key": "string",
  "headers": {}
}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
amqp_destination_name path string true AMQP Destination name
body body AMQPAuditDestination true none

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Delete an AMQP destination

Code samples

# You can also use wget
curl -X DELETE https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
DELETE https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.delete 'https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.delete('https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hostname/api/v1.1/filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /filers/{filer_serial}/amqp-audit-destinations/{amqp_destination_name}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
amqp_destination_name path string true AMQP Destination name

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List CIFS clients

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/cifsclients/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/cifsclients/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/cifsclients/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/cifsclients/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/cifsclients/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/cifsclients/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/cifsclients/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/cifsclients/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/cifsclients/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "filer_serial_number": "string",
      "share_id": 0,
      "user": "string",
      "client": "string",
      "client_name": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "share": {
          "href": "string",
          "method": "string"
        },
        "locks": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of all CIFS clients across all Filers Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List CIFS clients for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/cifsclients/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "filer_serial_number": "string",
      "share_id": 0,
      "user": "string",
      "client": "string",
      "client_name": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "share": {
          "href": "string",
          "method": "string"
        },
        "locks": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of CIFS clients connected to the specified Filer Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Get CIFS client

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/cifsclients/{cifs_client_id}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
cifs_client_id path string true CIFS client object identifier

Example responses

200 Response

{
  "id": "string",
  "filer_serial_number": "string",
  "share_id": 0,
  "user": "string",
  "client": "string",
  "client_name": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "share": {
      "href": "string",
      "method": "string"
    },
    "locks": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK - Information about the specified CIFS client FilerCIFSClient
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List CIFS file locks

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/cifsclients/locks/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/cifsclients/locks/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/cifsclients/locks/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/cifsclients/locks/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/cifsclients/locks/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/cifsclients/locks/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/cifsclients/locks/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/cifsclients/locks/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/cifsclients/locks/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "cifsclient_id": "string",
      "share_id": 0,
      "path": "string",
      "type": "string",
      "user": "string",
      "client": "string",
      "client_name": "string",
      "links": {
        "filer": {
          "href": "string",
          "method": "string"
        },
        "cifsclient": {
          "href": "string",
          "method": "string"
        },
        "share": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of all CIFS file locks across all Filers Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List CIFS file locks for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/locks/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/cifsclients/locks/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "cifsclient_id": "string",
      "share_id": 0,
      "path": "string",
      "type": "string",
      "user": "string",
      "client": "string",
      "client_name": "string",
      "links": {
        "filer": {
          "href": "string",
          "method": "string"
        },
        "cifsclient": {
          "href": "string",
          "method": "string"
        },
        "share": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of CIFS file locks held by clients of the specified Filer Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List CIFS file locks for a client

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/cifsclients/{cifs_client_id}/locks/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
cifs_client_id path string true CIFS client object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "cifsclient_id": "string",
      "share_id": 0,
      "path": "string",
      "type": "string",
      "user": "string",
      "client": "string",
      "client_name": "string",
      "links": {
        "filer": {
          "href": "string",
          "method": "string"
        },
        "cifsclient": {
          "href": "string",
          "method": "string"
        },
        "share": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of CIFS file locks held by the specified client Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List FTP clients

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/ftpclients/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/ftpclients/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/ftpclients/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/ftpclients/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/ftpclients/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/ftpclients/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/ftpclients/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/ftpclients/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/ftpclients/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "filer_serial_number": "string",
      "protocol": "ftp",
      "client": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of all FTP clients across Filers Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
protocol ftp
protocol sftp

List FTP clients for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/ftpclients/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "filer_serial_number": "string",
      "protocol": "ftp",
      "client": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK OK - List of FTP clients connected to the specified Filer Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
protocol ftp
protocol sftp

Get FTP client

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/ftpclients/{ftp_client_id}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/ftpclients/{ftp_client_id}

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
ftp_client_id path string true FTP client object identifier

Example responses

200 Response

{
  "id": "string",
  "filer_serial_number": "string",
  "protocol": "ftp",
  "client": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK - Description of the specified FTP client FilerFTPClient
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List encryption keys

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/encryption-keys/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/encryption-keys/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/encryption-keys/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/encryption-keys/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/encryption-keys/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/encryption-keys/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/encryption-keys/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/encryption-keys/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/encryption-keys/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "fingerprint": "string",
      "key_id": "string",
      "name": "string",
      "algorithm": "string",
      "length": 0,
      "escrowed": true,
      "used": true,
      "is_backup_key": true,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List encryption keys for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/encryption-keys/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "fingerprint": "string",
      "key_id": "string",
      "name": "string",
      "algorithm": "string",
      "length": 0,
      "escrowed": true,
      "used": true,
      "is_backup_key": true,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Get a Filer encryption key

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/encryption-keys/{encryption_key_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/encryption-keys/{encryption_key_id}/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
encryption_key_id path integer true Encryption key object identifier

Example responses

200 Response

{
  "id": 0,
  "filer_serial_number": "string",
  "fingerprint": "string",
  "key_id": "string",
  "name": "string",
  "algorithm": "string",
  "length": 0,
  "escrowed": true,
  "used": true,
  "is_backup_key": true,
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success EncryptionKey
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List health status for all Filers

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/health/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/health/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/health/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/health/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/health/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/health/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/health/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/health/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/health/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "last_updated": "string",
      "smb": "Healthy",
      "network": "Healthy",
      "filesystem": "Healthy",
      "unityfs": "Healthy",
      "nfs": "Healthy",
      "memory": "Healthy",
      "services": "Healthy",
      "directoryservices": "Healthy",
      "disk": "Healthy",
      "cpu": "Healthy",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
smb Healthy
smb Warning
smb Unhealthy
network Healthy
network Warning
network Unhealthy
filesystem Healthy
filesystem Warning
filesystem Unhealthy
unityfs Healthy
unityfs Warning
unityfs Unhealthy
nfs Healthy
nfs Warning
nfs Unhealthy
memory Healthy
memory Warning
memory Unhealthy
services Healthy
services Warning
services Unhealthy
directoryservices Healthy
directoryservices Warning
directoryservices Unhealthy
disk Healthy
disk Warning
disk Unhealthy
cpu Healthy
cpu Warning
cpu Unhealthy

List health status for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/filers/{filer_serial}/health/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/filers/{filer_serial}/health/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/filers/{filer_serial}/health/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/filers/{filer_serial}/health/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/filers/{filer_serial}/health/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/filers/{filer_serial}/health/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/filers/{filer_serial}/health/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/filers/{filer_serial}/health/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /filers/{filer_serial}/health/

Parameters

Name In Type Required Description
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "last_updated": "string",
      "smb": "Healthy",
      "network": "Healthy",
      "filesystem": "Healthy",
      "unityfs": "Healthy",
      "nfs": "Healthy",
      "memory": "Healthy",
      "services": "Healthy",
      "directoryservices": "Healthy",
      "disk": "Healthy",
      "cpu": "Healthy",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
smb Healthy
smb Warning
smb Unhealthy
network Healthy
network Warning
network Unhealthy
filesystem Healthy
filesystem Warning
filesystem Unhealthy
unityfs Healthy
unityfs Warning
unityfs Unhealthy
nfs Healthy
nfs Warning
nfs Unhealthy
memory Healthy
memory Warning
memory Unhealthy
services Healthy
services Warning
services Unhealthy
directoryservices Healthy
directoryservices Warning
directoryservices Unhealthy
disk Healthy
disk Warning
disk Unhealthy
cpu Healthy
cpu Warning
cpu Unhealthy

Volumes

List volumes

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "guid": "string",
      "filer_serial_number": "string",
      "name": "string",
      "nmc_managed": true,
      "protocols": {
        "permissions_policy": "NTFS60",
        "protocols": [
          "CIFS"
        ]
      },
      "antivirus_service": {
        "enabled": true,
        "days": {
          "sun": true,
          "mon": true,
          "tue": true,
          "wed": true,
          "thu": true,
          "fri": true,
          "sat": true
        },
        "check_files_immediately": true,
        "allday": true,
        "start": 0,
        "stop": 0,
        "frequency": 0
      },
      "remote_access": {
        "enabled": true,
        "access_permissions": "readonly",
        "filer_access": [
          {
            "filer_serial_number": "string",
            "permission": "disabled"
          }
        ]
      },
      "quota": 0,
      "case_sensitive": true,
      "snapshot_retention": {
        "retain": "INFINITE",
        "number": 0,
        "years": 0,
        "months": 0,
        "days": 0
      },
      "cloud_io": {
        "dedupe": true,
        "compression": true,
        "chunk_size": 0
      },
      "provider": {
        "cred_id": "string",
        "name": "string",
        "shortname": "amazons3",
        "location": "string"
      },
      "auth": {
        "authenticated_access": true,
        "policy": "ads",
        "policy_label": "string"
      },
      "root_handle": "string",
      "bucket": "string",
      "account_name": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "filer_settings": {
          "href": "string",
          "method": "string"
        },
        "filer_connections": {
          "href": "string",
          "method": "string"
        },
        "shares": {
          "href": "string",
          "method": "string"
        },
        "exports": {
          "href": "string",
          "method": "string"
        },
        "ftp_directories": {
          "href": "string",
          "method": "string"
        },
        "antivirus_violations": {
          "href": "string",
          "method": "string"
        },
        "folder_quotas": {
          "href": "string",
          "method": "string"
        },
        "snapshots": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
permissions_policy NTFS60
permissions_policy NTFSONLY710
permissions_policy POSIX60
permissions_policy MODEBITS60
permissions_policy PUBLICMODE60
access_permissions readonly
access_permissions readwrite
access_permissions custom
permission disabled
permission readonly
permission readwrite
retain INFINITE
retain BY_COUNT
retain BY_AGE
shortname amazons3
shortname azure
shortname cleversafe
shortname hcp
shortname ibmcos
shortname vipr
policy ads
policy ldapds
policy public

Create volume

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "filer_serial_number": "string",
  "name": "string",
  "protocols": {
    "permissions_policy": "NTFS60",
    "protocols": [
      "CIFS"
    ]
  },
  "antivirus_service": {
    "enabled": true,
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "check_files_immediately": true,
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0
  },
  "quota": 0,
  "snapshot_retention": {
    "retain": "INFINITE",
    "number": 0,
    "years": 0,
    "months": 0,
    "days": 0
  },
  "cloud_io": {
    "dedupe": true,
    "compression": true,
    "chunk_size": 0
  },
  "provider": {
    "cred_id": "string",
    "name": "string",
    "shortname": "amazons3",
    "location": "string"
  },
  "auth": {
    "authenticated_access": true,
    "policy": "ads",
    "policy_label": "string"
  },
  "options": {
    "auto_provision_cred": false,
    "create_new_key": true,
    "key_name": "string",
    "create_default_access_point": true
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/

Body parameter

{
  "filer_serial_number": "string",
  "name": "string",
  "protocols": {
    "permissions_policy": "NTFS60",
    "protocols": [
      "CIFS"
    ]
  },
  "antivirus_service": {
    "enabled": true,
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "check_files_immediately": true,
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0
  },
  "quota": 0,
  "snapshot_retention": {
    "retain": "INFINITE",
    "number": 0,
    "years": 0,
    "months": 0,
    "days": 0
  },
  "cloud_io": {
    "dedupe": true,
    "compression": true,
    "chunk_size": 0
  },
  "provider": {
    "cred_id": "string",
    "name": "string",
    "shortname": "amazons3",
    "location": "string"
  },
  "auth": {
    "authenticated_access": true,
    "policy": "ads",
    "policy_label": "string"
  },
  "options": {
    "auto_provision_cred": false,
    "create_new_key": true,
    "key_name": "string",
    "create_default_access_point": true
  }
}

Parameters

Name In Type Required Description
body body any true none

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message

Get volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier

Example responses

200 Response

{
  "guid": "string",
  "filer_serial_number": "string",
  "name": "string",
  "nmc_managed": true,
  "protocols": {
    "permissions_policy": "NTFS60",
    "protocols": [
      "CIFS"
    ]
  },
  "antivirus_service": {
    "enabled": true,
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "check_files_immediately": true,
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0
  },
  "remote_access": {
    "enabled": true,
    "access_permissions": "readonly",
    "filer_access": [
      {
        "filer_serial_number": "string",
        "permission": "disabled"
      }
    ]
  },
  "quota": 0,
  "case_sensitive": true,
  "snapshot_retention": {
    "retain": "INFINITE",
    "number": 0,
    "years": 0,
    "months": 0,
    "days": 0
  },
  "cloud_io": {
    "dedupe": true,
    "compression": true,
    "chunk_size": 0
  },
  "provider": {
    "cred_id": "string",
    "name": "string",
    "shortname": "amazons3",
    "location": "string"
  },
  "auth": {
    "authenticated_access": true,
    "policy": "ads",
    "policy_label": "string"
  },
  "root_handle": "string",
  "bucket": "string",
  "account_name": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "filer_settings": {
      "href": "string",
      "method": "string"
    },
    "filer_connections": {
      "href": "string",
      "method": "string"
    },
    "shares": {
      "href": "string",
      "method": "string"
    },
    "exports": {
      "href": "string",
      "method": "string"
    },
    "ftp_directories": {
      "href": "string",
      "method": "string"
    },
    "antivirus_violations": {
      "href": "string",
      "method": "string"
    },
    "folder_quotas": {
      "href": "string",
      "method": "string"
    },
    "snapshots": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success Volume
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Update volume

Code samples

# You can also use wget
curl -X PATCH https://hostname/api/v1.1/volumes/{volume_guid}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
PATCH https://hostname/api/v1.1/volumes/{volume_guid}/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/',
  method: 'patch',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "filer_serial_number": "string",
  "name": "string",
  "protocols": {
    "permissions_policy": "NTFS60",
    "protocols": [
      "CIFS"
    ]
  },
  "antivirus_service": {
    "enabled": true,
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "check_files_immediately": true,
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0
  },
  "quota": 0,
  "snapshot_retention": {
    "retain": "INFINITE",
    "number": 0,
    "years": 0,
    "months": 0,
    "days": 0
  },
  "cloud_io": {
    "dedupe": true,
    "compression": true,
    "chunk_size": 0
  },
  "provider": {
    "cred_id": "string",
    "name": "string",
    "shortname": "amazons3",
    "location": "string"
  },
  "auth": {
    "authenticated_access": true,
    "policy": "ads",
    "policy_label": "string"
  },
  "options": {
    "auto_provision_cred": false,
    "create_new_key": true,
    "key_name": "string",
    "create_default_access_point": true
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.patch 'https://hostname/api/v1.1/volumes/{volume_guid}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.patch('https://hostname/api/v1.1/volumes/{volume_guid}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://hostname/api/v1.1/volumes/{volume_guid}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /volumes/{volume_guid}/

Body parameter

{
  "filer_serial_number": "string",
  "name": "string",
  "protocols": {
    "permissions_policy": "NTFS60",
    "protocols": [
      "CIFS"
    ]
  },
  "antivirus_service": {
    "enabled": true,
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "check_files_immediately": true,
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0
  },
  "quota": 0,
  "snapshot_retention": {
    "retain": "INFINITE",
    "number": 0,
    "years": 0,
    "months": 0,
    "days": 0
  },
  "cloud_io": {
    "dedupe": true,
    "compression": true,
    "chunk_size": 0
  },
  "provider": {
    "cred_id": "string",
    "name": "string",
    "shortname": "amazons3",
    "location": "string"
  },
  "auth": {
    "authenticated_access": true,
    "policy": "ads",
    "policy_label": "string"
  },
  "options": {
    "auto_provision_cred": false,
    "create_new_key": true,
    "key_name": "string",
    "create_default_access_point": true
  }
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
body body Volume true none

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message

List Filer settings for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "guid": "string",
      "filer_serial_number": "string",
      "name": "string",
      "type": "master",
      "sync_schedule": {
        "days": {
          "sun": true,
          "mon": true,
          "tue": true,
          "wed": true,
          "thu": true,
          "fri": true,
          "sat": true
        },
        "allday": true,
        "start": 0,
        "stop": 0,
        "frequency": 0,
        "auto_cache_allowed": true,
        "auto_cache_min_file_size": 0
      },
      "snapshot_schedule": {
        "days": {
          "sun": true,
          "mon": true,
          "tue": true,
          "wed": true,
          "thu": true,
          "fri": true,
          "sat": true
        },
        "allday": true,
        "start": 0,
        "stop": 0,
        "frequency": 0
      },
      "snapshot_access": true,
      "file_alerts_service": {
        "enabled": true,
        "patterns": [
          "string"
        ]
      },
      "auditing": {
        "enabled": true,
        "collapse": true,
        "output_type": "csv",
        "destination": "string",
        "events": {
          "create": true,
          "delete": true,
          "rename": true,
          "close": true,
          "security": true,
          "metadata": true,
          "write": true,
          "read": true
        },
        "logs": {
          "prune_audit_logs": true,
          "days_to_keep": 0,
          "exclude_by_default": true,
          "include_takes_priority": true,
          "include_patterns": [
            "string"
          ],
          "exclude_patterns": [
            "string"
          ],
          "user_blacklist": [
            "string"
          ],
          "protocol_whitelist": [
            "CIFS"
          ]
        },
        "syslog_export": true
      },
      "status": {
        "accessible_data": 0,
        "data_not_yet_protected": 0,
        "first_snapshot": "string",
        "last_snapshot": "string",
        "last_snapshot_start": "string",
        "last_snapshot_end": "string",
        "last_snapshot_version": 0,
        "snapshot_status": "idle",
        "snapshot_percent": 0,
        "ftp_dir_count": 0,
        "export_count": 0,
        "share_count": 0
      },
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "shares": {
          "href": "string",
          "method": "string"
        },
        "exports": {
          "href": "string",
          "method": "string"
        },
        "ftp_directories": {
          "href": "string",
          "method": "string"
        },
        "antivirus_violations": {
          "href": "string",
          "method": "string"
        },
        "snapshots": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
type master
type remote
output_type csv
output_type amqp
output_type varonis
snapshot_status idle
snapshot_status pending
snapshot_status in_progress

Get volume settings for a Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier

Example responses

200 Response

{
  "guid": "string",
  "filer_serial_number": "string",
  "name": "string",
  "type": "master",
  "sync_schedule": {
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0,
    "auto_cache_allowed": true,
    "auto_cache_min_file_size": 0
  },
  "snapshot_schedule": {
    "days": {
      "sun": true,
      "mon": true,
      "tue": true,
      "wed": true,
      "thu": true,
      "fri": true,
      "sat": true
    },
    "allday": true,
    "start": 0,
    "stop": 0,
    "frequency": 0
  },
  "snapshot_access": true,
  "file_alerts_service": {
    "enabled": true,
    "patterns": [
      "string"
    ]
  },
  "auditing": {
    "enabled": true,
    "collapse": true,
    "output_type": "csv",
    "destination": "string",
    "events": {
      "create": true,
      "delete": true,
      "rename": true,
      "close": true,
      "security": true,
      "metadata": true,
      "write": true,
      "read": true
    },
    "logs": {
      "prune_audit_logs": true,
      "days_to_keep": 0,
      "exclude_by_default": true,
      "include_takes_priority": true,
      "include_patterns": [
        "string"
      ],
      "exclude_patterns": [
        "string"
      ],
      "user_blacklist": [
        "string"
      ],
      "protocol_whitelist": [
        "CIFS"
      ]
    },
    "syslog_export": true
  },
  "status": {
    "accessible_data": 0,
    "data_not_yet_protected": 0,
    "first_snapshot": "string",
    "last_snapshot": "string",
    "last_snapshot_start": "string",
    "last_snapshot_end": "string",
    "last_snapshot_version": 0,
    "snapshot_status": "idle",
    "snapshot_percent": 0,
    "ftp_dir_count": 0,
    "export_count": 0,
    "share_count": 0
  },
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "shares": {
      "href": "string",
      "method": "string"
    },
    "exports": {
      "href": "string",
      "method": "string"
    },
    "ftp_directories": {
      "href": "string",
      "method": "string"
    },
    "antivirus_violations": {
      "href": "string",
      "method": "string"
    },
    "snapshots": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success VolumeFilerSetting
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Update the settings for a volume on a specific Filer

Code samples

# You can also use wget
curl -X PATCH https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
PATCH https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/',
  method: 'patch',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "auditing": {
    "enabled": true,
    "collapse": true,
    "output_type": "csv",
    "destination": "string",
    "events": {
      "create": true,
      "delete": true,
      "rename": true,
      "close": true,
      "security": true,
      "metadata": true,
      "write": true,
      "read": true
    },
    "logs": {
      "prune_audit_logs": true,
      "days_to_keep": 0,
      "exclude_by_default": true,
      "include_takes_priority": true,
      "include_patterns": [
        "string"
      ],
      "exclude_patterns": [
        "string"
      ],
      "user_blacklist": [
        "string"
      ],
      "protocol_whitelist": [
        "CIFS"
      ]
    },
    "syslog_export": true
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.patch 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.patch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /volumes/{volume_guid}/filers/{filer_serial}/

Body parameter

{
  "auditing": {
    "enabled": true,
    "collapse": true,
    "output_type": "csv",
    "destination": "string",
    "events": {
      "create": true,
      "delete": true,
      "rename": true,
      "close": true,
      "security": true,
      "metadata": true,
      "write": true,
      "read": true
    },
    "logs": {
      "prune_audit_logs": true,
      "days_to_keep": 0,
      "exclude_by_default": true,
      "include_takes_priority": true,
      "include_patterns": [
        "string"
      ],
      "exclude_patterns": [
        "string"
      ],
      "user_blacklist": [
        "string"
      ],
      "protocol_whitelist": [
        "CIFS"
      ]
    },
    "syslog_export": true
  }
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
body body VolumeFilerSetting true Volume settings to update for a Filer

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filers volume has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message

List shares

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/shares/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/shares/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/shares/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/shares/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/shares/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/shares/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/shares/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/shares/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/shares/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": false,
      "browseable": true,
      "hosts_allow": "",
      "hide_unreadable": true,
      "enable_previous_vers": false,
      "case_sensitive": false,
      "enable_snapshot_dirs": false,
      "homedir_support": 0,
      "mobile": false,
      "browser_access": false,
      "browser_access_settings": {
        "shared_links_enabled": false,
        "link_force_password": true,
        "link_allow_rw": false,
        "external_share_url": "string",
        "link_expire_limit": 0,
        "link_auth": {
          "authall": true,
          "allow_groups_ro": [
            "string"
          ],
          "allow_groups_rw": [
            "string"
          ],
          "deny_groups": [
            "string"
          ],
          "allow_users_ro": [
            "string"
          ],
          "allow_users_rw": [
            "string"
          ],
          "deny_users": [
            "string"
          ]
        }
      },
      "aio_enabled": true,
      "veto_files": "",
      "fruit_enabled": false,
      "smb_encrypt": "",
      "auth": {
        "authall": true,
        "rw_groups": [
          "string"
        ],
        "ro_groups": [
          "string"
        ],
        "deny_groups": [
          "string"
        ],
        "ro_users": [
          "string"
        ],
        "rw_users": [
          "string"
        ],
        "deny_users": [
          "string"
        ]
      },
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
homedir_support 0
homedir_support 2
smb_encrypt
smb_encrypt desired
smb_encrypt required

List shares for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/shares/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/shares/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": false,
      "browseable": true,
      "hosts_allow": "",
      "hide_unreadable": true,
      "enable_previous_vers": false,
      "case_sensitive": false,
      "enable_snapshot_dirs": false,
      "homedir_support": 0,
      "mobile": false,
      "browser_access": false,
      "browser_access_settings": {
        "shared_links_enabled": false,
        "link_force_password": true,
        "link_allow_rw": false,
        "external_share_url": "string",
        "link_expire_limit": 0,
        "link_auth": {
          "authall": true,
          "allow_groups_ro": [
            "string"
          ],
          "allow_groups_rw": [
            "string"
          ],
          "deny_groups": [
            "string"
          ],
          "allow_users_ro": [
            "string"
          ],
          "allow_users_rw": [
            "string"
          ],
          "deny_users": [
            "string"
          ]
        }
      },
      "aio_enabled": true,
      "veto_files": "",
      "fruit_enabled": false,
      "smb_encrypt": "",
      "auth": {
        "authall": true,
        "rw_groups": [
          "string"
        ],
        "ro_groups": [
          "string"
        ],
        "deny_groups": [
          "string"
        ],
        "ro_users": [
          "string"
        ],
        "rw_users": [
          "string"
        ],
        "deny_users": [
          "string"
        ]
      },
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
homedir_support 0
homedir_support 2
smb_encrypt
smb_encrypt desired
smb_encrypt required

List shares for a volume and Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/shares/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": false,
      "browseable": true,
      "hosts_allow": "",
      "hide_unreadable": true,
      "enable_previous_vers": false,
      "case_sensitive": false,
      "enable_snapshot_dirs": false,
      "homedir_support": 0,
      "mobile": false,
      "browser_access": false,
      "browser_access_settings": {
        "shared_links_enabled": false,
        "link_force_password": true,
        "link_allow_rw": false,
        "external_share_url": "string",
        "link_expire_limit": 0,
        "link_auth": {
          "authall": true,
          "allow_groups_ro": [
            "string"
          ],
          "allow_groups_rw": [
            "string"
          ],
          "deny_groups": [
            "string"
          ],
          "allow_users_ro": [
            "string"
          ],
          "allow_users_rw": [
            "string"
          ],
          "deny_users": [
            "string"
          ]
        }
      },
      "aio_enabled": true,
      "veto_files": "",
      "fruit_enabled": false,
      "smb_encrypt": "",
      "auth": {
        "authall": true,
        "rw_groups": [
          "string"
        ],
        "ro_groups": [
          "string"
        ],
        "deny_groups": [
          "string"
        ],
        "ro_users": [
          "string"
        ],
        "rw_users": [
          "string"
        ],
        "deny_users": [
          "string"
        ]
      },
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
homedir_support 0
homedir_support 2
smb_encrypt
smb_encrypt desired
smb_encrypt required

Create share

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": false,
  "browseable": true,
  "hosts_allow": "",
  "hide_unreadable": true,
  "enable_previous_vers": false,
  "case_sensitive": false,
  "enable_snapshot_dirs": false,
  "homedir_support": 0,
  "mobile": false,
  "browser_access": false,
  "browser_access_settings": {
    "shared_links_enabled": false,
    "link_force_password": true,
    "link_allow_rw": false,
    "external_share_url": "string",
    "link_expire_limit": 0,
    "link_auth": {
      "authall": true,
      "allow_groups_ro": [
        "string"
      ],
      "allow_groups_rw": [
        "string"
      ],
      "deny_groups": [
        "string"
      ],
      "allow_users_ro": [
        "string"
      ],
      "allow_users_rw": [
        "string"
      ],
      "deny_users": [
        "string"
      ]
    }
  },
  "aio_enabled": true,
  "veto_files": "",
  "fruit_enabled": false,
  "smb_encrypt": "",
  "auth": {
    "authall": true,
    "rw_groups": [
      "string"
    ],
    "ro_groups": [
      "string"
    ],
    "deny_groups": [
      "string"
    ],
    "ro_users": [
      "string"
    ],
    "rw_users": [
      "string"
    ],
    "deny_users": [
      "string"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/shares/

Body parameter

{
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": false,
  "browseable": true,
  "hosts_allow": "",
  "hide_unreadable": true,
  "enable_previous_vers": false,
  "case_sensitive": false,
  "enable_snapshot_dirs": false,
  "homedir_support": 0,
  "mobile": false,
  "browser_access": false,
  "browser_access_settings": {
    "shared_links_enabled": false,
    "link_force_password": true,
    "link_allow_rw": false,
    "external_share_url": "string",
    "link_expire_limit": 0,
    "link_auth": {
      "authall": true,
      "allow_groups_ro": [
        "string"
      ],
      "allow_groups_rw": [
        "string"
      ],
      "deny_groups": [
        "string"
      ],
      "allow_users_ro": [
        "string"
      ],
      "allow_users_rw": [
        "string"
      ],
      "deny_users": [
        "string"
      ]
    }
  },
  "aio_enabled": true,
  "veto_files": "",
  "fruit_enabled": false,
  "smb_encrypt": "",
  "auth": {
    "authall": true,
    "rw_groups": [
      "string"
    ],
    "ro_groups": [
      "string"
    ],
    "deny_groups": [
      "string"
    ],
    "ro_users": [
      "string"
    ],
    "rw_users": [
      "string"
    ],
    "deny_users": [
      "string"
    ]
  }
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
body body any true The share to create.

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Get share

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
share_id path string true Share object identifier

Example responses

200 Response

{
  "id": 0,
  "filer_serial_number": "string",
  "volume_guid": "string",
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": false,
  "browseable": true,
  "hosts_allow": "",
  "hide_unreadable": true,
  "enable_previous_vers": false,
  "case_sensitive": false,
  "enable_snapshot_dirs": false,
  "homedir_support": 0,
  "mobile": false,
  "browser_access": false,
  "browser_access_settings": {
    "shared_links_enabled": false,
    "link_force_password": true,
    "link_allow_rw": false,
    "external_share_url": "string",
    "link_expire_limit": 0,
    "link_auth": {
      "authall": true,
      "allow_groups_ro": [
        "string"
      ],
      "allow_groups_rw": [
        "string"
      ],
      "deny_groups": [
        "string"
      ],
      "allow_users_ro": [
        "string"
      ],
      "allow_users_rw": [
        "string"
      ],
      "deny_users": [
        "string"
      ]
    }
  },
  "aio_enabled": true,
  "veto_files": "",
  "fruit_enabled": false,
  "smb_encrypt": "",
  "auth": {
    "authall": true,
    "rw_groups": [
      "string"
    ],
    "ro_groups": [
      "string"
    ],
    "deny_groups": [
      "string"
    ],
    "ro_users": [
      "string"
    ],
    "rw_users": [
      "string"
    ],
    "deny_users": [
      "string"
    ]
  },
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success Share
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Update share

Code samples

# You can also use wget
curl -X PATCH https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
PATCH https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
  method: 'patch',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": false,
  "browseable": true,
  "hosts_allow": "",
  "hide_unreadable": true,
  "enable_previous_vers": false,
  "case_sensitive": false,
  "enable_snapshot_dirs": false,
  "homedir_support": 0,
  "mobile": false,
  "browser_access": false,
  "browser_access_settings": {
    "shared_links_enabled": false,
    "link_force_password": true,
    "link_allow_rw": false,
    "external_share_url": "string",
    "link_expire_limit": 0,
    "link_auth": {
      "authall": true,
      "allow_groups_ro": [
        "string"
      ],
      "allow_groups_rw": [
        "string"
      ],
      "deny_groups": [
        "string"
      ],
      "allow_users_ro": [
        "string"
      ],
      "allow_users_rw": [
        "string"
      ],
      "deny_users": [
        "string"
      ]
    }
  },
  "aio_enabled": true,
  "veto_files": "",
  "fruit_enabled": false,
  "smb_encrypt": "",
  "auth": {
    "authall": true,
    "rw_groups": [
      "string"
    ],
    "ro_groups": [
      "string"
    ],
    "deny_groups": [
      "string"
    ],
    "ro_users": [
      "string"
    ],
    "rw_users": [
      "string"
    ],
    "deny_users": [
      "string"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.patch 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.patch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/

Body parameter

{
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": false,
  "browseable": true,
  "hosts_allow": "",
  "hide_unreadable": true,
  "enable_previous_vers": false,
  "case_sensitive": false,
  "enable_snapshot_dirs": false,
  "homedir_support": 0,
  "mobile": false,
  "browser_access": false,
  "browser_access_settings": {
    "shared_links_enabled": false,
    "link_force_password": true,
    "link_allow_rw": false,
    "external_share_url": "string",
    "link_expire_limit": 0,
    "link_auth": {
      "authall": true,
      "allow_groups_ro": [
        "string"
      ],
      "allow_groups_rw": [
        "string"
      ],
      "deny_groups": [
        "string"
      ],
      "allow_users_ro": [
        "string"
      ],
      "allow_users_rw": [
        "string"
      ],
      "deny_users": [
        "string"
      ]
    }
  },
  "aio_enabled": true,
  "veto_files": "",
  "fruit_enabled": false,
  "smb_encrypt": "",
  "auth": {
    "authall": true,
    "rw_groups": [
      "string"
    ],
    "ro_groups": [
      "string"
    ],
    "deny_groups": [
      "string"
    ],
    "ro_users": [
      "string"
    ],
    "rw_users": [
      "string"
    ],
    "deny_users": [
      "string"
    ]
  }
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
share_id path string true Share object identifier
body body Share true Share fields to update

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Delete a share

Code samples

# You can also use wget
curl -X DELETE https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
DELETE https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.delete 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.delete('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /volumes/{volume_guid}/filers/{filer_serial}/shares/{share_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
share_id path string true Share object identifier

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List exports

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/exports/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/exports/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/exports/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/exports/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/exports/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/exports/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/exports/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/exports/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/exports/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": true,
      "hostspec": "string",
      "access_mode": "root_squash",
      "perf_mode": "sync",
      "sec_options": [
        "sys"
      ],
      "nfs_host_options": [
        {
          "hostspec": "string",
          "readonly": true,
          "access_mode": "root_squash",
          "perf_mode": "sync",
          "sec_options": [
            "sys"
          ]
        }
      ],
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
access_mode root_squash
access_mode no_root_squash
access_mode all_squash
perf_mode sync
perf_mode no_wdelay
perf_mode async
access_mode root_squash
access_mode no_root_squash
access_mode all_squash
perf_mode sync
perf_mode no_wdelay
perf_mode async

List exports for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/exports/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/exports/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": true,
      "hostspec": "string",
      "access_mode": "root_squash",
      "perf_mode": "sync",
      "sec_options": [
        "sys"
      ],
      "nfs_host_options": [
        {
          "hostspec": "string",
          "readonly": true,
          "access_mode": "root_squash",
          "perf_mode": "sync",
          "sec_options": [
            "sys"
          ]
        }
      ],
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
access_mode root_squash
access_mode no_root_squash
access_mode all_squash
perf_mode sync
perf_mode no_wdelay
perf_mode async
access_mode root_squash
access_mode no_root_squash
access_mode all_squash
perf_mode sync
perf_mode no_wdelay
perf_mode async

List exports for a volume and Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/exports/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": true,
      "hostspec": "string",
      "access_mode": "root_squash",
      "perf_mode": "sync",
      "sec_options": [
        "sys"
      ],
      "nfs_host_options": [
        {
          "hostspec": "string",
          "readonly": true,
          "access_mode": "root_squash",
          "perf_mode": "sync",
          "sec_options": [
            "sys"
          ]
        }
      ],
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
access_mode root_squash
access_mode no_root_squash
access_mode all_squash
perf_mode sync
perf_mode no_wdelay
perf_mode async
access_mode root_squash
access_mode no_root_squash
access_mode all_squash
perf_mode sync
perf_mode no_wdelay
perf_mode async

Get export

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/exports/{export_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
export_id path string true Export object identifier

Example responses

200 Response

{
  "id": 0,
  "filer_serial_number": "string",
  "volume_guid": "string",
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": true,
  "hostspec": "string",
  "access_mode": "root_squash",
  "perf_mode": "sync",
  "sec_options": [
    "sys"
  ],
  "nfs_host_options": [
    {
      "hostspec": "string",
      "readonly": true,
      "access_mode": "root_squash",
      "perf_mode": "sync",
      "sec_options": [
        "sys"
      ]
    }
  ],
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success Export
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List FTP directories

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/ftp-directories/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/ftp-directories/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/ftp-directories/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/ftp-directories/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/ftp-directories/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/ftp-directories/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/ftp-directories/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/ftp-directories/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/ftp-directories/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": true,
      "visibility": "default",
      "allow_from": "string",
      "allow_users": "string",
      "allow_groups": "string",
      "anonymous": true,
      "anonymous_only": true,
      "umask": "000",
      "hide_ownership": true,
      "hidden_stores": true,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
visibility default
visibility hide
visibility invisible
umask 000
umask 002
umask 022
umask 006
umask 066
umask 026

List FTP directories for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/ftp-directories/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/ftp-directories/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": true,
      "visibility": "default",
      "allow_from": "string",
      "allow_users": "string",
      "allow_groups": "string",
      "anonymous": true,
      "anonymous_only": true,
      "umask": "000",
      "hide_ownership": true,
      "hidden_stores": true,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
visibility default
visibility hide
visibility invisible
umask 000
umask 002
umask 022
umask 006
umask 066
umask 026

List FTP directories for a volume and Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "name": "string",
      "path": "string",
      "comment": "string",
      "readonly": true,
      "visibility": "default",
      "allow_from": "string",
      "allow_users": "string",
      "allow_groups": "string",
      "anonymous": true,
      "anonymous_only": true,
      "umask": "000",
      "hide_ownership": true,
      "hidden_stores": true,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
visibility default
visibility hide
visibility invisible
umask 000
umask 002
umask 022
umask 006
umask 066
umask 026

Get FTP directory

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/ftp-directories/{ftpdir_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
ftpdir_id path string true FTP directory object identifier

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "path": "string",
  "comment": "string",
  "readonly": true,
  "visibility": "default",
  "allow_from": "string",
  "allow_users": "string",
  "allow_groups": "string",
  "anonymous": true,
  "anonymous_only": true,
  "umask": "000",
  "hide_ownership": true,
  "hidden_stores": true,
  "filer_serial_number": "string",
  "volume_guid": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success FtpDirectory
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List volume connections

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filer-connections/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filer-connections/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filer-connections/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filer-connections/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filer-connections/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filer-connections/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filer-connections/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filer-connections/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filer-connections/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "connected": true,
      "volume_guid": "string",
      "filer_serial_number": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List volume connections for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filer-connections/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "connected": true,
      "volume_guid": "string",
      "filer_serial_number": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Get volume connection

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filer-connections/{filer_serial}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filer-connections/{filer_serial}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier

Example responses

200 Response

{
  "connected": true,
  "volume_guid": "string",
  "filer_serial_number": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success VolumeConnection
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List antivirus violations

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/antivirus-violations/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/antivirus-violations/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/antivirus-violations/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/antivirus-violations/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/antivirus-violations/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/antivirus-violations/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/antivirus-violations/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/antivirus-violations/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/antivirus-violations/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "fpath": "string",
      "vname": "string",
      "volume_uri": "string",
      "seqno": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List antivirus violations for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/antivirus-violations/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/antivirus-violations/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "fpath": "string",
      "vname": "string",
      "volume_uri": "string",
      "seqno": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

List antivirus violations for a volume and Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "fpath": "string",
      "vname": "string",
      "volume_uri": "string",
      "seqno": 0,
      "filer_serial_number": "string",
      "volume_guid": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Get antivirus violation

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/antivirus-violations/{antivirus_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
antivirus_id path string true Antivirus violation object identifier

Example responses

200 Response

{
  "id": 0,
  "fpath": "string",
  "vname": "string",
  "volume_uri": "string",
  "seqno": 0,
  "filer_serial_number": "string",
  "volume_guid": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success AntivirusViolation
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List folder quotas

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/folder-quotas/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/folder-quotas/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/folder-quotas/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/folder-quotas/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/folder-quotas/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/folder-quotas/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/folder-quotas/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/folder-quotas/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/folder-quotas/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "filer_serial_number": "string",
      "volume_guid": "string",
      "email": "string",
      "limit": 0,
      "usage": 0,
      "children": true,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "delete": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
type rule
type quota

List folder quotas for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/folder-quotas/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "filer_serial_number": "string",
      "volume_guid": "string",
      "email": "string",
      "limit": 0,
      "usage": 0,
      "children": true,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "delete": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
type rule
type quota

Create folder quota

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "type": "rule",
  "path": "string",
  "email": "string",
  "limit": 0,
  "children": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/folder-quotas/

Body parameter

{
  "type": "rule",
  "path": "string",
  "email": "string",
  "limit": 0,
  "children": true
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
body body any true The folder quota to create.

Example responses

200 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success MessageResponse
401 Unauthorized Authentication failure ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Get folder quota

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/folder-quotas/{folder_quota_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
folder_quota_id path string true Folder Quota object identifier

Example responses

200 Response

{
  "id": "string",
  "filer_serial_number": "string",
  "volume_guid": "string",
  "email": "string",
  "limit": 0,
  "usage": 0,
  "children": true,
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "delete": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success FolderQuota
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Update folder quota

Code samples

# You can also use wget
curl -X PATCH https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
PATCH https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
  method: 'patch',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "type": "rule",
  "path": "string",
  "email": "string",
  "limit": 0,
  "children": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.patch 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.patch('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /volumes/{volume_guid}/folder-quotas/{folder_quota_id}/

Body parameter

{
  "type": "rule",
  "path": "string",
  "email": "string",
  "limit": 0,
  "children": true
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
folder_quota_id path string true Folder Quota object identifier
body body FolderQuota false The folder quota fields to edit.

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted the request and returns a status message MessageResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Delete folder quota

Code samples

# You can also use wget
curl -X DELETE https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
DELETE https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.delete 'https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.delete('https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hostname/api/v1.1/volumes/{volume_guid}/folder-quotas/{folder_quota_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /volumes/{volume_guid}/folder-quotas/{folder_quota_id}/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
folder_quota_id path string true Folder Quota object identifier

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted the request and returns a status message MessageResponse
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

List snapshot statuses

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/snapshots/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/snapshots/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/snapshots/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/snapshots/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/snapshots/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/snapshots/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/snapshots/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/snapshots/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/snapshots/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "volume_guid": "string",
      "filer_serial_number": "string",
      "snapshot_status": "idle",
      "snapshot_percent": 0,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
snapshot_status idle
snapshot_status pending
snapshot_status in_progress

List snapshot statuses for a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/snapshots/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/snapshots/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "volume_guid": "string",
      "filer_serial_number": "string",
      "snapshot_status": "idle",
      "snapshot_percent": 0,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
snapshot_status idle
snapshot_status pending
snapshot_status in_progress

List snapshot status for a volume and Filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/snapshots/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier

Example responses

200 Response

{
  "items": [
    {
      "volume_guid": "string",
      "filer_serial_number": "string",
      "snapshot_status": "idle",
      "snapshot_percent": 0,
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
snapshot_status idle
snapshot_status pending
snapshot_status in_progress

Request snapshot for volume

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/snapshots/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/snapshots/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted the request and returns a status message MessageResponse
401 Unauthorized Authentication failure ErrorResponse
409 Conflict Conflict, there's already a snapshot in progress. Error
429 Too Many Requests Request throttled ErrorResponse

Enable global locking and its various modes on a specified path

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "path": "string",
  "mode": "optimized"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/global-lock-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/global-lock-folders/

Body parameter

{
  "path": "string",
  "mode": "optimized"
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
body body any true The global locking settings to create.

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message. MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Get a list of all known paths

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/paths/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/paths/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/paths/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/paths/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/paths/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/paths/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/paths/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/paths/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/paths/

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "path": "string",
      "is_dir": true,
      "cache_resident": true,
      "protected": true,
      "owner": "string",
      "size": 0,
      "pinning_enabled": true,
      "pinning_mode": "metadata",
      "pinning_inherited": true,
      "autocache_enabled": true,
      "autocache_mode": "metadata",
      "autocache_inherited": true,
      "quota_enabled": true,
      "quota_type": "rule",
      "quota_email": "string",
      "quota_usage": 0,
      "quota_limit": 0,
      "quota_inherited": true,
      "global_locking_enabled": true,
      "global_locking_inherited": true,
      "global_locking_mode": "optimized",
      "updated": "string",
      "expires": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "refresh": {
          "href": "string",
          "method": "string"
        },
        "cache": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
pinning_mode metadata
pinning_mode metadata_and_data
pinning_mode disabled
autocache_mode metadata
autocache_mode metadata_and_data
autocache_mode disabled
quota_type rule
quota_type quota
global_locking_mode optimized
global_locking_mode advanced
global_locking_mode asynchronous

Get a list of all known paths with a specific volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/paths/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/paths/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "path": "string",
      "is_dir": true,
      "cache_resident": true,
      "protected": true,
      "owner": "string",
      "size": 0,
      "pinning_enabled": true,
      "pinning_mode": "metadata",
      "pinning_inherited": true,
      "autocache_enabled": true,
      "autocache_mode": "metadata",
      "autocache_inherited": true,
      "quota_enabled": true,
      "quota_type": "rule",
      "quota_email": "string",
      "quota_usage": 0,
      "quota_limit": 0,
      "quota_inherited": true,
      "global_locking_enabled": true,
      "global_locking_inherited": true,
      "global_locking_mode": "optimized",
      "updated": "string",
      "expires": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "refresh": {
          "href": "string",
          "method": "string"
        },
        "cache": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
pinning_mode metadata
pinning_mode metadata_and_data
pinning_mode disabled
autocache_mode metadata
autocache_mode metadata_and_data
autocache_mode disabled
quota_type rule
quota_type quota
global_locking_mode optimized
global_locking_mode advanced
global_locking_mode asynchronous

Get a list of all known paths with a specific volume and filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/paths/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/paths/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "path": "string",
      "is_dir": true,
      "cache_resident": true,
      "protected": true,
      "owner": "string",
      "size": 0,
      "pinning_enabled": true,
      "pinning_mode": "metadata",
      "pinning_inherited": true,
      "autocache_enabled": true,
      "autocache_mode": "metadata",
      "autocache_inherited": true,
      "quota_enabled": true,
      "quota_type": "rule",
      "quota_email": "string",
      "quota_usage": 0,
      "quota_limit": 0,
      "quota_inherited": true,
      "global_locking_enabled": true,
      "global_locking_inherited": true,
      "global_locking_mode": "optimized",
      "updated": "string",
      "expires": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "refresh": {
          "href": "string",
          "method": "string"
        },
        "cache": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
pinning_mode metadata
pinning_mode metadata_and_data
pinning_mode disabled
autocache_mode metadata
autocache_mode metadata_and_data
autocache_mode disabled
quota_type rule
quota_type quota
global_locking_mode optimized
global_locking_mode advanced
global_locking_mode asynchronous

Get info on a specific path

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/path/{path}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path

Example responses

200 Response

{
  "filer_serial_number": "string",
  "volume_guid": "string",
  "path": "string",
  "is_dir": true,
  "cache_resident": true,
  "protected": true,
  "owner": "string",
  "size": 0,
  "pinning_enabled": true,
  "pinning_mode": "metadata",
  "pinning_inherited": true,
  "autocache_enabled": true,
  "autocache_mode": "metadata",
  "autocache_inherited": true,
  "quota_enabled": true,
  "quota_type": "rule",
  "quota_email": "string",
  "quota_usage": 0,
  "quota_limit": 0,
  "quota_inherited": true,
  "global_locking_enabled": true,
  "global_locking_inherited": true,
  "global_locking_mode": "optimized",
  "updated": "string",
  "expires": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "refresh": {
      "href": "string",
      "method": "string"
    },
    "cache": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success PathData
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Refresh info about a given path

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/path/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/path/{path}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message. MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message.

Bring path into cache

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path} HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "metadata_only": false,
  "force": false
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/cache-path/{path}

Only avaliable with Filers on version 8.5 and higher.

Body parameter

{
  "metadata_only": false,
  "force": false
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path
body body any false Whether or not to bring only directory metadata into cache

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message

Try to make the given directory path

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "path": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/make-dir-path/

Only available with Filers on version 8.5 and higher.

Body parameter

{
  "path": "string"
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
body body object true Create the given path as a directory under the volume on the given filer. The path should start with a /.
» path body string false none

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message

Get a list of all pinned folders

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/pinned-folders/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/pinned-folders/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/pinned-folders/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/pinned-folders/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/pinned-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/pinned-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/pinned-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/pinned-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/pinned-folders/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "mode": "metadata_and_data",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "disable": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
mode metadata
mode metadata_and_data

Get a list of all pinned folders in a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/pinned-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/pinned-folders/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "mode": "metadata_and_data",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "disable": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
mode metadata
mode metadata_and_data

Get a list of pinned folders in a volume for a specific filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "mode": "metadata_and_data",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "disable": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
mode metadata
mode metadata_and_data

Set pinning mode

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "path": "string",
  "mode": "metadata_and_data"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/pinned-folders/

Metadata mode is only avaliable with Filers on version 8.5 and higher.

Body parameter

{
  "path": "string",
  "mode": "metadata_and_data"
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
body body any true The folder to enable pinning on and optionally the mode

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message. MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message.

Get pinning status for the path

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path

Example responses

200 Response

{
  "filer_serial_number": "string",
  "volume_guid": "string",
  "mode": "metadata_and_data",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    },
    "disable": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success PinnedFolders
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Disable pinning mode on a folder

Code samples

# You can also use wget
curl -X DELETE https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
DELETE https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.delete 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.delete('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /volumes/{volume_guid}/filers/{filer_serial}/pinned-folder/{path}

Only avaliable with Filers on version 8.5 and higher.

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message. MessageResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message.

Get a list of all auto cache enabled folders

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/filers/auto-cached-folders/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/filers/auto-cached-folders/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/filers/auto-cached-folders/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/filers/auto-cached-folders/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/filers/auto-cached-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/filers/auto-cached-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/filers/auto-cached-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/filers/auto-cached-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/filers/auto-cached-folders/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "mode": "metadata_and_data",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "disable": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
mode metadata
mode metadata_and_data

Get a list of all auto cache enabled folders in a volume

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/auto-cached-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/auto-cached-folders/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "mode": "metadata_and_data",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "disable": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
mode metadata
mode metadata_and_data

List auto cache enabled folders for a volume on a filer

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "filer_serial_number": "string",
      "volume_guid": "string",
      "mode": "metadata_and_data",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        },
        "volume": {
          "href": "string",
          "method": "string"
        },
        "disable": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
mode metadata
mode metadata_and_data

Set auto caching mode

Code samples

# You can also use wget
curl -X POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
POST https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/ HTTP/1.1
Host: hostname
Content-Type: application/json
Accept: application/json
var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const inputBody = '{
  "path": "string",
  "mode": "metadata_and_data"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.post 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.post('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folders/

Metadata mode is only avaliable with Filers on version 8.5 and higher.

Body parameter

{
  "path": "string",
  "mode": "metadata_and_data"
}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
body body any true The folder to enable auto cache on and optionally the mode

Example responses

200 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Accepted - Filer has been sent a message. MessageResponse
400 Bad Request Validation error ErrorResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
200 Location string URL to the associated message.

Get auto cache folder status for a folder

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path

Example responses

200 Response

{
  "filer_serial_number": "string",
  "volume_guid": "string",
  "mode": "metadata_and_data",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    },
    "volume": {
      "href": "string",
      "method": "string"
    },
    "disable": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success AutoCachedFolders
401 Unauthorized Authentication failure ErrorResponse
404 Not Found Resource not found ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Disable auto cache mode on a folder

Code samples

# You can also use wget
curl -X DELETE https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
DELETE https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path} HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.delete 'https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.delete('https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hostname/api/v1.1/volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /volumes/{volume_guid}/filers/{filer_serial}/auto-cached-folder/{path}

Only avaliable with Filers on version 8.5 and higher

Parameters

Name In Type Required Description
volume_guid path string true Volume identifier
filer_serial path string true Filer object identifier
path path string true Folder or File path

Example responses

202 Response

{
  "message": {
    "id": "string",
    "filer_serial_number": "string",
    "description": "string",
    "code": "string",
    "status": "synced",
    "send_time": "string",
    "expiration_time": "string",
    "response_time": "string",
    "initiated_by": "string",
    "links": {
      "self": {
        "href": "string",
        "method": "string"
      },
      "filer": {
        "href": "string",
        "method": "string"
      },
      "acknowledge": {
        "href": "string",
        "method": "string"
      },
      "applied_resource": {
        "href": "string",
        "method": "string"
      }
    },
    "error": {
      "code": "error",
      "description": "string"
    }
  }
}

Responses

Status Meaning Description Schema
202 Accepted Accepted - Filer has been sent a message. MessageResponse
401 Unauthorized Authentication failure ErrorResponse
403 Forbidden Permission denied ErrorResponse
404 Not Found Resource not found ErrorResponse
405 Method Not Allowed Method not allowed ErrorResponse
409 Conflict Conflict ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Headers

Status Header Type Format Description
202 Location string URL to the associated message.

Notifications

List notifications

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/notifications/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/notifications/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/notifications/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/notifications/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/notifications/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/notifications/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/notifications/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/notifications/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /notifications/

Parameters

Name In Type Required Description
limit query integer false The maximum number of objects to return
offset query integer false The index of the first object to return

Example responses

200 Response

{
  "items": [
    {
      "id": 0,
      "date": "string",
      "priority": "noop",
      "name": "string",
      "message": "string",
      "group": "string",
      "acknowledged": true,
      "sticky": true,
      "urgent": true,
      "origin": "string",
      "links": {
        "self": {
          "href": "string",
          "method": "string"
        },
        "filer": {
          "href": "string",
          "method": "string"
        }
      }
    }
  ],
  "href": "string",
  "limit": 0,
  "next": "string",
  "offset": 0,
  "previous": "string",
  "total": 0
}

Responses

Status Meaning Description Schema
200 OK Success Inline
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Response Schema

Enumerated Values

Property Value
priority noop
priority alert
priority admin
priority error
priority warning
priority info

Get notification

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/notifications/{notification_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/notifications/{notification_id}/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/notifications/{notification_id}/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/notifications/{notification_id}/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/notifications/{notification_id}/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/notifications/{notification_id}/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/notifications/{notification_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
       "bytes"
       "net/http"
)
func main() {
    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }
    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hostname/api/v1.1/notifications/{notification_id}/", data)
    req.Header = headers
    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /notifications/{notification_id}/

Parameters

Name In Type Required Description
notification_id path string true Notification object identifier

Example responses

200 Response

{
  "id": 0,
  "date": "string",
  "priority": "noop",
  "name": "string",
  "message": "string",
  "group": "string",
  "acknowledged": true,
  "sticky": true,
  "urgent": true,
  "origin": "string",
  "links": {
    "self": {
      "href": "string",
      "method": "string"
    },
    "filer": {
      "href": "string",
      "method": "string"
    }
  }
}

Responses

Status Meaning Description Schema
200 OK Success Notification
401 Unauthorized Authentication failure ErrorResponse
429 Too Many Requests Request throttled ErrorResponse

Messages

List messages

Code samples

# You can also use wget
curl -X GET https://hostname/api/v1.1/messages/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
GET https://hostname/api/v1.1/messages/ HTTP/1.1
Host: hostname
Accept: application/json
var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
$.ajax({
  url: 'https://hostname/api/v1.1/messages/',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})
const fetch = require('node-fetch');
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};
fetch('https://hostname/api/v1.1/messages/',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
require 'rest-client'
require 'json'
headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}
result = RestClient.get 'https://hostname/api/v1.1/messages/',
  params: {
  }, headers: headers
p JSON.parse(result)
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}
r = requests.get('https://hostname/api/v1.1/messages/', params={
}, headers = headers)
print r.json()
URL obj = new URL("https://hostname/api/v1.1/messages/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null