package shmqueue
|
|
import (
|
"context"
|
"fmt"
|
"time"
|
"github.com/gen2brain/shm"
|
)
|
|
// NewBlock shm block with size
|
func NewBlock(size int, key int) ([]byte, int, error) {
|
id, err := shm.Get(key, size, shm.IPC_CREAT|0666)
|
fmt.Println("Get:", id, err)
|
if err != nil || id == -1 {
|
return nil, -1, err
|
}
|
|
data, err2 := shm.At(id, 0, 0)
|
if err2 != nil {
|
return nil, -1, err2
|
}
|
|
return data, id, nil
|
}
|
|
// AttachBlock attach exist shm
|
func AttachBlock(key int) ([]byte, int, error) {
|
id, err := shm.Get(key, 0, 0)
|
fmt.Println("Get:", id, err)
|
if err != nil || id == -1 { //no exist
|
return nil, -1, err
|
}
|
|
data, err2 := shm.At(id, 0, 0)
|
if err2 != nil {
|
return nil, -1, err2
|
}
|
|
return data, id, nil
|
}
|
|
// ReleaseBlock release shm block
|
func ReleaseBlock(data []byte) {
|
if data != nil {
|
shm.Dt(data)
|
}
|
}
|
|
// CreateRawShm create raw shm block with size, only space, no padding, return data([]byte), id(int)
|
// context for quit
|
func CreateRawShm(ctx context.Context, size int, key int) ([]byte, int) {
|
data, id, err := AttachBlock(key)
|
fmt.Println("err:", err)
|
if err != nil {
|
loopB:
|
for {
|
select {
|
case <-ctx.Done():
|
return nil, -1
|
default:
|
if err == nil {
|
break loopB
|
} else {
|
fmt.Println("createShm error:", err)
|
}
|
time.Sleep(time.Millisecond)
|
data, id, err = NewBlock(size, key)
|
}
|
}
|
}
|
return data, id
|
}
|
|
//AttachRawShm don't create
|
func AttachRawShm(ctx context.Context, key int) ([]byte, int) {
|
data, id, err := AttachBlock(key)
|
if err != nil {
|
loopB:
|
for {
|
select {
|
case <-ctx.Done():
|
return nil, -1
|
default:
|
if err == nil {
|
break loopB
|
} else {
|
fmt.Println("createShm error:", err)
|
}
|
time.Sleep(time.Millisecond)
|
data, id, err = AttachBlock(key)
|
}
|
}
|
}
|
return data, id
|
}
|
|
// CreatePaddingShm create padding shm block with size, return data-with-padding([]byte), id(int)
|
// context for quit, padding for fill raw shm block
|
func CreatePaddingShm(ctx context.Context, size int, key int, padding []byte) ([]byte, int) {
|
data, id, err := NewBlock(size, key)
|
if err != nil {
|
loopB:
|
for {
|
select {
|
case <-ctx.Done():
|
return nil, -1
|
default:
|
if err == nil {
|
break loopB
|
} else {
|
fmt.Println("createShm error:", err)
|
}
|
time.Sleep(time.Millisecond)
|
data, id, err = NewBlock(size, key)
|
}
|
}
|
}
|
|
copy(data, padding)
|
return data, id
|
}
|
|
// DetachShm destroy
|
func DetachShm(data []byte) {
|
ReleaseBlock(data)
|
}
|
|
// Attach attach shmid get block
|
func Attach(id int) ([]byte, error) {
|
return shm.At(id, 0, 0)
|
}
|
|
// Detach detach shm block
|
func Detach(d []byte) error {
|
return shm.Dt(d)
|
}
|
|
// RemoveShmID Remove shmid
|
func RemoveShmID(id int) error {
|
return shm.Rm(id)
|
}
|
|
// RemoveShmKey Remove shmkey
|
func RemoveShmKey(shmkey int) error {
|
_, id, err := AttachBlock(shmkey)
|
if err != nil {
|
return err
|
} else {
|
return shm.Rm(id)
|
}
|
}
|
|
// DetachShmKey detach shmkey
|
func DetachShmKey(shmkey int) error {
|
d, _, err := AttachBlock(shmkey)
|
if err != nil {
|
return err
|
} else {
|
return Detach(d)
|
}
|
}
|
|
// DetachAndRemoveShmKey detach and Remove shmkey
|
func DetachAndRemoveShmKey(shmkey int) error {
|
d, id, err := AttachBlock(shmkey)
|
if err != nil {
|
return err
|
} else {
|
Detach(d)
|
return shm.Rm(id)
|
}
|
}
|
