Remove vsm.Pointer().

The VSM handle is exported as a field in struct VSM, for internal
use only.

internal/pkg/vsm/e2e_test.go

@@ -140,20 +140,12 @@ func TestAttachInstance(t *testing.T) {
 func TestPointer(t *testing.T) {
 	v := New()
 	defer v.Destroy()
-	p, err := v.Pointer()
-	if err != nil {
-		t.Error("Pointer():", err)
-	}
-	if p == nil {
-		t.Error("Pointer() returned nil")
+	if v.VSM == nil {
+		t.Error("VSM handle is nil")
 	}
 
-	var n *VSM
-	if _, err := n.Pointer(); err == nil {
-		t.Error("expected nil.Pointer() to fail")
-	}
 	uninit := new(VSM)
-	if _, err := uninit.Pointer(); err == nil {
-		t.Error("expected uninitialized.Pointer() to fail")
+	if uninit.VSM != nil {
+		t.Error("expected uninitialized.VSM == nil")
 	}
 }

internal/pkg/vsm/vsm.go

@@ -41,12 +41,13 @@ import (
 	"errors"
 	"strconv"
 	"time"
-	"unsafe"
 )
 
 // VSM provides methods for attaching to Varnish shared memory.
 type VSM struct {
-	vsm *C.struct_vsm
+	// VSM is an native handle for use by other packages.  Client
+	// code should never use it.
+	VSM *C.struct_vsm
 }
 
 // New returns a new and initialied instance of VSM. Instances should
@@ -68,7 +69,7 @@ func (v *VSM) checkNil() error {
 	if v == nil {
 		return errors.New("VSM object is nil")
 	}
-	if v.vsm == nil {
+	if v.VSM == nil {
 		return errors.New("VSM object was uninitialized via New()")
 	}
 	return nil
@@ -81,7 +82,7 @@ func (v *VSM) Destroy() error {
 	if err := v.checkNil(); err != nil {
 		return err
 	}
-	C.VSM_Destroy(&v.vsm)
+	C.VSM_Destroy(&v.VSM)
 	return nil
 }
 
@@ -91,7 +92,7 @@ func (v *VSM) Error() string {
 	if err := v.checkNil(); err != nil {
 		return err.Error()
 	}
-	return C.GoString(C.VSM_Error(v.vsm))
+	return C.GoString(C.VSM_Error(v.VSM))
 }
 
 // AttachTmo sets the timeout for attaching to a Varnish instance. If
@@ -108,8 +109,8 @@ func (v *VSM) AttachTmo(tmo time.Duration) error {
 	if secs >= 0 {
 		arg = strconv.FormatUint(uint64(secs), 10)
 	}
-	C.VSM_ResetError(v.vsm)
-	if C.VSM_Arg(v.vsm, 't', C.CString(arg)) != 1 {
+	C.VSM_ResetError(v.VSM)
+	if C.VSM_Arg(v.VSM, 't', C.CString(arg)) != 1 {
 		return v
 	}
 	return nil
@@ -126,31 +127,22 @@ func (v *VSM) Attach(name string) error {
 		return err
 	}
 	if name != "" {
-		C.VSM_ResetError(v.vsm)
-		if C.VSM_Arg(v.vsm, 'n', C.CString(name)) != 1 {
+		C.VSM_ResetError(v.VSM)
+		if C.VSM_Arg(v.VSM, 'n', C.CString(name)) != 1 {
 			return v
 		}
 	}
-	C.VSM_ResetError(v.vsm)
-	if C.VSM_Attach(v.vsm, C.int(-1)) != 0 {
+	C.VSM_ResetError(v.VSM)
+	if C.VSM_Attach(v.VSM, C.int(-1)) != 0 {
 		return v
 	}
 	return nil
 }
 
-// Pointer returns an internal pointer for use by other packages.
-// Client code should never use it.
-func (v *VSM) Pointer() (unsafe.Pointer, error) {
-	if err := v.checkNil(); err != nil {
-		return nil, err
-	}
-	return unsafe.Pointer(v.vsm), nil
-}
-
 /*
 func (v *VSM) Get(class string, ident string) (string, error) {
 	var vf C.struct_vsm_fantom
-	if C.VSM_Get(v.vsm, &vf, C.CString(class), C.CString(ident)) == 0 {
+	if C.VSM_Get(v.VSM, &vf, C.CString(class), C.CString(ident)) == 0 {
 		return "", v
 	}
 	return C.GoStringN(vf.b, vf.e - vf.b), nil

pkg/log/log.go

@@ -456,20 +456,6 @@ func (log *Log) AttachTmo(tmo time.Duration) error {
 	return log.vsm.AttachTmo(tmo)
 }
 
-func (log *Log) setCursor() error {
-	p, err := log.vsm.Pointer()
-	if err != nil {
-		return err
-	}
-	vsmp := (*C.struct_vsm)(p)
-	C.VSL_ResetError(log.vsl)
-	log.cursor = C.VSL_CursorVSM(log.vsl, vsmp, log.vsmopts)
-	if log.cursor == nil {
-		return log
-	}
-	return nil
-}
-
 // Attach to an instance of Varnish -- varnishd with a running worker
 // process.
 //
@@ -483,8 +469,14 @@ func (log *Log) Attach(name string) error {
 	if err := log.vsm.Attach(name); err != nil {
 		return err
 	}
-	if err := log.setCursor(); err != nil {
-		return nil
+	if log.vsm.VSM == nil {
+		panic("VSM handle is nil")
+	}
+	C.VSL_ResetError(log.vsl)
+	log.cursor = C.VSL_CursorVSM(log.vsl, (*C.struct_vsm)(log.vsm.VSM),
+		log.vsmopts)
+	if log.cursor == nil {
+		return log
 	}
 	return nil
 }

pkg/stats/e2e_test.go

@@ -108,6 +108,7 @@ func TestAttach(t *testing.T) {
 	defer s.Release()
 	if err := s.Attach(""); err != nil {
 		t.Fatal("Attach(default):", err)
+		return
 	}
 
 	var n *Stats

pkg/stats/stats.go

@@ -410,9 +410,8 @@ func (stats *Stats) Attach(name string) error {
 	if err := stats.vsm.Attach(name); err != nil {
 		return err
 	}
-	p, err := stats.vsm.Pointer()
-	if err != nil {
-		return err
+	if stats.vsm.VSM == nil {
+		panic("VSM handle is nil")
 	}
 
 	data := new(statsData)
@@ -427,7 +426,8 @@ func (stats *Stats) Attach(name string) error {
 	dataMap.Store(key, data)
 	// Don't need the read lock here, because this is only called
 	// for Attach.
-	C.descriptions(stats.vsc, (*C.struct_vsm)(p), unsafe.Pointer(key))
+	C.descriptions(stats.vsc, (*C.struct_vsm)(stats.vsm.VSM),
+		unsafe.Pointer(key))
 
 	stats.names = data.names
 	stats.d9ns = data.d9ns
@@ -496,11 +496,10 @@ func (stats *Stats) Release() {
 		C.free(unsafe.Pointer(stats.vsc))
 		return
 	}
-	p, err := stats.vsm.Pointer()
-	if err != nil {
-		panic(err)
+	if stats.vsm.VSM == nil {
+		panic("VSM handle is nil")
 	}
-	C.VSC_Destroy(&stats.vsc, (*C.struct_vsm)(p))
+	C.VSC_Destroy(&stats.vsc, (*C.struct_vsm)(stats.vsm.VSM))
 	// ignoring nil check errors
 	stats.vsm.Destroy()
 }
@@ -583,13 +582,12 @@ func (stats *Stats) Read(rdHndlr ReadHandler) error {
 	if stats.vsm == nil {
 		return errors.New("not attached to a Varnish instance")
 	}
+	if stats.vsm.VSM == nil {
+		panic("VSM handle is nil")
+	}
 	if rdHndlr == nil {
 		return errors.New("callback is nil")
 	}
-	p, err := stats.vsm.Pointer()
-	if err != nil {
-		return err
-	}
 
 	key, err := mkKey()
 	if err != nil {
@@ -598,7 +596,7 @@ func (stats *Stats) Read(rdHndlr ReadHandler) error {
 	cbMap.Store(key, rdHndlr)
 
 	stats.rdLock.Lock()
-	C.stats(stats.vsc, (*C.struct_vsm)(p), unsafe.Pointer(key))
+	C.stats(stats.vsc, (*C.struct_vsm)(stats.vsm.VSM), unsafe.Pointer(key))
 	stats.rdLock.Unlock()
 
 	cbMap.Delete(key)