1 of 4

Filesystem

The API allows you to manipulate the contents of the available filesystems.

Disk

The disk filesystem gives access to the actual directory that has been provided in the configuration as storage.disk.dir. It accessible only for retrieval via HTTP under /.

curl http://127.0.0.1:8080/path/to/a/file.txt -o file.txt

Given that the requested file exists, the returned Content-Type is based solely on the file extension. For a list of known mime-types and their extensions see storage.mime_types in the configuration.

Access

API

The contents of the disk filesystem at / are also accessible via the API in the same way as described above, but with the same protection as the API (see API-Security configuration) for all operations. It is also possible to list all files that are currently in the filesystem.

Create, Update

Example:

echo 'test' > example.txt && \
curl http://127.0.0.1:8080/api/v3/fs/disk/example.txt \
   -d @example.txt \
   -X PUT

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_put_file(
    name: "disk",
    path: "example.txt",
    data: b"test"
)

Path is the complete file path incl. file name (/a/b/c/1.txt).

import (
    "strings"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data := strings.NewReader("test")
err := client.FilesystemAddFile("disk", "/example.txt", data)

The contents for the upload has to be provided as an io.Reader.

After the successful upload the file is available at /example.txt and /api/v3/fs/disk/example.txt.

Description:

Read

List all files

Listing all currently stored files is done by calling /api/v3/fs/disk. It also accepts the query parameters pattern, sort (name, size, or lastmod) and order (asc or desc). If none of the parameters are given, all files will be listed sorted by their last modification time in ascending order.

With the pattern parameter you can filter the list based on a glob pattern, with the addition of the ** placeholder to include multiple subdirectories, e.g. listing all .ts file in the root directory has the pattern /*.ts, listing all .ts file in the whole filesystem has the pattern /**.ts.Example:

curl "http://127.0.0.1:8080/api/v3/fs/disk?sort=name&order=asc" \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_list = client.v3_fs_get_file_list(name="disk")
print(core_memfs_list)

import (
    "fmt"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

files, err := client.FilesystemList("disk", "/*.", coreclient.SORT_NAME, coreclient.ORDER_ASC)

for _, file := range files {
    fmt.Printf("%+v\n", file)
}

Description:

Download a file

For downloading a file you have to specify the complete path and filename. The Content-Type will always be application/data.

Example:

curl http://127.0.0.1:8080/api/v3/fs/disk/example.txt \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_file = client.v3_fs_get_file(
    name="disk",
    path="example.txt"
)
print(core_memfs_file)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data, err := client.FilesystemGetFile("disk", "/example.txt")
defer data.Close()

The returned data is an io.ReadCloser.

Description:

Delete

For deleting a file you have to specify the complete path and filename.

Example:

curl http://127.0.0.1:8080/api/v3/fs/disk/example.txt \
   -X DELETE

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_delete_file(
    name="disk",
    path="example.txt"
)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

err := client.FilesystemDeleteFile("disk", "/example.txt")

Description:

Configuration

In-memory

A very simple in-memory filesystem is available which is only accessible via HTTP under /memfs. Use the POST or PUT method with the path to that file. The body of the request contains the contents of the file. No particular encoding or Content-Type is required. The file can then be downloaded from the same path.

This filesystem is practical for often changing data (e.g. HLS live stream) in order not to stress the disk or to wear out a flash drive. Also you don't need to setup a RAM drive or similar on your system.

curl http://127.0.0.1:8080/memfs/path/to/a/file.txt -X PUT -d @somefile.txt

curl http://127.0.0.1:8080/memfs/path/to/a/file.txt -o file.txt

curl http://127.0.0.1:8080/memfs/path/to/a/file.txt -X DELETE

The returned Content-Type is based solely on the file extension. For a list of known mime-types and their extensions see storage.mime_types in the configuration.

Access protection

It is strongly recommended to enable a username/password (HTTP Basic-Auth) protection for any PUT/POST and DELETE operations on /memfs. GET operations are not protected.

By default HTTP Basic-Auth is enabled with the username "admin" and a random password.

Example:

Use these endpoints to, e.g., store HLS chunks and .m3u8 files (in contrast to an actual disk or a ramdisk):

ffmpeg -f lavfi -re -i testsrc2=size=640x480:rate=25 -c:v libx264 -preset:v ultrafast -r 25 -g 50 -f hls -start_number 0 -hls_time 2 -hls_list_size 6 -hls_flags delete_segments+temp_file+append_list -method PUT -hls_segment_filename http://127.0.0.1:8080/memfs/foobar_%04d.ts -y http://127.0.0.1:8080/memfs/foobar.m3u8

Then you can play it generally with, e.g., ffplay http://127.0.0.1:8080/memfs/foobar.m3u8.

API

The contents of the /memfs are also accessible via the API in the same way as described above, but with the same protection as the API (see API-Security configuration) for all operations. It is also possible to list all files that are currently in the filesystem.

Create, Update

Example:

echo 'test' > example.txt && \
curl http://127.0.0.1:8080/api/v3/fs/mem/example.txt \
   -d @example.txt \
   -X PUT

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_put_file(
    name: "mem",
    path: "example.txt",
    data: b"test"
)

import (
    "strings"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data := strings.NewReader("test")
err := client.FilesystemAddFile("mem", "/example.txt", data)

The contents for the upload has to be provided as an io.Reader.

After the successful upload the file is available at /memfs/example.txt and /api/v3/fs/mem/example.txt.

Description:

Read

List all files

Listing all currently stored files is done by calling /api/v3/fs/mem. It also accepts the query parameters pattern, sort (name, size, or lastmod) and order (asc or desc). If none of the parameters are given, all files will be listed sorted by their last modification time in ascending order.

Example:

curl "http://127.0.0.1:8080/api/v3/fs/mem?sort=name&order=asc" \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_list = client.v3_fs_get_file_list(name="mem")
print(core_memfs_list)

import (
    "fmt"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

files, err := client.FilesystemList("mem", "/*.", coreclient.SORT_NAME, coreclient.ORDER_ASC)

for _, file := range files {
    fmt.Printf("%+v\n", file)
}

Description:

Download a file

For downloading a file you have to specify the complete path and filename. The Content-Type will always be application/data.

Example:

curl http://127.0.0.1:8080/api/v3/fs/mem/example.txt \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_file = client.v3_fs_get_file(
    name="mem",
    path="example.txt"
)
print(core_memfs_file)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data, err := client.FilesystemGetFile("mem", "/example.txt")
defer data.Close()

The returned data is an io.ReadCloser.

Description:

Link

Linking a file will return a redirect to the linked file. The target of the redirect has to be in the body of the request.

Example:

curl http://127.0.0.1:8080/api/v3/fs/mem/example2.txt \
   -d 'example.txt'
   -X PATCH

Missed.

This is not implemented in the client.

Description:

Delete

For deleting a file you have to specify the complete path and filename.

Example:

curl http://127.0.0.1:8080/api/v3/fs/mem/example.txt \
   -X DELETE

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_delete_file(
    name="mem",
    path="example.txt"
)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

err := client.FilesystemDeleteFile("mem", "/example.txt")

Description:

Configuration

S3

S3 filesystems are only accessible via HTTP their configured mountpoint. Use the POST or PUT method with the path to that file to (over-)write a file. The body of the request contains the contents of the file. No particular encoding or Content-Type is required. The file can then be downloaded from the same path.

This filesystem is practical rarely changing data (e.g. VOD) for long term storage.

On this page and in the examples we assume that a S3 storage with the name aws is mounted on /awsfs.

curl http://127.0.0.1:8080/awsfs/path/to/a/file.txt -X PUT -d @somefile.txt

curl http://127.0.0.1:8080/awsfs/path/to/a/file.txt -o file.txt

curl http://127.0.0.1:8080/awsfs/path/to/a/file.txt -X DELETE

The returned Content-Type is based solely on the file extension. For a list of known mime-types and their extensions see storage.mime_types in the configuration.

Access protection

It is strongly recommended to enable a username/password (HTTP Basic-Auth) protection for any PUT/POST and DELETE operations on /memfs. GET operations are not protected.

By default HTTP Basic-Auth is not enabled.

API

The contents of the S3 filesystem mounted on /awsfs are also accessible via the API in the same way as described above, but with the same protection as the API (see API-Security configuration) for all operations. It is also possible to list all files that are currently in the filesystem.

Create, Update

Example:

echo 'test' > example.txt && \
curl http://127.0.0.1:8080/api/v3/fs/aws/example.txt \
   -d @example.txt \
   -X PUT

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_put_file(
    name: "aws",
    path: "example.txt",
    data: b"test"
)

import (
    "strings"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data := strings.NewReader("test")
err := client.FilesystemAddFile("aws", "/example.txt", data)

The contents for the upload has to be provided as an io.Reader.

After the successful upload the file is available at /awsfs/example.txt and /api/v3/fs/aws/example.txt.

Description:

Read

List all files

Listing all currently stored files is done by calling /api/v3/fs/aws. It also accepts the query parameters pattern, sort (name, size, or lastmod) and order (asc or desc). If none of the parameters are given, all files will be listed sorted by their last modification time in ascending order.

Example:

curl "http://127.0.0.1:8080/api/v3/fs/aws?sort=name&order=asc" \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_list = client.v3_fs_get_file_list(name="aws")
print(core_memfs_list)

import (
    "fmt"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

files, err := client.FilesystemList("aws", "/*.", coreclient.SORT_NAME, coreclient.ORDER_ASC)

for _, file := range files {
    fmt.Printf("%+v\n", file)
}

Description:

Download a file

For downloading a file you have to specify the complete path and filename. The Content-Type will always be application/data.

Example:

curl http://127.0.0.1:8080/api/v3/fs/aws/example.txt \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_file = client.v3_fs_get_file(
    name="aws",
    path="example.txt"
)
print(core_memfs_file)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data, err := client.FilesystemGetFile("aws", "/example.txt")
defer data.Close()

The returned data is an io.ReadCloser.

Description:

Delete

For deleting a file you have to specify the complete path and filename.

Example:

curl http://127.0.0.1:8080/api/v3/fs/aws/example.txt \
   -X DELETE

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_delete_file(
    name="aws",
    path="example.txt"
)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

err := client.FilesystemDeleteFile("aws", "/example.txt")

Description:

Configuration

Disk

The disk filesystem gives access to the actual directory that has been provided in the configuration as storage.disk.dir. It accessible only for retrieval via HTTP under /.

curl http://127.0.0.1:8080/path/to/a/file.txt -o file.txt

Access

API

Create, Update

Example:

echo 'test' > example.txt && \
curl http://127.0.0.1:8080/api/v3/fs/disk/example.txt \
   -d @example.txt \
   -X PUT

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_put_file(
    name: "disk",
    path: "example.txt",
    data: b"test"
)

Path is the complete file path incl. file name (/a/b/c/1.txt).

import (
    "strings"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data := strings.NewReader("test")
err := client.FilesystemAddFile("disk", "/example.txt", data)

The contents for the upload has to be provided as an io.Reader.

After the successful upload the file is available at /example.txt and /api/v3/fs/disk/example.txt.

Description:

Read

List all files

curl "http://127.0.0.1:8080/api/v3/fs/disk?sort=name&order=asc" \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_list = client.v3_fs_get_file_list(name="disk")
print(core_memfs_list)

import (
    "fmt"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

files, err := client.FilesystemList("disk", "/*.", coreclient.SORT_NAME, coreclient.ORDER_ASC)

for _, file := range files {
    fmt.Printf("%+v\n", file)
}

Description:

Download a file

For downloading a file you have to specify the complete path and filename. The Content-Type will always be application/data.

Example:

curl http://127.0.0.1:8080/api/v3/fs/disk/example.txt \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_file = client.v3_fs_get_file(
    name="disk",
    path="example.txt"
)
print(core_memfs_file)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data, err := client.FilesystemGetFile("disk", "/example.txt")
defer data.Close()

The returned data is an io.ReadCloser.

Description:

Delete

For deleting a file you have to specify the complete path and filename.

Example:

curl http://127.0.0.1:8080/api/v3/fs/disk/example.txt \
   -X DELETE

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_delete_file(
    name="disk",
    path="example.txt"
)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

err := client.FilesystemDeleteFile("disk", "/example.txt")

Description:

Configuration

Disk

S3

This filesystem is practical rarely changing data (e.g. VOD) for long term storage.

On this page and in the examples we assume that a S3 storage with the name aws is mounted on /awsfs.

curl http://127.0.0.1:8080/awsfs/path/to/a/file.txt -X PUT -d @somefile.txt

curl http://127.0.0.1:8080/awsfs/path/to/a/file.txt -o file.txt

curl http://127.0.0.1:8080/awsfs/path/to/a/file.txt -X DELETE

The returned Content-Type is based solely on the file extension. For a list of known mime-types and their extensions see storage.mime_types in the configuration.

Access protection

It is strongly recommended to enable a username/password (HTTP Basic-Auth) protection for any PUT/POST and DELETE operations on /memfs. GET operations are not protected.

By default HTTP Basic-Auth is not enabled.

API

Create, Update

Example:

echo 'test' > example.txt && \
curl http://127.0.0.1:8080/api/v3/fs/aws/example.txt \
   -d @example.txt \
   -X PUT

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_put_file(
    name: "aws",
    path: "example.txt",
    data: b"test"
)

import (
    "strings"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data := strings.NewReader("test")
err := client.FilesystemAddFile("aws", "/example.txt", data)

The contents for the upload has to be provided as an io.Reader.

After the successful upload the file is available at /awsfs/example.txt and /api/v3/fs/aws/example.txt.

Description:

Add a file to a filesystem

Writes or overwrites a file on a filesystem

PUT//api/v3/fs/{name}/{path}

Authorization

Path parameters

name*string

Name of the filesystem

path*string

Path to file

Body

File data

itemsinteger

Response

Created

Body

string

Request

Response

Read

List all files

Example:

curl "http://127.0.0.1:8080/api/v3/fs/aws?sort=name&order=asc" \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_list = client.v3_fs_get_file_list(name="aws")
print(core_memfs_list)

import (
    "fmt"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

files, err := client.FilesystemList("aws", "/*.", coreclient.SORT_NAME, coreclient.ORDER_ASC)

for _, file := range files {
    fmt.Printf("%+v\n", file)
}

Description:

List all files on a filesystem

List all files on a filesystem. The listing can be ordered by name, size, or date of last modification in ascending or descending order.

GET//api/v3/fs/{name}

Authorization

Path parameters

name*string

Name of the filesystem

Query parameters

globstring

glob pattern for file names

sortstring

none, name, size, lastmod

orderstring

asc, desc

Response

Body

last_modifiedinteger (int64)

namestring

size_bytesinteger (int64)

Request

Response

Download a file

For downloading a file you have to specify the complete path and filename. The Content-Type will always be application/data.

Example:

curl http://127.0.0.1:8080/api/v3/fs/aws/example.txt \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_file = client.v3_fs_get_file(
    name="aws",
    path="example.txt"
)
print(core_memfs_file)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data, err := client.FilesystemGetFile("aws", "/example.txt")
defer data.Close()

The returned data is an io.ReadCloser.

Description:

Fetch a file from a filesystem

GET//api/v3/fs/{name}/{path}

Authorization

Path parameters

name*string

Name of the filesystem

path*string

Path to file

Response

Body

string (binary)

Request

Response

Delete

For deleting a file you have to specify the complete path and filename.

Example:

curl http://127.0.0.1:8080/api/v3/fs/aws/example.txt \
   -X DELETE

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_delete_file(
    name="aws",
    path="example.txt"
)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

err := client.FilesystemDeleteFile("aws", "/example.txt")

Description:

Remove a file from a filesystem

DELETE//api/v3/fs/{name}/{path}

Authorization

Path parameters

name*string

Name of the filesystem

path*string

Path to file

Response

Body

string

Request

Response

Configuration

In-memory

curl http://127.0.0.1:8080/memfs/path/to/a/file.txt -X PUT -d @somefile.txt

curl http://127.0.0.1:8080/memfs/path/to/a/file.txt -o file.txt

curl http://127.0.0.1:8080/memfs/path/to/a/file.txt -X DELETE

The returned Content-Type is based solely on the file extension. For a list of known mime-types and their extensions see storage.mime_types in the configuration.

Access protection

It is strongly recommended to enable a username/password (HTTP Basic-Auth) protection for any PUT/POST and DELETE operations on /memfs. GET operations are not protected.

By default HTTP Basic-Auth is enabled with the username "admin" and a random password.

Fetch a file from the memory filesystem

GET//memfs/{path}

Path parameters

path*string

Path to file

Response

Body

string (binary)

Request

Response

Add a file to the memory filesystem

Writes or overwrites a file on the memory filesystem

PUT//memfs/{path}

Authorization

Path parameters

path*string

Path to file

Body

File data

itemsinteger

Response

Created

Body

string

Request

Response

Remove a file from the memory filesystem

DELETE//memfs/{path}

Authorization

Path parameters

path*string

Path to file

Response

Body

string

Request

Response

Example:

Use these endpoints to, e.g., store HLS chunks and .m3u8 files (in contrast to an actual disk or a ramdisk):

ffmpeg -f lavfi -re -i testsrc2=size=640x480:rate=25 -c:v libx264 -preset:v ultrafast -r 25 -g 50 -f hls -start_number 0 -hls_time 2 -hls_list_size 6 -hls_flags delete_segments+temp_file+append_list -method PUT -hls_segment_filename http://127.0.0.1:8080/memfs/foobar_%04d.ts -y http://127.0.0.1:8080/memfs/foobar.m3u8

Then you can play it generally with, e.g., ffplay http://127.0.0.1:8080/memfs/foobar.m3u8.

API

Create, Update

Example:

echo 'test' > example.txt && \
curl http://127.0.0.1:8080/api/v3/fs/mem/example.txt \
   -d @example.txt \
   -X PUT

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_put_file(
    name: "mem",
    path: "example.txt",
    data: b"test"
)

import (
    "strings"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data := strings.NewReader("test")
err := client.FilesystemAddFile("mem", "/example.txt", data)

The contents for the upload has to be provided as an io.Reader.

After the successful upload the file is available at /memfs/example.txt and /api/v3/fs/mem/example.txt.

Description:

Add a file to the memory filesystem

Writes or overwrites a file on the memory filesystem

PUT//api/v3/fs/mem/{path}

Authorization

Path parameters

path*string

Path to file

Body

File data

itemsinteger

Response

Created

Body

string

Request

Response

Read

List all files

Example:

curl "http://127.0.0.1:8080/api/v3/fs/mem?sort=name&order=asc" \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_list = client.v3_fs_get_file_list(name="mem")
print(core_memfs_list)

import (
    "fmt"
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

files, err := client.FilesystemList("mem", "/*.", coreclient.SORT_NAME, coreclient.ORDER_ASC)

for _, file := range files {
    fmt.Printf("%+v\n", file)
}

Description:

List all files on the memory filesystem

List all files on the memory filesystem. The listing can be ordered by name, size, or date of last modification in ascending or descending order.

GET//api/v3/fs/mem

Authorization

Query parameters

globstring

glob pattern for file names

sortstring

none, name, size, lastmod

orderstring

asc, desc

Response

Body

last_modifiedinteger

namestring

size_bytesinteger

Request

Response

Download a file

For downloading a file you have to specify the complete path and filename. The Content-Type will always be application/data.

Example:

curl http://127.0.0.1:8080/api/v3/fs/mem/example.txt \
   -X GET

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

core_memfs_file = client.v3_fs_get_file(
    name="mem",
    path="example.txt"
)
print(core_memfs_file)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

data, err := client.FilesystemGetFile("mem", "/example.txt")
defer data.Close()

The returned data is an io.ReadCloser.

Description:

Fetch a file from the memory filesystem

GET//api/v3/fs/mem/{path}

Authorization

Path parameters

path*string

Path to file

Response

Body

string (binary)

Request

Response

Link

Linking a file will return a redirect to the linked file. The target of the redirect has to be in the body of the request.

Example:

curl http://127.0.0.1:8080/api/v3/fs/mem/example2.txt \
   -d 'example.txt'
   -X PATCH

Missed.

This is not implemented in the client.

Description:

Create a link to a file in the memory filesystem

Create a link to a file in the memory filesystem. The file linked to has to exist.

PATCH//api/v3/fs/mem/{path}

Authorization

Path parameters

path*string

Path to file

Body

Path to the file to link to

string

Response

Created

Body

string

Request

Response

Delete

For deleting a file you have to specify the complete path and filename.

Example:

curl http://127.0.0.1:8080/api/v3/fs/mem/example.txt \
   -X DELETE

from core_client import Client

client = Client(base_url="http://127.0.0.1:8080")
client.login()

client.v3_fs_delete_file(
    name="mem",
    path="example.txt"
)

import (
    "github.com/datarhei/core-client-go/v16"
)

client, _ := coreclient.New(coreclient.Config{
    Address: "https://127.0.0.1:8080",
})

err := client.FilesystemDeleteFile("mem", "/example.txt")

Description:

Remove a file from the memory filesystem

DELETE//api/v3/fs/mem/{path}

Authorization

Path parameters

path*string

Path to file

Response

Body

string

Request

Response

Configuration

In-memory