package/go-astikit
1
0
Fork 0
mirror of https://github.com/asticode/go-astikit.git synced 2025-12-24 11:50:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Split ipc posix/systemv in different packages

Browse Source
This commit is contained in:
Quentin Renard
2024-11-24 16:24:53 +01:00
parent 1e1241572a
commit f8dea4ff1d
10 changed files with 127 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/test.yml vendored
View File

@@ -31,9 +31,7 @@ jobs:
run: go mod download
- name: Run tests
run: |
echo "CGO_ENABLED=0" >> $env:GITHUB_ENV
go test -race -covermode atomic -coverprofile=covprofile ./...
run: go test -race -covermode atomic -coverprofile=covprofile ./...
- if: github.event_name != 'pull_request'
name: Send coverage

0
ipc_posix.c → ipc/posix/posix.c
View File

74
ipc_posix.go → ipc/posix/posix.go
View File

@@ -1,10 +1,10 @@
//go:build !windows
package astikit
package astiposix
//#include <stdlib.h>
//#include <string.h>
//#include "ipc_posix.h"
//#include "posix.h"
import "C"
import (
"errors"
@@ -17,7 +17,7 @@ import (
"unsafe"
)
type PosixSharedMemory struct {
type SharedMemory struct {
addr unsafe.Pointer
cname string
fd *C.int
@@ -26,9 +26,9 @@ type PosixSharedMemory struct {
unlink bool
}
func newPosixSharedMemory(name string, flags, mode int, cb func(shm *PosixSharedMemory) error) (shm *PosixSharedMemory, err error) {
func newSharedMemory(name string, flags, mode int, cb func(shm *SharedMemory) error) (shm *SharedMemory, err error) {
// Create shared memory
shm = &PosixSharedMemory{name: name}
shm = &SharedMemory{name: name}
// To have a similar behavior with python, we need to handle the leading slash the same way:
// - make sure the "public" name has no leading "/"
@@ -84,8 +84,8 @@ func newPosixSharedMemory(name string, flags, mode int, cb func(shm *PosixShared
return
}
func CreatePosixSharedMemory(name string, size int) (*PosixSharedMemory, error) {
return newPosixSharedMemory(name, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600, func(shm *PosixSharedMemory) (err error) {
func CreateSharedMemory(name string, size int) (*SharedMemory, error) {
return newSharedMemory(name, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600, func(shm *SharedMemory) (err error) {
// Shared memory needs to be unlink on close
shm.unlink = true
@@ -99,11 +99,11 @@ func CreatePosixSharedMemory(name string, size int) (*PosixSharedMemory, error)
})
}
func OpenPosixSharedMemory(name string) (*PosixSharedMemory, error) {
return newPosixSharedMemory(name, os.O_RDWR, 0600, nil)
func OpenSharedMemory(name string) (*SharedMemory, error) {
return newSharedMemory(name, os.O_RDWR, 0600, nil)
}
func (shm *PosixSharedMemory) Close() error {
func (shm *SharedMemory) Close() error {
// Unlink
if shm.unlink {
// Get c name
@@ -138,7 +138,7 @@ func (shm *PosixSharedMemory) Close() error {
return nil
}
func (shm *PosixSharedMemory) Write(src unsafe.Pointer, size int) error {
func (shm *SharedMemory) Write(src unsafe.Pointer, size int) error {
// Unmapped
if shm.addr == nil {
return errors.New("astikit: shared memory is unmapped")
@@ -149,7 +149,7 @@ func (shm *PosixSharedMemory) Write(src unsafe.Pointer, size int) error {
return nil
}
func (shm *PosixSharedMemory) WriteBytes(b []byte) error {
func (shm *SharedMemory) WriteBytes(b []byte) error {
// Get c bytes
cb := C.CBytes(b)
defer C.free(cb)
@@ -158,7 +158,7 @@ func (shm *PosixSharedMemory) WriteBytes(b []byte) error {
return shm.Write(cb, len(b))
}
func (shm *PosixSharedMemory) ReadBytes(size int) ([]byte, error) {
func (shm *SharedMemory) ReadBytes(size int) ([]byte, error) {
// Unmapped
if shm.addr == nil {
return nil, errors.New("astikit: shared memory is unmapped")
@@ -168,39 +168,39 @@ func (shm *PosixSharedMemory) ReadBytes(size int) ([]byte, error) {
return C.GoBytes(shm.addr, C.int(size)), nil
}
func (shm *PosixSharedMemory) Name() string {
func (shm *SharedMemory) Name() string {
return shm.name
}
func (shm *PosixSharedMemory) Size() int {
func (shm *SharedMemory) Size() int {
return shm.size
}
func (shm *PosixSharedMemory) Addr() unsafe.Pointer {
func (shm *SharedMemory) Addr() unsafe.Pointer {
return shm.addr
}
type PosixVariableSizeSharedMemoryWriter struct {
type VariableSizeSharedMemoryWriter struct {
m sync.Mutex // Locks write operations
prefix string
shm *PosixSharedMemory
shm *SharedMemory
}
func NewPosixVariableSizeSharedMemoryWriter(prefix string) *PosixVariableSizeSharedMemoryWriter {
return &PosixVariableSizeSharedMemoryWriter{prefix: prefix}
func NewVariableSizeSharedMemoryWriter(prefix string) *VariableSizeSharedMemoryWriter {
return &VariableSizeSharedMemoryWriter{prefix: prefix}
}
func (w *PosixVariableSizeSharedMemoryWriter) closeSharedMemory() {
func (w *VariableSizeSharedMemoryWriter) closeSharedMemory() {
if w.shm != nil {
w.shm.Close()
}
}
func (w *PosixVariableSizeSharedMemoryWriter) Close() {
func (w *VariableSizeSharedMemoryWriter) Close() {
w.closeSharedMemory()
}
func (w *PosixVariableSizeSharedMemoryWriter) Write(src unsafe.Pointer, size int) (ro PosixVariableSizeSharedMemoryReadOptions, err error) {
func (w *VariableSizeSharedMemoryWriter) Write(src unsafe.Pointer, size int) (ro VariableSizeSharedMemoryReadOptions, err error) {
// Lock
w.m.Lock()
defer w.m.Unlock()
@@ -211,8 +211,8 @@ func (w *PosixVariableSizeSharedMemoryWriter) Write(src unsafe.Pointer, size int
w.closeSharedMemory()
// Create shared memory
var shm *PosixSharedMemory
if shm, err = CreatePosixSharedMemory(w.prefix+"-"+strconv.Itoa(size), size); err != nil {
var shm *SharedMemory
if shm, err = CreateSharedMemory(w.prefix+"-"+strconv.Itoa(size), size); err != nil {
err = fmt.Errorf("astikit: creating shared memory failed: %w", err)
return
}
@@ -228,14 +228,14 @@ func (w *PosixVariableSizeSharedMemoryWriter) Write(src unsafe.Pointer, size int
}
// Create read options
ro = PosixVariableSizeSharedMemoryReadOptions{
ro = VariableSizeSharedMemoryReadOptions{
Name: w.shm.Name(),
Size: size,
}
return
}
func (w *PosixVariableSizeSharedMemoryWriter) WriteBytes(b []byte) (PosixVariableSizeSharedMemoryReadOptions, error) {
func (w *VariableSizeSharedMemoryWriter) WriteBytes(b []byte) (VariableSizeSharedMemoryReadOptions, error) {
// Get c bytes
cb := C.CBytes(b)
defer C.free(cb)
@@ -244,31 +244,31 @@ func (w *PosixVariableSizeSharedMemoryWriter) WriteBytes(b []byte) (PosixVariabl
return w.Write(cb, len(b))
}
type PosixVariableSizeSharedMemoryReader struct {
type VariableSizeSharedMemoryReader struct {
m sync.Mutex // Locks read operations
shm *PosixSharedMemory
shm *SharedMemory
}
func NewPosixVariableSizeSharedMemoryReader() *PosixVariableSizeSharedMemoryReader {
return &PosixVariableSizeSharedMemoryReader{}
func NewVariableSizeSharedMemoryReader() *VariableSizeSharedMemoryReader {
return &VariableSizeSharedMemoryReader{}
}
func (r *PosixVariableSizeSharedMemoryReader) closeSharedMemory() {
func (r *VariableSizeSharedMemoryReader) closeSharedMemory() {
if r.shm != nil {
r.shm.Close()
}
}
func (r *PosixVariableSizeSharedMemoryReader) Close() {
func (r *VariableSizeSharedMemoryReader) Close() {
r.closeSharedMemory()
}
type PosixVariableSizeSharedMemoryReadOptions struct {
type VariableSizeSharedMemoryReadOptions struct {
Name string `json:"name"`
Size int `json:"size"`
}
func (r *PosixVariableSizeSharedMemoryReader) ReadBytes(o PosixVariableSizeSharedMemoryReadOptions) (b []byte, err error) {
func (r *VariableSizeSharedMemoryReader) ReadBytes(o VariableSizeSharedMemoryReadOptions) (b []byte, err error) {
// Lock
r.m.Lock()
defer r.m.Unlock()
@@ -279,8 +279,8 @@ func (r *PosixVariableSizeSharedMemoryReader) ReadBytes(o PosixVariableSizeShare
r.closeSharedMemory()
// Open shared memory
var shm *PosixSharedMemory
if shm, err = OpenPosixSharedMemory(o.Name); err != nil {
var shm *SharedMemory
if shm, err = OpenSharedMemory(o.Name); err != nil {
err = fmt.Errorf("astikit: opening shared memory failed: %w", err)
return
}

0
ipc_posix.h → ipc/posix/posix.h
View File

16
ipc_posix_test.go → ipc/posix/posix_test.go
View File

@@ -1,14 +1,14 @@
//go:build !windows
package astikit
package astiposix
import (
"bytes"
"testing"
)
func TestPosixSharedMemory(t *testing.T) {
sm1, err := CreatePosixSharedMemory("/test", 8)
func TestSharedMemory(t *testing.T) {
sm1, err := CreateSharedMemory("/test", 8)
if err != nil {
t.Fatalf("expected no error, got %s", err)
}
@@ -22,7 +22,7 @@ func TestPosixSharedMemory(t *testing.T) {
if e, g := "test", sm1.Name(); e != g {
t.Fatalf("expected %v, got %v", e, g)
}
if _, err = CreatePosixSharedMemory("/test", 8); err == nil {
if _, err = CreateSharedMemory("/test", 8); err == nil {
t.Fatal("expected error, got nil")
}
@@ -31,7 +31,7 @@ func TestPosixSharedMemory(t *testing.T) {
t.Fatalf("expected no error, got %s", err)
}
sm2, err := OpenPosixSharedMemory("test")
sm2, err := OpenSharedMemory("test")
if err != nil {
t.Fatalf("expected no error, got %s", err)
}
@@ -65,10 +65,10 @@ func TestPosixSharedMemory(t *testing.T) {
}
}
func TestPosixVariableSizeSharedMemory(t *testing.T) {
w := NewPosixVariableSizeSharedMemoryWriter("test-1")
func TestVariableSizeSharedMemory(t *testing.T) {
w := NewVariableSizeSharedMemoryWriter("test-1")
defer w.Close()
r := NewPosixVariableSizeSharedMemoryReader()
r := NewVariableSizeSharedMemoryReader()
defer r.Close()
b1 := []byte("test")

0
ipc_systemv.c → ipc/systemv/systemv.c
View File

118
ipc_systemv.go → ipc/systemv/systemv.go
View File

@@ -1,11 +1,11 @@
//go:build !windows
package astikit
package astisystemv
//#include <sys/shm.h>
//#include <stdlib.h>
//#include <string.h>
//#include "ipc_systemv.h"
//#include "systemv.h"
import "C"
import (
"errors"
@@ -14,9 +14,11 @@ import (
"syscall"
"time"
"unsafe"
"github.com/asticode/go-astikit"
)
func NewSystemVKey(projectID int, path string) (int, error) {
func NewKey(projectID int, path string) (int, error) {
// Get c path
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
@@ -35,33 +37,33 @@ const (
IpcExclusive = C.IPC_EXCL
)
type SystemVSemaphore struct {
type Semaphore struct {
id C.int
key int
}
func newSystemVSemaphore(key int, flags int) (*SystemVSemaphore, error) {
func newSemaphore(key int, flags int) (*Semaphore, error) {
// Get id
var errno C.int
id := C.astikit_sem_get(C.int(key), C.int(flags), &errno)
if id < 0 {
return nil, fmt.Errorf("astikit: sem_get failed: %w", syscall.Errno(errno))
}
return &SystemVSemaphore{
return &Semaphore{
id: id,
key: key,
}, nil
}
func CreateSystemVSemaphore(key, flags int) (*SystemVSemaphore, error) {
return newSystemVSemaphore(key, flags)
func CreateSemaphore(key, flags int) (*Semaphore, error) {
return newSemaphore(key, flags)
}
func OpenSystemVSemaphore(key int) (*SystemVSemaphore, error) {
return newSystemVSemaphore(key, 0)
func OpenSemaphore(key int) (*Semaphore, error) {
return newSemaphore(key, 0)
}
func (s *SystemVSemaphore) Close() error {
func (s *Semaphore) Close() error {
// Already closed
if s.id == -1 {
return nil
@@ -79,7 +81,7 @@ func (s *SystemVSemaphore) Close() error {
return nil
}
func (s *SystemVSemaphore) Lock() error {
func (s *Semaphore) Lock() error {
// Closed
if s.id == -1 {
return errors.New("astikit: semaphore is closed")
@@ -94,7 +96,7 @@ func (s *SystemVSemaphore) Lock() error {
return nil
}
func (s *SystemVSemaphore) Unlock() error {
func (s *Semaphore) Unlock() error {
// Closed
if s.id == -1 {
return errors.New("astikit: semaphore is closed")
@@ -109,17 +111,17 @@ func (s *SystemVSemaphore) Unlock() error {
return nil
}
func (s *SystemVSemaphore) Key() int {
func (s *Semaphore) Key() int {
return s.key
}
type SystemVSharedMemory struct {
type SharedMemory struct {
addr unsafe.Pointer
id C.int
key int
}
func newSystemVSharedMemory(key, size int, flags int) (shm *SystemVSharedMemory, err error) {
func newSharedMemory(key, size int, flags int) (shm *SharedMemory, err error) {
// Get id
var errno C.int
id := C.astikit_shm_get(C.int(key), C.int(size), C.int(flags), &errno)
@@ -129,7 +131,7 @@ func newSystemVSharedMemory(key, size int, flags int) (shm *SystemVSharedMemory,
}
// Create shared memory
shm = &SystemVSharedMemory{
shm = &SharedMemory{
id: id,
key: key,
}
@@ -153,15 +155,15 @@ func newSystemVSharedMemory(key, size int, flags int) (shm *SystemVSharedMemory,
return
}
func CreateSystemVSharedMemory(key, size, flags int) (*SystemVSharedMemory, error) {
return newSystemVSharedMemory(key, size, flags)
func CreateSharedMemory(key, size, flags int) (*SharedMemory, error) {
return newSharedMemory(key, size, flags)
}
func OpenSystemVSharedMemory(key int) (*SystemVSharedMemory, error) {
return newSystemVSharedMemory(key, 0, 0)
func OpenSharedMemory(key int) (*SharedMemory, error) {
return newSharedMemory(key, 0, 0)
}
func (shm *SystemVSharedMemory) Close() error {
func (shm *SharedMemory) Close() error {
// Already closed
if shm.id == -1 {
return nil
@@ -180,7 +182,7 @@ func (shm *SystemVSharedMemory) Close() error {
return nil
}
func (shm *SystemVSharedMemory) Write(src unsafe.Pointer, size int) error {
func (shm *SharedMemory) Write(src unsafe.Pointer, size int) error {
// Closed
if shm.id == -1 {
return errors.New("astikit: shared memory is closed")
@@ -191,7 +193,7 @@ func (shm *SystemVSharedMemory) Write(src unsafe.Pointer, size int) error {
return nil
}
func (shm *SystemVSharedMemory) WriteBytes(b []byte) error {
func (shm *SharedMemory) WriteBytes(b []byte) error {
// Get c bytes
cb := C.CBytes(b)
defer C.free(cb)
@@ -200,15 +202,15 @@ func (shm *SystemVSharedMemory) WriteBytes(b []byte) error {
return shm.Write(cb, len(b))
}
func (shm *SystemVSharedMemory) Addr() unsafe.Pointer {
func (shm *SharedMemory) Addr() unsafe.Pointer {
return shm.addr
}
func (shm *SystemVSharedMemory) Key() int {
func (shm *SharedMemory) Key() int {
return shm.key
}
func (shm *SystemVSharedMemory) ReadBytes(size int) ([]byte, error) {
func (shm *SharedMemory) ReadBytes(size int) ([]byte, error) {
// Closed
if shm.id == -1 {
return nil, errors.New("astikit: shared memory is closed")
@@ -218,39 +220,39 @@ func (shm *SystemVSharedMemory) ReadBytes(size int) ([]byte, error) {
return C.GoBytes(shm.addr, C.int(size)), nil
}
type SystemVSemaphoredSharedMemoryWriter struct {
type SemaphoredSharedMemoryWriter struct {
m sync.Mutex // Locks write operations
sem *SystemVSemaphore
shm *SystemVSharedMemory
sem *Semaphore
shm *SharedMemory
shmAt int64
shmSize int
}
func NewSystemVSemaphoredSharedMemoryWriter() *SystemVSemaphoredSharedMemoryWriter {
return &SystemVSemaphoredSharedMemoryWriter{}
func NewSemaphoredSharedMemoryWriter() *SemaphoredSharedMemoryWriter {
return &SemaphoredSharedMemoryWriter{}
}
func (w *SystemVSemaphoredSharedMemoryWriter) closeSemaphore() {
func (w *SemaphoredSharedMemoryWriter) closeSemaphore() {
if w.sem != nil {
w.sem.Close()
}
}
func (w *SystemVSemaphoredSharedMemoryWriter) closeSharedMemory() {
func (w *SemaphoredSharedMemoryWriter) closeSharedMemory() {
if w.shm != nil {
w.shm.Close()
}
}
func (w *SystemVSemaphoredSharedMemoryWriter) Close() {
func (w *SemaphoredSharedMemoryWriter) Close() {
w.closeSemaphore()
w.closeSharedMemory()
}
func (w *SystemVSemaphoredSharedMemoryWriter) generateRandomKey(f func(key int) error) error {
func (w *SemaphoredSharedMemoryWriter) generateRandomKey(f func(key int) error) error {
try := 0
for {
key := int(int32(randSrc.Int63()))
key := int(int32(astikit.RandSource.Int63()))
if key == int(C.IPC_PRIVATE) {
continue
}
@@ -265,7 +267,7 @@ func (w *SystemVSemaphoredSharedMemoryWriter) generateRandomKey(f func(key int)
}
}
func (w *SystemVSemaphoredSharedMemoryWriter) Write(src unsafe.Pointer, size int) (ro *SystemVSemaphoredSharedMemoryReadOptions, err error) {
func (w *SemaphoredSharedMemoryWriter) Write(src unsafe.Pointer, size int) (ro *SemaphoredSharedMemoryReadOptions, err error) {
// Lock
w.m.Lock()
defer w.m.Unlock()
@@ -279,8 +281,8 @@ func (w *SystemVSemaphoredSharedMemoryWriter) Write(src unsafe.Pointer, size int
// Generate random key
if err = w.generateRandomKey(func(key int) (err error) {
// Create shared memory
var shm *SystemVSharedMemory
if shm, err = CreateSystemVSharedMemory(key, size, IpcCreate|IpcExclusive|0666); err != nil {
var shm *SharedMemory
if shm, err = CreateSharedMemory(key, size, IpcCreate|IpcExclusive|0666); err != nil {
err = fmt.Errorf("astikit: creating shared memory failed: %w", err)
return
}
@@ -301,8 +303,8 @@ func (w *SystemVSemaphoredSharedMemoryWriter) Write(src unsafe.Pointer, size int
// Generate random key
if err = w.generateRandomKey(func(key int) (err error) {
// Create semaphore
var sem *SystemVSemaphore
if sem, err = CreateSystemVSemaphore(key, IpcCreate|IpcExclusive|0666); err != nil {
var sem *Semaphore
if sem, err = CreateSemaphore(key, IpcCreate|IpcExclusive|0666); err != nil {
err = fmt.Errorf("astikit: creating semaphore failed: %w", err)
return
}
@@ -335,7 +337,7 @@ func (w *SystemVSemaphoredSharedMemoryWriter) Write(src unsafe.Pointer, size int
}
// Create read options
ro = &SystemVSemaphoredSharedMemoryReadOptions{
ro = &SemaphoredSharedMemoryReadOptions{
SemaphoreKey: w.sem.Key(),
SharedMemoryAt: w.shmAt,
SharedMemoryKey: w.shm.Key(),
@@ -344,7 +346,7 @@ func (w *SystemVSemaphoredSharedMemoryWriter) Write(src unsafe.Pointer, size int
return
}
func (w *SystemVSemaphoredSharedMemoryWriter) WriteBytes(b []byte) (*SystemVSemaphoredSharedMemoryReadOptions, error) {
func (w *SemaphoredSharedMemoryWriter) WriteBytes(b []byte) (*SemaphoredSharedMemoryReadOptions, error) {
// Get c bytes
cb := C.CBytes(b)
defer C.free(cb)
@@ -353,42 +355,42 @@ func (w *SystemVSemaphoredSharedMemoryWriter) WriteBytes(b []byte) (*SystemVSema
return w.Write(cb, len(b))
}
type SystemVSemaphoredSharedMemoryReader struct {
type SemaphoredSharedMemoryReader struct {
m sync.Mutex // Locks read operations
sem *SystemVSemaphore
shm *SystemVSharedMemory
sem *Semaphore
shm *SharedMemory
shmAt int64
}
func NewSystemVSemaphoredSharedMemoryReader() *SystemVSemaphoredSharedMemoryReader {
return &SystemVSemaphoredSharedMemoryReader{}
func NewSemaphoredSharedMemoryReader() *SemaphoredSharedMemoryReader {
return &SemaphoredSharedMemoryReader{}
}
func (r *SystemVSemaphoredSharedMemoryReader) closeSemaphore() {
func (r *SemaphoredSharedMemoryReader) closeSemaphore() {
if r.sem != nil {
r.sem.Close()
}
}
func (r *SystemVSemaphoredSharedMemoryReader) closeSharedMemory() {
func (r *SemaphoredSharedMemoryReader) closeSharedMemory() {
if r.shm != nil {
r.shm.Close()
}
}
func (r *SystemVSemaphoredSharedMemoryReader) Close() {
func (r *SemaphoredSharedMemoryReader) Close() {
r.closeSemaphore()
r.closeSharedMemory()
}
type SystemVSemaphoredSharedMemoryReadOptions struct {
type SemaphoredSharedMemoryReadOptions struct {
SemaphoreKey int
SharedMemoryAt int64
SharedMemoryKey int
Size int
}
func (r *SystemVSemaphoredSharedMemoryReader) ReadBytes(o *SystemVSemaphoredSharedMemoryReadOptions) (b []byte, err error) {
func (r *SemaphoredSharedMemoryReader) ReadBytes(o *SemaphoredSharedMemoryReadOptions) (b []byte, err error) {
// Lock
r.m.Lock()
defer r.m.Unlock()
@@ -399,8 +401,8 @@ func (r *SystemVSemaphoredSharedMemoryReader) ReadBytes(o *SystemVSemaphoredShar
r.closeSharedMemory()
// Open shared memory
var shm *SystemVSharedMemory
if shm, err = OpenSystemVSharedMemory(o.SharedMemoryKey); err != nil {
var shm *SharedMemory
if shm, err = OpenSharedMemory(o.SharedMemoryKey); err != nil {
err = fmt.Errorf("astikit: opening shared memory failed: %w", err)
return
}
@@ -416,8 +418,8 @@ func (r *SystemVSemaphoredSharedMemoryReader) ReadBytes(o *SystemVSemaphoredShar
r.closeSemaphore()
// Open semaphore
var sem *SystemVSemaphore
if sem, err = OpenSystemVSemaphore(o.SemaphoreKey); err != nil {
var sem *Semaphore
if sem, err = OpenSemaphore(o.SemaphoreKey); err != nil {
err = fmt.Errorf("astikit: opening semaphore failed: %w", err)
return
}

0
ipc_systemv.h → ipc/systemv/systemv.h
View File

36
ipc_systemv_test.go → ipc/systemv/systemv_test.go
View File

@@ -1,25 +1,25 @@
//go:build !windows
package astikit
package astisystemv
import (
"bytes"
"testing"
)
func TestNewSystemVKey(t *testing.T) {
_, err := NewSystemVKey(1, "testdata/ipc/invalid")
func TestNewKey(t *testing.T) {
_, err := NewKey(1, "../../testdata/ipc/invalid")
if err == nil {
t.Fatal("expected an error, got none")
}
if _, err = NewSystemVKey(1, "testdata/ipc/f"); err != nil {
if _, err = NewKey(1, "../../testdata/ipc/f"); err != nil {
t.Fatalf("expected no error, got %s", err)
}
}
func TestSystemVSemaphore(t *testing.T) {
func TestSemaphore(t *testing.T) {
const key = 1
s1, err := CreateSystemVSemaphore(key, IpcCreate|IpcExclusive|0666)
s1, err := CreateSemaphore(key, IpcCreate|IpcExclusive|0666)
if err != nil {
t.Fatalf("expected no error, got %s", err)
}
@@ -33,7 +33,7 @@ func TestSystemVSemaphore(t *testing.T) {
if err = s1.Unlock(); err != nil {
t.Fatalf("expected no error, got %s", err)
}
s2, err := OpenSystemVSemaphore(key)
s2, err := OpenSemaphore(key)
if err != nil {
t.Fatalf("expected no error, got %s", err)
}
@@ -70,9 +70,9 @@ func TestSystemVSemaphore(t *testing.T) {
}
}
func TestSystemVSharedMemory(t *testing.T) {
func TestSharedMemory(t *testing.T) {
const key = 1
sm1, err := CreateSystemVSharedMemory(key, 10, IpcCreate|IpcExclusive|0666)
sm1, err := CreateSharedMemory(key, 10, IpcCreate|IpcExclusive|0666)
if err != nil {
t.Fatalf("expected no error, got %s", err)
}
@@ -87,7 +87,7 @@ func TestSystemVSharedMemory(t *testing.T) {
if err := sm1.WriteBytes(b1); err != nil {
t.Fatalf("expected no error, got %s", err)
}
sm2, err := OpenSystemVSharedMemory(key)
sm2, err := OpenSharedMemory(key)
if err != nil {
t.Fatalf("expected no error, got %s", err)
}
@@ -110,23 +110,23 @@ func TestSystemVSharedMemory(t *testing.T) {
}
}
func TestSystemVSemaphoredSharedMemory(t *testing.T) {
w1 := NewSystemVSemaphoredSharedMemoryWriter()
func TestSemaphoredSharedMemory(t *testing.T) {
w1 := NewSemaphoredSharedMemoryWriter()
defer w1.Close()
w2 := NewSystemVSemaphoredSharedMemoryWriter()
w2 := NewSemaphoredSharedMemoryWriter()
defer w2.Close()
r1 := NewSystemVSemaphoredSharedMemoryReader()
r1 := NewSemaphoredSharedMemoryReader()
defer r1.Close()
r2 := NewSystemVSemaphoredSharedMemoryReader()
r2 := NewSemaphoredSharedMemoryReader()
defer r2.Close()
b1 := []byte("test")
semKeys := make(map[int]bool)
shmAts := make(map[*SystemVSemaphoredSharedMemoryWriter]int64)
shmAts := make(map[*SemaphoredSharedMemoryWriter]int64)
shmKeys := make(map[int]bool)
for _, v := range []struct {
r *SystemVSemaphoredSharedMemoryReader
w *SystemVSemaphoredSharedMemoryWriter
r *SemaphoredSharedMemoryReader
w *SemaphoredSharedMemoryWriter
}{
{
r: r1,

6
rand.go
View File

@@ -13,7 +13,7 @@ const (
randLetterIdxMax = 63 / randLetterIdxBits // # of letter indices fitting in 63 bits
)
var randSrc = rand.NewSource(time.Now().UnixNano())
var RandSource = rand.NewSource(time.Now().UnixNano())
// RandStr generates a random string of length n
// https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-golang
@@ -21,9 +21,9 @@ func RandStr(n int) string {
sb := strings.Builder{}
sb.Grow(n)
// A randSrc.Int63() generates 63 random bits, enough for randLetterIdxMax characters!
for i, cache, remain := n-1, randSrc.Int63(), randLetterIdxMax; i >= 0; {
for i, cache, remain := n-1, RandSource.Int63(), randLetterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = randSrc.Int63(), randLetterIdxMax
cache, remain = RandSource.Int63(), randLetterIdxMax
}
if idx := int(cache & randLetterIdxMask); idx < len(randLetterBytes) {
sb.WriteByte(randLetterBytes[idx])