mirror of
https://github.com/ceph/ceph-csi.git
synced 2024-11-18 04:10:22 +00:00
128 lines
3.9 KiB
Go
128 lines
3.9 KiB
Go
package rados
|
|
|
|
// #cgo LDFLAGS: -lrados
|
|
// #include <errno.h>
|
|
// #include <stdlib.h>
|
|
// #include <rados/librados.h>
|
|
import "C"
|
|
|
|
import (
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
const (
|
|
// AllNamespaces is used to reset a selected namespace to all
|
|
// namespaces. See the IOContext SetNamespace function.
|
|
AllNamespaces = C.LIBRADOS_ALL_NSPACES
|
|
|
|
// FIXME: for backwards compatibility
|
|
|
|
// RadosAllNamespaces is used to reset a selected namespace to all
|
|
// namespaces. See the IOContext SetNamespace function.
|
|
//
|
|
// Deprecated: use AllNamespaces instead
|
|
RadosAllNamespaces = AllNamespaces
|
|
)
|
|
|
|
// OpFlags are flags that can be set on a per-op basis.
|
|
type OpFlags uint
|
|
|
|
const (
|
|
// OpFlagNone can be use to not set any flags.
|
|
OpFlagNone = OpFlags(0)
|
|
// OpFlagExcl marks an op to fail a create operation if the object
|
|
// already exists.
|
|
OpFlagExcl = OpFlags(C.LIBRADOS_OP_FLAG_EXCL)
|
|
// OpFlagFailOk allows the transaction to succeed even if the flagged
|
|
// op fails.
|
|
OpFlagFailOk = OpFlags(C.LIBRADOS_OP_FLAG_FAILOK)
|
|
// OpFlagFAdviseRandom indicates read/write op random.
|
|
OpFlagFAdviseRandom = OpFlags(C.LIBRADOS_OP_FLAG_FADVISE_RANDOM)
|
|
// OpFlagFAdviseSequential indicates read/write op sequential.
|
|
OpFlagFAdviseSequential = OpFlags(C.LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL)
|
|
// OpFlagFAdviseWillNeed indicates read/write data will be accessed in
|
|
// the near future (by someone).
|
|
OpFlagFAdviseWillNeed = OpFlags(C.LIBRADOS_OP_FLAG_FADVISE_WILLNEED)
|
|
// OpFlagFAdviseDontNeed indicates read/write data will not accessed in
|
|
// the near future (by anyone).
|
|
OpFlagFAdviseDontNeed = OpFlags(C.LIBRADOS_OP_FLAG_FADVISE_DONTNEED)
|
|
// OpFlagFAdviseNoCache indicates read/write data will not accessed
|
|
// again (by *this* client).
|
|
OpFlagFAdviseNoCache = OpFlags(C.LIBRADOS_OP_FLAG_FADVISE_NOCACHE)
|
|
)
|
|
|
|
// Version returns the major, minor, and patch components of the version of
|
|
// the RADOS library linked against.
|
|
func Version() (int, int, int) {
|
|
var cMajor, cMinor, cPatch C.int
|
|
C.rados_version(&cMajor, &cMinor, &cPatch)
|
|
return int(cMajor), int(cMinor), int(cPatch)
|
|
}
|
|
|
|
func makeConn() *Conn {
|
|
return &Conn{connected: false}
|
|
}
|
|
|
|
func newConn(user *C.char) (*Conn, error) {
|
|
conn := makeConn()
|
|
ret := C.rados_create(&conn.cluster, user)
|
|
|
|
if ret != 0 {
|
|
return nil, getError(ret)
|
|
}
|
|
|
|
runtime.SetFinalizer(conn, freeConn)
|
|
return conn, nil
|
|
}
|
|
|
|
// NewConn creates a new connection object. It returns the connection and an
|
|
// error, if any.
|
|
func NewConn() (*Conn, error) {
|
|
return newConn(nil)
|
|
}
|
|
|
|
// NewConnWithUser creates a new connection object with a custom username.
|
|
// It returns the connection and an error, if any.
|
|
func NewConnWithUser(user string) (*Conn, error) {
|
|
cUser := C.CString(user)
|
|
defer C.free(unsafe.Pointer(cUser))
|
|
return newConn(cUser)
|
|
}
|
|
|
|
// NewConnWithClusterAndUser creates a new connection object for a specific cluster and username.
|
|
// It returns the connection and an error, if any.
|
|
func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
|
|
cClusterName := C.CString(clusterName)
|
|
defer C.free(unsafe.Pointer(cClusterName))
|
|
|
|
cName := C.CString(userName)
|
|
defer C.free(unsafe.Pointer(cName))
|
|
|
|
conn := makeConn()
|
|
ret := C.rados_create2(&conn.cluster, cClusterName, cName, 0)
|
|
if ret != 0 {
|
|
return nil, getError(ret)
|
|
}
|
|
|
|
runtime.SetFinalizer(conn, freeConn)
|
|
return conn, nil
|
|
}
|
|
|
|
// freeConn releases resources that are allocated while configuring the
|
|
// connection to the cluster. rados_shutdown() should only be needed after a
|
|
// successful call to rados_connect(), however if the connection has been
|
|
// configured with non-default parameters, some of the parameters may be
|
|
// allocated before connecting. rados_shutdown() will free the allocated
|
|
// resources, even if there has not been a connection yet.
|
|
//
|
|
// This function is setup as a destructor/finalizer when rados_create() is
|
|
// called.
|
|
func freeConn(conn *Conn) {
|
|
if conn.cluster != nil {
|
|
C.rados_shutdown(conn.cluster)
|
|
// prevent calling rados_shutdown() more than once
|
|
conn.cluster = nil
|
|
}
|
|
}
|