mirror of
https://github.com/ceph/go-ceph
synced 2024-12-24 15:13:11 +00:00
112 lines
2.4 KiB
Go
112 lines
2.4 KiB
Go
//go:build ceph_preview
|
|
// +build ceph_preview
|
|
|
|
package rados
|
|
|
|
// #cgo LDFLAGS: -lrados
|
|
// #include <stdlib.h>
|
|
// #include <rados/librados.h>
|
|
//
|
|
import "C"
|
|
|
|
import (
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
// ReadOpExecStep - step for exec operation code.
|
|
type ReadOpExecStep struct {
|
|
withoutFree
|
|
|
|
inBuffPtr *C.char
|
|
inBuffLen C.size_t
|
|
outBuffPtr *C.char
|
|
outBuffLen C.size_t
|
|
prval C.int
|
|
canReadOutput bool
|
|
}
|
|
|
|
// newExecStepOp - init new *execStepOp.
|
|
func newReadOpExecStep(in []byte) *ReadOpExecStep {
|
|
es := &ReadOpExecStep{
|
|
outBuffPtr: nil,
|
|
outBuffLen: 0,
|
|
prval: 0,
|
|
}
|
|
|
|
if len(in) > 0 {
|
|
es.inBuffPtr = (*C.char)(unsafe.Pointer(&in[0]))
|
|
es.inBuffLen = C.size_t(len(in))
|
|
}
|
|
|
|
runtime.SetFinalizer(es, func(es *ReadOpExecStep) {
|
|
if es != nil {
|
|
es.freeBuffer()
|
|
es = nil
|
|
}
|
|
})
|
|
return es
|
|
}
|
|
|
|
// freeBuffer - releases C allocated buffer. It is separated from es.free() because lifespan of C allocated buffer is
|
|
// longer than lifespan of read operation.
|
|
func (es *ReadOpExecStep) freeBuffer() {
|
|
if es.outBuffPtr != nil {
|
|
C.free(unsafe.Pointer(es.outBuffPtr))
|
|
es.outBuffPtr = nil
|
|
es.canReadOutput = false
|
|
}
|
|
}
|
|
|
|
// update - update state operation.
|
|
func (es *ReadOpExecStep) update() error {
|
|
err := getError(es.prval)
|
|
es.canReadOutput = err == nil
|
|
return err
|
|
}
|
|
|
|
// Bytes returns the result of the executed command as a byte slice.
|
|
func (es *ReadOpExecStep) Bytes() ([]byte, error) {
|
|
if !es.canReadOutput {
|
|
return nil, ErrOperationIncomplete
|
|
}
|
|
|
|
return C.GoBytes(unsafe.Pointer(es.outBuffPtr), C.int(es.outBuffLen)), nil
|
|
}
|
|
|
|
// Exec executes an OSD class method on an object.
|
|
// See rados_exec() in the RADOS C api documentation for a general description.
|
|
//
|
|
// Implements:
|
|
//
|
|
// void rados_read_op_exec(rados_read_op_t read_op,
|
|
// const char *cls,
|
|
// const char *method,
|
|
// const char *in_buf,
|
|
// size_t in_len,
|
|
// char **out_buf,
|
|
// size_t *out_len,
|
|
// int *prval);
|
|
func (r *ReadOp) Exec(clsName, method string, in []byte) *ReadOpExecStep {
|
|
cClsName := C.CString(clsName)
|
|
defer C.free(unsafe.Pointer(cClsName))
|
|
|
|
cMethod := C.CString(method)
|
|
defer C.free(unsafe.Pointer(cMethod))
|
|
|
|
es := newReadOpExecStep(in)
|
|
r.steps = append(r.steps, es)
|
|
C.rados_read_op_exec(
|
|
r.op,
|
|
cClsName,
|
|
cMethod,
|
|
es.inBuffPtr,
|
|
es.inBuffLen,
|
|
&es.outBuffPtr,
|
|
&es.outBuffLen,
|
|
&es.prval,
|
|
)
|
|
|
|
return es
|
|
}
|