kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Merge pull request #16096 from vdemeester/14756-final-golints

Browse source 
Final bits of enabling golint on the code base 🐹
This commit is contained in:
Jess Frazelle 2015-09-08 15:25:55 -07:00
commit 634a848b8e
15 changed files with 271 additions and 307 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
daemon/graphdriver/devmapper/deviceset.go
View file

@ -266,7 +266,7 @@ func (devices *DeviceSet) allocateTransactionID() uint64 {
}
func (devices *DeviceSet) updatePoolTransactionID() error {
if err := devicemapper.SetTransactionId(devices.getPoolDevName(), devices.TransactionID, devices.OpenTransactionID); err != nil {
if err := devicemapper.SetTransactionID(devices.getPoolDevName(), devices.TransactionID, devices.OpenTransactionID); err != nil {
return fmt.Errorf("Error setting devmapper transaction ID: %s", err)
}
devices.TransactionID = devices.OpenTransactionID
@ -596,7 +596,7 @@ func (devices *DeviceSet) createRegisterDevice(hash string) (*devInfo, error) {
for {
if err := devicemapper.CreateDevice(devices.getPoolDevName(), deviceID); err != nil {
if devicemapper.DeviceIdExists(err) {
if devicemapper.DeviceIDExists(err) {
// Device ID already exists. This should not
// happen. Now we have a mechianism to find
// a free device ID. So something is not right.
@ -648,7 +648,7 @@ func (devices *DeviceSet) createRegisterSnapDevice(hash string, baseInfo *devInf
for {
if err := devicemapper.CreateSnapDevice(devices.getPoolDevName(), deviceID, baseInfo.Name(), baseInfo.DeviceID); err != nil {
if devicemapper.DeviceIdExists(err) {
if devicemapper.DeviceIDExists(err) {
// Device ID already exists. This should not
// happen. Now we have a mechianism to find
// a free device ID. So something is not right.

109
hack/make/validate-lint
View file

@ -2,116 +2,15 @@
source "${MAKEDIR}/.validate"
# We will eventually get to the point when packages should be the complete list
# of subpackages, vendoring excluded, as given by:
#
# packages=( $(go list ./... 2> /dev/null | grep -vE "^github.com/docker/docker/vendor" || true ) )
packages=(
api
api/client
api/client/ps
api/server
api/types
builder
builder/command
builder/parser
builder/parser/dumper
cliconfig
daemon
daemon/events
daemon/execdriver
daemon/execdriver/execdrivers
daemon/execdriver/lxc
daemon/execdriver/native
daemon/execdriver/native/template
daemon/execdriver/windows
daemon/graphdriver
daemon/graphdriver/aufs
daemon/graphdriver/devmapper
daemon/graphdriver/overlay
daemon/graphdriver/vfs
daemon/graphdriver/zfs
daemon/logger
daemon/logger/fluentd
daemon/logger/gelf
daemon/logger/journald
daemon/logger/jsonfilelog
daemon/logger/syslog
daemon/network
docker
dockerinit
graph
graph/tags
image
integration-cli
opts
pkg/archive
pkg/broadcastwriter
pkg/chrootarchive
pkg/directory
pkg/fileutils
pkg/graphdb
pkg/homedir
pkg/httputils
pkg/ioutils
pkg/jsonlog
pkg/jsonmessage
pkg/listenbuffer
pkg/mflag
pkg/mflag/example
pkg/mount
pkg/namesgenerator
pkg/nat
pkg/parsers
pkg/parsers/filters
pkg/parsers/kernel
pkg/parsers/operatingsystem
pkg/pidfile
pkg/plugins
pkg/pools
pkg/progressreader
pkg/promise
pkg/proxy
pkg/pubsub
pkg/random
pkg/reexec
pkg/signal
pkg/sockets
pkg/stdcopy
pkg/streamformatter
pkg/stringid
pkg/stringutils
pkg/symlink
pkg/sysinfo
pkg/system
pkg/tailfile
pkg/tarsum
pkg/term
pkg/term/windows
pkg/timeoutconn
pkg/timeutils
pkg/tlsconfig
pkg/truncindex
pkg/urlutil
pkg/ulimit
pkg/units
pkg/useragent
pkg/version
registry
runconfig
trust
utils
volume
volume/local
volume/drivers
)
packages=( $(go list ./... 2> /dev/null | grep -vE "^github.com/docker/docker/vendor|^github.com/docker/docker/autogen" || true ) )
errors=()
for p in "${packages[@]}"; do
# Remove the github.com/docker/docker/ prefix from listed package
package="${p#github.com/docker/docker/}"
# Run golint on package/*.go file explicitly to validate all go files
# and not just the ones for the current platform.
failedLint=$(golint "$p"/*.go)
failedLint=$(golint $package/*.go)
if [ "$failedLint" ]; then
errors+=( "$failedLint" )
fi

2
integration-cli/checker/checker.go
View file

@ -1,4 +1,4 @@
// Checker provide Docker specific implementations of the go-check.Checker interface.
// Package checker provide Docker specific implementations of the go-check.Checker interface.
package checker
import (

2
pkg/archive/archive_windows.go
View file

@ -25,7 +25,7 @@ func getWalkRoot(srcPath string, include string) string {
return filepath.Join(srcPath, include)
}
// canonicalTarNameForPath returns platform-specific filepath
// CanonicalTarNameForPath returns platform-specific filepath
// to canonical posix-style path for tar archival. p is relative
// path.
func CanonicalTarNameForPath(p string) (string, error) {

4
pkg/devicemapper/attach_loopback.go
View file

@ -82,7 +82,7 @@ func openNextAvailableLoopback(index int, sparseFile *os.File) (loopFile *os.Fil
return loopFile, nil
}
// attachLoopDevice attaches the given sparse file to the next
// AttachLoopDevice attaches the given sparse file to the next
// available loopback device. It returns an opened *os.File.
func AttachLoopDevice(sparseName string) (loop *os.File, err error) {
@ -108,7 +108,7 @@ func AttachLoopDevice(sparseName string) (loop *os.File, err error) {
}
// Set the status of the loopback device
loopInfo := &LoopInfo64{
loopInfo := &loopInfo64{
loFileName: stringToLoopName(loopFile.Name()),
loOffset: 0,
loFlags: LoFlagsAutoClear,

327
pkg/devicemapper/devmapper.go
View file

@ -13,37 +13,39 @@ import (
"github.com/Sirupsen/logrus"
)
// DevmapperLogger defines methods for logging with devicemapper.
type DevmapperLogger interface {
DMLog(level int, file string, line int, dmError int, message string)
}
const (
DeviceCreate TaskType = iota
DeviceReload
DeviceRemove
DeviceRemoveAll
DeviceSuspend
DeviceResume
DeviceInfo
DeviceDeps
DeviceRename
DeviceVersion
DeviceStatus
DeviceTable
DeviceWaitevent
DeviceList
DeviceClear
DeviceMknodes
DeviceListVersions
DeviceTargetMsg
DeviceSetGeometry
deviceCreate TaskType = iota
deviceReload
deviceRemove
deviceRemoveAll
deviceSuspend
deviceResume
deviceInfo
deviceDeps
deviceRename
deviceVersion
deviceStatus
deviceTable
deviceWaitevent
deviceList
deviceClear
deviceMknodes
deviceListVersions
deviceTargetMsg
deviceSetGeometry
)
const (
AddNodeOnResume AddNodeType = iota
AddNodeOnCreate
addNodeOnResume AddNodeType = iota
addNodeOnCreate
)
// List of errors returned when using devicemapper.
var (
ErrTaskRun = errors.New("dm_task_run failed")
ErrTaskSetName = errors.New("dm_task_set_name failed")
@ -63,29 +65,35 @@ var (
ErrUdevWait = errors.New("wait on udev cookie failed")
ErrSetDevDir = errors.New("dm_set_dev_dir failed")
ErrGetLibraryVersion = errors.New("dm_get_library_version failed")
ErrCreateRemoveTask = errors.New("Can't create task of type DeviceRemove")
ErrCreateRemoveTask = errors.New("Can't create task of type deviceRemove")
ErrRunRemoveDevice = errors.New("running RemoveDevice failed")
ErrInvalidAddNode = errors.New("Invalid AddNode type")
ErrGetLoopbackBackingFile = errors.New("Unable to get loopback backing file")
ErrLoopbackSetCapacity = errors.New("Unable set loopback capacity")
ErrBusy = errors.New("Device is Busy")
ErrDeviceIdExists = errors.New("Device Id Exists")
ErrDeviceIDExists = errors.New("Device Id Exists")
ErrEnxio = errors.New("No such device or address")
)
var (
dmSawBusy bool
dmSawExist bool
dmSawEnxio bool // No Such Device or Address
)
type (
// Task represents a devicemapper task (like lvcreate, etc.) ; a task is needed for each ioctl
// command to execute.
Task struct {
unmanaged *CDmTask
unmanaged *cdmTask
}
// Deps represents dependents (layer) of a device.
Deps struct {
Count uint32
Filler uint32
Device []uint64
}
// Info represents information about a device.
Info struct {
Exists int
Suspended int
@ -99,18 +107,20 @@ type (
TargetCount int32
DeferredRemove int
}
// TaskType represents a type of task
TaskType int
// AddNodeType represents a type of node to be added (?)
AddNodeType int
)
// Returns whether error conveys the information about device Id already
// DeviceIDExists returns whether error conveys the information about device Id already
// exist or not. This will be true if device creation or snap creation
// operation fails if device or snap device already exists in pool.
// Current implementation is little crude as it scans the error string
// for exact pattern match. Replacing it with more robust implementation
// is desirable.
func DeviceIdExists(err error) bool {
return fmt.Sprint(err) == fmt.Sprint(ErrDeviceIdExists)
func DeviceIDExists(err error) bool {
return fmt.Sprint(err) == fmt.Sprint(ErrDeviceIDExists)
}
func (t *Task) destroy() {
@ -127,7 +137,7 @@ func TaskCreateNamed(t TaskType, name string) (*Task, error) {
if task == nil {
return nil, fmt.Errorf("Can't create task of type %d", int(t))
}
if err := task.SetName(name); err != nil {
if err := task.setName(name); err != nil {
return nil, fmt.Errorf("Can't set task name %s", name)
}
return task, nil
@ -144,35 +154,35 @@ func TaskCreate(tasktype TaskType) *Task {
return task
}
func (t *Task) Run() error {
func (t *Task) run() error {
if res := DmTaskRun(t.unmanaged); res != 1 {
return ErrTaskRun
}
return nil
}
func (t *Task) SetName(name string) error {
func (t *Task) setName(name string) error {
if res := DmTaskSetName(t.unmanaged, name); res != 1 {
return ErrTaskSetName
}
return nil
}
func (t *Task) SetMessage(message string) error {
func (t *Task) setMessage(message string) error {
if res := DmTaskSetMessage(t.unmanaged, message); res != 1 {
return ErrTaskSetMessage
}
return nil
}
func (t *Task) SetSector(sector uint64) error {
func (t *Task) setSector(sector uint64) error {
if res := DmTaskSetSector(t.unmanaged, sector); res != 1 {
return ErrTaskSetSector
}
return nil
}
func (t *Task) SetCookie(cookie *uint, flags uint16) error {
func (t *Task) setCookie(cookie *uint, flags uint16) error {
if cookie == nil {
return ErrNilCookie
}
@ -182,8 +192,8 @@ func (t *Task) SetCookie(cookie *uint, flags uint16) error {
return nil
}
func (t *Task) SetAddNode(addNode AddNodeType) error {
if addNode != AddNodeOnResume && addNode != AddNodeOnCreate {
func (t *Task) setAddNode(addNode AddNodeType) error {
if addNode != addNodeOnResume && addNode != addNodeOnCreate {
return ErrInvalidAddNode
}
if res := DmTaskSetAddNode(t.unmanaged, addNode); res != 1 {
@ -192,14 +202,14 @@ func (t *Task) SetAddNode(addNode AddNodeType) error {
return nil
}
func (t *Task) SetRo() error {
func (t *Task) setRo() error {
if res := DmTaskSetRo(t.unmanaged); res != 1 {
return ErrTaskSetRo
}
return nil
}
func (t *Task) AddTarget(start, size uint64, ttype, params string) error {
func (t *Task) addTarget(start, size uint64, ttype, params string) error {
if res := DmTaskAddTarget(t.unmanaged, start, size,
ttype, params); res != 1 {
return ErrTaskAddTarget
@ -207,7 +217,7 @@ func (t *Task) AddTarget(start, size uint64, ttype, params string) error {
return nil
}
func (t *Task) GetDeps() (*Deps, error) {
func (t *Task) getDeps() (*Deps, error) {
var deps *Deps
if deps = DmTaskGetDeps(t.unmanaged); deps == nil {
return nil, ErrTaskGetDeps
@ -215,7 +225,7 @@ func (t *Task) GetDeps() (*Deps, error) {
return deps, nil
}
func (t *Task) GetInfo() (*Info, error) {
func (t *Task) getInfo() (*Info, error) {
info := &Info{}
if res := DmTaskGetInfo(t.unmanaged, info); res != 1 {
return nil, ErrTaskGetInfo
@ -223,7 +233,7 @@ func (t *Task) GetInfo() (*Info, error) {
return info, nil
}
func (t *Task) GetInfoWithDeferred() (*Info, error) {
func (t *Task) getInfoWithDeferred() (*Info, error) {
info := &Info{}
if res := DmTaskGetInfoWithDeferred(t.unmanaged, info); res != 1 {
return nil, ErrTaskGetInfo
@ -231,7 +241,7 @@ func (t *Task) GetInfoWithDeferred() (*Info, error) {
return info, nil
}
func (t *Task) GetDriverVersion() (string, error) {
func (t *Task) getDriverVersion() (string, error) {
res := DmTaskGetDriverVersion(t.unmanaged)
if res == "" {
return "", ErrTaskGetDriverVersion
@ -239,7 +249,7 @@ func (t *Task) GetDriverVersion() (string, error) {
return res, nil
}
func (t *Task) GetNextTarget(next unsafe.Pointer) (nextPtr unsafe.Pointer, start uint64,
func (t *Task) getNextTarget(next unsafe.Pointer) (nextPtr unsafe.Pointer, start uint64,
length uint64, targetType string, params string) {
return DmGetNextTarget(t.unmanaged, next, &start, &length,
@ -256,6 +266,7 @@ func getLoopbackBackingFile(file *os.File) (uint64, uint64, error) {
return loopInfo.loDevice, loopInfo.loInode, nil
}
// LoopbackSetCapacity reloads the size for the loopback device.
func LoopbackSetCapacity(file *os.File) error {
if err := ioctlLoopSetCapacity(file.Fd(), 0); err != nil {
logrus.Errorf("Error loopbackSetCapacity: %s", err)
@ -264,6 +275,8 @@ func LoopbackSetCapacity(file *os.File) error {
return nil
}
// FindLoopDeviceFor returns a loopback device file for the specified file which
// is backing file of a loop back device.
func FindLoopDeviceFor(file *os.File) *os.File {
stat, err := file.Stat()
if err != nil {
@ -296,6 +309,7 @@ func FindLoopDeviceFor(file *os.File) *os.File {
return nil
}
// UdevWait wakes any processes that are waiting for udev to complete the specified cookie. (?)
func UdevWait(cookie *uint) error {
if res := DmUdevWait(*cookie); res != 1 {
logrus.Debugf("Failed to wait on udev cookie %d", *cookie)
@ -304,18 +318,20 @@ func UdevWait(cookie *uint) error {
return nil
}
// LogInitVerbose is an interface to initialize the verbose logger for the device mapper library. (?)
func LogInitVerbose(level int) {
DmLogInitVerbose(level)
}
var dmLogger DevmapperLogger = nil
var dmLogger DevmapperLogger
// initialize the logger for the device mapper library
// LogInit initializes the logger for the device mapper library.
func LogInit(logger DevmapperLogger) {
dmLogger = logger
LogWithErrnoInit()
}
// SetDevDir sets the dev folder for the device mapper library (usually /dev).
func SetDevDir(dir string) error {
if res := DmSetDevDir(dir); res != 1 {
logrus.Debugf("Error dm_set_dev_dir")
@ -324,6 +340,7 @@ func SetDevDir(dir string) error {
return nil
}
// GetLibraryVersion returns the device mapper library version.
func GetLibraryVersion() (string, error) {
var version string
if res := DmGetLibraryVersion(&version); res != 1 {
@ -359,21 +376,21 @@ func CookieSupported() bool {
return DmCookieSupported() != 0
}
// Useful helper for cleanup
// RemoveDevice is a useful helper for cleaning up a device.
func RemoveDevice(name string) error {
task, err := TaskCreateNamed(DeviceRemove, name)
task, err := TaskCreateNamed(deviceRemove, name)
if task == nil {
return err
}
var cookie uint = 0
if err := task.SetCookie(&cookie, 0); err != nil {
var cookie uint
if err := task.setCookie(&cookie, 0); err != nil {
return fmt.Errorf("Can not set cookie: %s", err)
}
defer UdevWait(&cookie)
dmSawBusy = false // reset before the task is run
if err = task.Run(); err != nil {
if err = task.run(); err != nil {
if dmSawBusy {
return ErrBusy
}
@ -383,10 +400,11 @@ func RemoveDevice(name string) error {
return nil
}
// RemoveDeviceDeferred is a useful helper for cleaning up a device, but deferred.
func RemoveDeviceDeferred(name string) error {
logrus.Debugf("[devmapper] RemoveDeviceDeferred START(%s)", name)
defer logrus.Debugf("[devmapper] RemoveDeviceDeferred END(%s)", name)
task, err := TaskCreateNamed(DeviceRemove, name)
task, err := TaskCreateNamed(deviceRemove, name)
if task == nil {
return err
}
@ -395,31 +413,31 @@ func RemoveDeviceDeferred(name string) error {
return ErrTaskDeferredRemove
}
if err = task.Run(); err != nil {
if err = task.run(); err != nil {
return fmt.Errorf("Error running RemoveDeviceDeferred %s", err)
}
return nil
}
// Useful helper for cleanup
// CancelDeferredRemove cancels a deferred remove for a device.
func CancelDeferredRemove(deviceName string) error {
task, err := TaskCreateNamed(DeviceTargetMsg, deviceName)
task, err := TaskCreateNamed(deviceTargetMsg, deviceName)
if task == nil {
return err
}
if err := task.SetSector(0); err != nil {
if err := task.setSector(0); err != nil {
return fmt.Errorf("Can't set sector %s", err)
}
if err := task.SetMessage(fmt.Sprintf("@cancel_deferred_remove")); err != nil {
if err := task.setMessage(fmt.Sprintf("@cancel_deferred_remove")); err != nil {
return fmt.Errorf("Can't set message %s", err)
}
dmSawBusy = false
dmSawEnxio = false
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
// A device might be being deleted already
if dmSawBusy {
return ErrBusy
@ -432,6 +450,7 @@ func CancelDeferredRemove(deviceName string) error {
return nil
}
// GetBlockDeviceSize returns the size of a block device identified by the specified file.
func GetBlockDeviceSize(file *os.File) (uint64, error) {
size, err := ioctlBlkGetSize64(file.Fd())
if err != nil {
@ -441,6 +460,10 @@ func GetBlockDeviceSize(file *os.File) (uint64, error) {
return uint64(size), nil
}
// BlockDeviceDiscard runs discard for the given path.
// This is used as a workaround for the kernel not discarding block so
// on the thin pool when we remove a thinp device, so we do it
// manually
func BlockDeviceDiscard(path string) error {
file, err := os.OpenFile(path, os.O_RDWR, 0)
if err != nil {
@ -464,9 +487,10 @@ func BlockDeviceDiscard(path string) error {
return nil
}
// This is the programmatic example of "dmsetup create"
// CreatePool is the programmatic example of "dmsetup create".
// It creates a device with the specified poolName, data and metadata file and block size.
func CreatePool(poolName string, dataFile, metadataFile *os.File, poolBlockSize uint32) error {
task, err := TaskCreateNamed(DeviceCreate, poolName)
task, err := TaskCreateNamed(deviceCreate, poolName)
if task == nil {
return err
}
@ -477,26 +501,29 @@ func CreatePool(poolName string, dataFile, metadataFile *os.File, poolBlockSize
}
params := fmt.Sprintf("%s %s %d 32768 1 skip_block_zeroing", metadataFile.Name(), dataFile.Name(), poolBlockSize)
if err := task.AddTarget(0, size/512, "thin-pool", params); err != nil {
if err := task.addTarget(0, size/512, "thin-pool", params); err != nil {
return fmt.Errorf("Can't add target %s", err)
}
var cookie uint = 0
var flags uint16 = DmUdevDisableSubsystemRulesFlag | DmUdevDisableDiskRulesFlag | DmUdevDisableOtherRulesFlag
if err := task.SetCookie(&cookie, flags); err != nil {
var cookie uint
var flags uint16
flags = DmUdevDisableSubsystemRulesFlag | DmUdevDisableDiskRulesFlag | DmUdevDisableOtherRulesFlag
if err := task.setCookie(&cookie, flags); err != nil {
return fmt.Errorf("Can't set cookie %s", err)
}
defer UdevWait(&cookie)
if err := task.Run(); err != nil {
return fmt.Errorf("Error running DeviceCreate (CreatePool) %s", err)
if err := task.run(); err != nil {
return fmt.Errorf("Error running deviceCreate (CreatePool) %s", err)
}
return nil
}
// ReloadPool is the programmatic example of "dmsetup reload".
// It reloads the table with the specified poolName, data and metadata file and block size.
func ReloadPool(poolName string, dataFile, metadataFile *os.File, poolBlockSize uint32) error {
task, err := TaskCreateNamed(DeviceReload, poolName)
task, err := TaskCreateNamed(deviceReload, poolName)
if task == nil {
return err
}
@ -507,73 +534,83 @@ func ReloadPool(poolName string, dataFile, metadataFile *os.File, poolBlockSize
}
params := fmt.Sprintf("%s %s %d 32768 1 skip_block_zeroing", metadataFile.Name(), dataFile.Name(), poolBlockSize)
if err := task.AddTarget(0, size/512, "thin-pool", params); err != nil {
if err := task.addTarget(0, size/512, "thin-pool", params); err != nil {
return fmt.Errorf("Can't add target %s", err)
}
if err := task.Run(); err != nil {
return fmt.Errorf("Error running DeviceCreate %s", err)
if err := task.run(); err != nil {
return fmt.Errorf("Error running deviceCreate %s", err)
}
return nil
}
// GetDeps is the programmatic example of "dmsetup deps".
// It outputs a list of devices referenced by the live table for the specified device.
func GetDeps(name string) (*Deps, error) {
task, err := TaskCreateNamed(DeviceDeps, name)
task, err := TaskCreateNamed(deviceDeps, name)
if task == nil {
return nil, err
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
return nil, err
}
return task.GetDeps()
return task.getDeps()
}
// GetInfo is the programmatic example of "dmsetup info".
// It outputs some brief information about the device.
func GetInfo(name string) (*Info, error) {
task, err := TaskCreateNamed(DeviceInfo, name)
task, err := TaskCreateNamed(deviceInfo, name)
if task == nil {
return nil, err
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
return nil, err
}
return task.GetInfo()
return task.getInfo()
}
// GetInfoWithDeferred is the programmatic example of "dmsetup info", but deferred.
// It outputs some brief information about the device.
func GetInfoWithDeferred(name string) (*Info, error) {
task, err := TaskCreateNamed(DeviceInfo, name)
task, err := TaskCreateNamed(deviceInfo, name)
if task == nil {
return nil, err
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
return nil, err
}
return task.GetInfoWithDeferred()
return task.getInfoWithDeferred()
}
// GetDriverVersion is the programmatic example of "dmsetup version".
// It outputs version information of the driver.
func GetDriverVersion() (string, error) {
task := TaskCreate(DeviceVersion)
task := TaskCreate(deviceVersion)
if task == nil {
return "", fmt.Errorf("Can't create DeviceVersion task")
return "", fmt.Errorf("Can't create deviceVersion task")
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
return "", err
}
return task.GetDriverVersion()
return task.getDriverVersion()
}
// GetStatus is the programmatic example of "dmsetup status".
// It outputs status information for the specified device name.
func GetStatus(name string) (uint64, uint64, string, string, error) {
task, err := TaskCreateNamed(DeviceStatus, name)
task, err := TaskCreateNamed(deviceStatus, name)
if task == nil {
logrus.Debugf("GetStatus: Error TaskCreateNamed: %s", err)
return 0, 0, "", "", err
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
logrus.Debugf("GetStatus: Error Run: %s", err)
return 0, 0, "", "", err
}
devinfo, err := task.GetInfo()
devinfo, err := task.getInfo()
if err != nil {
logrus.Debugf("GetStatus: Error GetInfo: %s", err)
return 0, 0, "", "", err
@ -583,22 +620,24 @@ func GetStatus(name string) (uint64, uint64, string, string, error) {
return 0, 0, "", "", fmt.Errorf("Non existing device %s", name)
}
_, start, length, targetType, params := task.GetNextTarget(unsafe.Pointer(nil))
_, start, length, targetType, params := task.getNextTarget(unsafe.Pointer(nil))
return start, length, targetType, params, nil
}
// GetTable is the programmatic example for "dmsetup table".
// It outputs the current table for the specified device name.
func GetTable(name string) (uint64, uint64, string, string, error) {
task, err := TaskCreateNamed(DeviceTable, name)
task, err := TaskCreateNamed(deviceTable, name)
if task == nil {
logrus.Debugf("GetTable: Error TaskCreateNamed: %s", err)
return 0, 0, "", "", err
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
logrus.Debugf("GetTable: Error Run: %s", err)
return 0, 0, "", "", err
}
devinfo, err := task.GetInfo()
devinfo, err := task.getInfo()
if err != nil {
logrus.Debugf("GetTable: Error GetInfo: %s", err)
return 0, 0, "", "", err
@ -608,80 +647,86 @@ func GetTable(name string) (uint64, uint64, string, string, error) {
return 0, 0, "", "", fmt.Errorf("Non existing device %s", name)
}
_, start, length, targetType, params := task.GetNextTarget(unsafe.Pointer(nil))
_, start, length, targetType, params := task.getNextTarget(unsafe.Pointer(nil))
return start, length, targetType, params, nil
}
func SetTransactionId(poolName string, oldId uint64, newId uint64) error {
task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
// SetTransactionID sets a transaction id for the specified device name.
func SetTransactionID(poolName string, oldID uint64, newID uint64) error {
task, err := TaskCreateNamed(deviceTargetMsg, poolName)
if task == nil {
return err
}
if err := task.SetSector(0); err != nil {
if err := task.setSector(0); err != nil {
return fmt.Errorf("Can't set sector %s", err)
}
if err := task.SetMessage(fmt.Sprintf("set_transaction_id %d %d", oldId, newId)); err != nil {
if err := task.setMessage(fmt.Sprintf("set_transaction_id %d %d", oldID, newID)); err != nil {
return fmt.Errorf("Can't set message %s", err)
}
if err := task.Run(); err != nil {
return fmt.Errorf("Error running SetTransactionId %s", err)
if err := task.run(); err != nil {
return fmt.Errorf("Error running SetTransactionID %s", err)
}
return nil
}
// SuspendDevice is the programmatic example of "dmsetup suspend".
// It suspends the specified device.
func SuspendDevice(name string) error {
task, err := TaskCreateNamed(DeviceSuspend, name)
task, err := TaskCreateNamed(deviceSuspend, name)
if task == nil {
return err
}
if err := task.Run(); err != nil {
return fmt.Errorf("Error running DeviceSuspend %s", err)
if err := task.run(); err != nil {
return fmt.Errorf("Error running deviceSuspend %s", err)
}
return nil
}
// ResumeDevice is the programmatic example of "dmsetup resume".
// It un-suspends the specified device.
func ResumeDevice(name string) error {
task, err := TaskCreateNamed(DeviceResume, name)
task, err := TaskCreateNamed(deviceResume, name)
if task == nil {
return err
}
var cookie uint = 0
if err := task.SetCookie(&cookie, 0); err != nil {
var cookie uint
if err := task.setCookie(&cookie, 0); err != nil {
return fmt.Errorf("Can't set cookie %s", err)
}
defer UdevWait(&cookie)
if err := task.Run(); err != nil {
return fmt.Errorf("Error running DeviceResume %s", err)
if err := task.run(); err != nil {
return fmt.Errorf("Error running deviceResume %s", err)
}
return nil
}
func CreateDevice(poolName string, deviceId int) error {
logrus.Debugf("[devmapper] CreateDevice(poolName=%v, deviceId=%v)", poolName, deviceId)
task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
// CreateDevice creates a device with the specified poolName with the specified device id. (?)
func CreateDevice(poolName string, deviceID int) error {
logrus.Debugf("[devmapper] CreateDevice(poolName=%v, deviceID=%v)", poolName, deviceID)
task, err := TaskCreateNamed(deviceTargetMsg, poolName)
if task == nil {
return err
}
if err := task.SetSector(0); err != nil {
if err := task.setSector(0); err != nil {
return fmt.Errorf("Can't set sector %s", err)
}
if err := task.SetMessage(fmt.Sprintf("create_thin %d", deviceId)); err != nil {
if err := task.setMessage(fmt.Sprintf("create_thin %d", deviceID)); err != nil {
return fmt.Errorf("Can't set message %s", err)
}
dmSawExist = false // reset before the task is run
if err := task.Run(); err != nil {
// Caller wants to know about ErrDeviceIdExists so that it can try with a different device id.
if err := task.run(); err != nil {
// Caller wants to know about ErrDeviceIDExists so that it can try with a different device id.
if dmSawExist {
return ErrDeviceIdExists
return ErrDeviceIDExists
}
return fmt.Errorf("Error running CreateDevice %s", err)
@ -690,68 +735,74 @@ func CreateDevice(poolName string, deviceId int) error {
return nil
}
func DeleteDevice(poolName string, deviceId int) error {
task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
// DeleteDevice deletes a device with the specified poolName with the specified device id. (?)
func DeleteDevice(poolName string, deviceID int) error {
task, err := TaskCreateNamed(deviceTargetMsg, poolName)
if task == nil {
return err
}
if err := task.SetSector(0); err != nil {
if err := task.setSector(0); err != nil {
return fmt.Errorf("Can't set sector %s", err)
}
if err := task.SetMessage(fmt.Sprintf("delete %d", deviceId)); err != nil {
if err := task.setMessage(fmt.Sprintf("delete %d", deviceID)); err != nil {
return fmt.Errorf("Can't set message %s", err)
}
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
return fmt.Errorf("Error running DeleteDevice %s", err)
}
return nil
}
func ActivateDevice(poolName string, name string, deviceId int, size uint64) error {
return activateDevice(poolName, name, deviceId, size, "")
// ActivateDevice activates the device identified by the specified
// poolName, name and deviceID with the specified size.
func ActivateDevice(poolName string, name string, deviceID int, size uint64) error {
return activateDevice(poolName, name, deviceID, size, "")
}
func ActivateDeviceWithExternal(poolName string, name string, deviceId int, size uint64, external string) error {
return activateDevice(poolName, name, deviceId, size, external)
// ActivateDeviceWithExternal activates the device identified by the specified
// poolName, name and deviceID with the specified size. (?)
func ActivateDeviceWithExternal(poolName string, name string, deviceID int, size uint64, external string) error {
return activateDevice(poolName, name, deviceID, size, external)
}
func activateDevice(poolName string, name string, deviceId int, size uint64, external string) error {
task, err := TaskCreateNamed(DeviceCreate, name)
func activateDevice(poolName string, name string, deviceID int, size uint64, external string) error {
task, err := TaskCreateNamed(deviceCreate, name)
if task == nil {
return err
}
var params string
if len(external) > 0 {
params = fmt.Sprintf("%s %d %s", poolName, deviceId, external)
params = fmt.Sprintf("%s %d %s", poolName, deviceID, external)
} else {
params = fmt.Sprintf("%s %d", poolName, deviceId)
params = fmt.Sprintf("%s %d", poolName, deviceID)
}
if err := task.AddTarget(0, size/512, "thin", params); err != nil {
if err := task.addTarget(0, size/512, "thin", params); err != nil {
return fmt.Errorf("Can't add target %s", err)
}
if err := task.SetAddNode(AddNodeOnCreate); err != nil {
if err := task.setAddNode(addNodeOnCreate); err != nil {
return fmt.Errorf("Can't add node %s", err)
}
var cookie uint = 0
if err := task.SetCookie(&cookie, 0); err != nil {
var cookie uint
if err := task.setCookie(&cookie, 0); err != nil {
return fmt.Errorf("Can't set cookie %s", err)
}
defer UdevWait(&cookie)
if err := task.Run(); err != nil {
return fmt.Errorf("Error running DeviceCreate (ActivateDevice) %s", err)
if err := task.run(); err != nil {
return fmt.Errorf("Error running deviceCreate (ActivateDevice) %s", err)
}
return nil
}
func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDeviceId int) error {
// CreateSnapDevice creates a snapshot based on the device identified by the baseName and baseDeviceId,
func CreateSnapDevice(poolName string, deviceID int, baseName string, baseDeviceID int) error {
devinfo, _ := GetInfo(baseName)
doSuspend := devinfo != nil && devinfo.Exists != 0
@ -761,7 +812,7 @@ func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDevice
}
}
task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
task, err := TaskCreateNamed(deviceTargetMsg, poolName)
if task == nil {
if doSuspend {
ResumeDevice(baseName)
@ -769,14 +820,14 @@ func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDevice
return err
}
if err := task.SetSector(0); err != nil {
if err := task.setSector(0); err != nil {
if doSuspend {
ResumeDevice(baseName)
}
return fmt.Errorf("Can't set sector %s", err)
}
if err := task.SetMessage(fmt.Sprintf("create_snap %d %d", deviceId, baseDeviceId)); err != nil {
if err := task.setMessage(fmt.Sprintf("create_snap %d %d", deviceID, baseDeviceID)); err != nil {
if doSuspend {
ResumeDevice(baseName)
}
@ -784,16 +835,16 @@ func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDevice
}
dmSawExist = false // reset before the task is run
if err := task.Run(); err != nil {
if err := task.run(); err != nil {
if doSuspend {
ResumeDevice(baseName)
}
// Caller wants to know about ErrDeviceIdExists so that it can try with a different device id.
// Caller wants to know about ErrDeviceIDExists so that it can try with a different device id.
if dmSawExist {
return ErrDeviceIdExists
return ErrDeviceIDExists
}
return fmt.Errorf("Error running DeviceCreate (createSnapDevice) %s", err)
return fmt.Errorf("Error running deviceCreate (createSnapDevice) %s", err)
}

5
pkg/devicemapper/devmapper_log.go
View file

@ -11,8 +11,9 @@ import (
// Due to the way cgo works this has to be in a separate file, as devmapper.go has
// definitions in the cgo block, which is incompatible with using "//export"
// DevmapperLogCallback exports the devmapper log callback for cgo. (?)
//export DevmapperLogCallback
func DevmapperLogCallback(level C.int, file *C.char, line C.int, dm_errno_or_class C.int, message *C.char) {
func DevmapperLogCallback(level C.int, file *C.char, line C.int, dmErrnoOrClass C.int, message *C.char) {
msg := C.GoString(message)
if level < 7 {
if strings.Contains(msg, "busy") {
@ -29,6 +30,6 @@ func DevmapperLogCallback(level C.int, file *C.char, line C.int, dm_errno_or_cla
}
if dmLogger != nil {
dmLogger.DMLog(int(level), C.GoString(file), int(line), int(dm_errno_or_class), msg)
dmLogger.DMLog(int(level), C.GoString(file), int(line), int(dmErrnoOrClass), msg)
}
}

43
pkg/devicemapper/devmapper_wrapper.go
View file

@ -44,18 +44,18 @@ import (
)
type (
CDmTask C.struct_dm_task
cdmTask C.struct_dm_task
CLoopInfo64 C.struct_loop_info64
LoopInfo64 struct {
cLoopInfo64 C.struct_loop_info64
loopInfo64 struct {
loDevice uint64 /* ioctl r/o */
loInode uint64 /* ioctl r/o */
loRdevice uint64 /* ioctl r/o */
loOffset uint64
loSizelimit uint64 /* bytes, 0 == max available */
loNumber uint32 /* ioctl r/o */
loEncrypt_type uint32
loEncrypt_key_size uint32 /* ioctl w/o */
loEncryptType uint32
loEncryptKeySize uint32 /* ioctl w/o */
loFlags uint32 /* ioctl r/o */
loFileName [LoNameSize]uint8
loCryptName [LoNameSize]uint8
@ -77,6 +77,7 @@ const (
LoopSetCapacity = C.LOOP_SET_CAPACITY
)
// LOOP consts. (?)
const (
LoFlagsAutoClear = C.LO_FLAGS_AUTOCLEAR
LoFlagsReadOnly = C.LO_FLAGS_READ_ONLY
@ -85,6 +86,7 @@ const (
LoNameSize = C.LO_NAME_SIZE
)
// DeviceMapper Udev consts. (?)
const (
DmUdevDisableSubsystemRulesFlag = C.DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG
DmUdevDisableDiskRulesFlag = C.DM_UDEV_DISABLE_DISK_RULES_FLAG
@ -92,6 +94,7 @@ const (
DmUdevDisableLibraryFallback = C.DM_UDEV_DISABLE_LIBRARY_FALLBACK
)
// DeviceMapper mapped functions.
var (
DmGetLibraryVersion = dmGetLibraryVersionFct
DmGetNextTarget = dmGetNextTargetFct
@ -123,38 +126,38 @@ func free(p *C.char) {
C.free(unsafe.Pointer(p))
}
func dmTaskDestroyFct(task *CDmTask) {
func dmTaskDestroyFct(task *cdmTask) {
C.dm_task_destroy((*C.struct_dm_task)(task))
}
func dmTaskCreateFct(taskType int) *CDmTask {
return (*CDmTask)(C.dm_task_create(C.int(taskType)))
func dmTaskCreateFct(taskType int) *cdmTask {
return (*cdmTask)(C.dm_task_create(C.int(taskType)))
}
func dmTaskRunFct(task *CDmTask) int {
func dmTaskRunFct(task *cdmTask) int {
ret, _ := C.dm_task_run((*C.struct_dm_task)(task))
return int(ret)
}
func dmTaskSetNameFct(task *CDmTask, name string) int {
func dmTaskSetNameFct(task *cdmTask, name string) int {
Cname := C.CString(name)
defer free(Cname)
return int(C.dm_task_set_name((*C.struct_dm_task)(task), Cname))
}
func dmTaskSetMessageFct(task *CDmTask, message string) int {
func dmTaskSetMessageFct(task *cdmTask, message string) int {
Cmessage := C.CString(message)
defer free(Cmessage)
return int(C.dm_task_set_message((*C.struct_dm_task)(task), Cmessage))
}
func dmTaskSetSectorFct(task *CDmTask, sector uint64) int {
func dmTaskSetSectorFct(task *cdmTask, sector uint64) int {
return int(C.dm_task_set_sector((*C.struct_dm_task)(task), C.uint64_t(sector)))
}
func dmTaskSetCookieFct(task *CDmTask, cookie *uint, flags uint16) int {
func dmTaskSetCookieFct(task *cdmTask, cookie *uint, flags uint16) int {
cCookie := C.uint32_t(*cookie)
defer func() {
*cookie = uint(cCookie)
@ -162,15 +165,15 @@ func dmTaskSetCookieFct(task *CDmTask, cookie *uint, flags uint16) int {
return int(C.dm_task_set_cookie((*C.struct_dm_task)(task), &cCookie, C.uint16_t(flags)))
}
func dmTaskSetAddNodeFct(task *CDmTask, addNode AddNodeType) int {
func dmTaskSetAddNodeFct(task *cdmTask, addNode AddNodeType) int {
return int(C.dm_task_set_add_node((*C.struct_dm_task)(task), C.dm_add_node_t(addNode)))
}
func dmTaskSetRoFct(task *CDmTask) int {
func dmTaskSetRoFct(task *cdmTask) int {
return int(C.dm_task_set_ro((*C.struct_dm_task)(task)))
}
func dmTaskAddTargetFct(task *CDmTask,
func dmTaskAddTargetFct(task *cdmTask,
start, size uint64, ttype, params string) int {
Cttype := C.CString(ttype)
@ -182,7 +185,7 @@ func dmTaskAddTargetFct(task *CDmTask,
return int(C.dm_task_add_target((*C.struct_dm_task)(task), C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))
}
func dmTaskGetDepsFct(task *CDmTask) *Deps {
func dmTaskGetDepsFct(task *cdmTask) *Deps {
Cdeps := C.dm_task_get_deps((*C.struct_dm_task)(task))
if Cdeps == nil {
return nil
@ -206,7 +209,7 @@ func dmTaskGetDepsFct(task *CDmTask) *Deps {
return deps
}
func dmTaskGetInfoFct(task *CDmTask, info *Info) int {
func dmTaskGetInfoFct(task *cdmTask, info *Info) int {
Cinfo := C.struct_dm_info{}
defer func() {
info.Exists = int(Cinfo.exists)
@ -223,7 +226,7 @@ func dmTaskGetInfoFct(task *CDmTask, info *Info) int {
return int(C.dm_task_get_info((*C.struct_dm_task)(task), &Cinfo))
}
func dmTaskGetDriverVersionFct(task *CDmTask) string {
func dmTaskGetDriverVersionFct(task *cdmTask) string {
buffer := C.malloc(128)
defer C.free(buffer)
res := C.dm_task_get_driver_version((*C.struct_dm_task)(task), (*C.char)(buffer), 128)
@ -233,7 +236,7 @@ func dmTaskGetDriverVersionFct(task *CDmTask) string {
return C.GoString((*C.char)(buffer))
}
func dmGetNextTargetFct(task *CDmTask, next unsafe.Pointer, start, length *uint64, target, params *string) unsafe.Pointer {
func dmGetNextTargetFct(task *cdmTask, next unsafe.Pointer, start, length *uint64, target, params *string) unsafe.Pointer {
var (
Cstart, Clength C.uint64_t
CtargetType, Cparams *C.char

1
pkg/devicemapper/devmapper_wrapper_deferred_remove.go
View file

@ -8,6 +8,7 @@ package devicemapper
*/
import "C"
// LibraryDeferredRemovalsupport is supported when statically linked.
const LibraryDeferredRemovalSupport = true
func dmTaskDeferredRemoveFct(task *CDmTask) int {

5
pkg/devicemapper/devmapper_wrapper_no_deferred_remove.go
View file

@ -2,13 +2,14 @@
package devicemapper
// LibraryDeferredRemovalsupport is not supported when statically linked.
const LibraryDeferredRemovalSupport = false
func dmTaskDeferredRemoveFct(task *CDmTask) int {
func dmTaskDeferredRemoveFct(task *cdmTask) int {
// Error. Nobody should be calling it.
return -1
}
func dmTaskGetInfoWithDeferredFct(task *CDmTask, info *Info) int {
func dmTaskGetInfoWithDeferredFct(task *cdmTask, info *Info) int {
return -1
}

6
pkg/devicemapper/ioctl.go
View file

@ -22,7 +22,7 @@ func ioctlLoopSetFd(loopFd, sparseFd uintptr) error {
return nil
}
func ioctlLoopSetStatus64(loopFd uintptr, loopInfo *LoopInfo64) error {
func ioctlLoopSetStatus64(loopFd uintptr, loopInfo *loopInfo64) error {
if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopSetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 {
return err
}
@ -36,8 +36,8 @@ func ioctlLoopClrFd(loopFd uintptr) error {
return nil
}
func ioctlLoopGetStatus64(loopFd uintptr) (*LoopInfo64, error) {
loopInfo := &LoopInfo64{}
func ioctlLoopGetStatus64(loopFd uintptr) (*loopInfo64, error) {
loopInfo := &loopInfo64{}
if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopGetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 {
return nil, err

6
pkg/plugins/pluginrpc-gen/fixtures/foo.go
View file

@ -6,12 +6,15 @@ type wobble struct {
Inception *wobble
}
// Fooer is an empty interface used for tests.
type Fooer interface{}
// Fooer2 is an interface used for tests.
type Fooer2 interface {
Foo()
}
// Fooer3 is an interface used for tests.
type Fooer3 interface {
Foo()
Bar(a string)
@ -21,14 +24,17 @@ type Fooer3 interface {
Wiggle() (w wobble)
}
// Fooer4 is an interface used for tests.
type Fooer4 interface {
Foo() error
}
// Bar is an interface used for tests.
type Bar interface {
Boo(a string, b string) (s string, err error)
}
// Fooer5 is an interface used for tests.
type Fooer5 interface {
Foo()
Bar

2
pkg/plugins/pluginrpc-gen/main.go
View file

@ -72,7 +72,7 @@ func main() {
InterfaceType string
RPCName string
BuildTags map[string]struct{}
*parsedPkg
*ParsedPkg
}{toLower(*typeName), *rpcName, flBuildTags.GetValues(), pkg}
var buf bytes.Buffer

32
pkg/plugins/pluginrpc-gen/parser.go
View file

@ -9,18 +9,20 @@ import (
"reflect"
)
var ErrBadReturn = errors.New("found return arg with no name: all args must be named")
var errBadReturn = errors.New("found return arg with no name: all args must be named")
type ErrUnexpectedType struct {
type errUnexpectedType struct {
expected string
actual interface{}
}
func (e ErrUnexpectedType) Error() string {
func (e errUnexpectedType) Error() string {
return fmt.Sprintf("got wrong type expecting %s, got: %v", e.expected, reflect.TypeOf(e.actual))
}
type parsedPkg struct {
// ParsedPkg holds information about a package that has been parsed,
// its name and the list of functions.
type ParsedPkg struct {
Name string
Functions []function
}
@ -41,14 +43,14 @@ func (a *arg) String() string {
return a.Name + " " + a.ArgType
}
// Parses the given file for an interface definition with the given name
func Parse(filePath string, objName string) (*parsedPkg, error) {
// Parse parses the given file for an interface definition with the given name.
func Parse(filePath string, objName string) (*ParsedPkg, error) {
fs := token.NewFileSet()
pkg, err := parser.ParseFile(fs, filePath, nil, parser.AllErrors)
if err != nil {
return nil, err
}
p := &parsedPkg{}
p := &ParsedPkg{}
p.Name = pkg.Name.Name
obj, exists := pkg.Scope.Objects[objName]
if !exists {
@ -59,11 +61,11 @@ func Parse(filePath string, objName string) (*parsedPkg, error) {
}
spec, ok := obj.Decl.(*ast.TypeSpec)
if !ok {
return nil, ErrUnexpectedType{"*ast.TypeSpec", obj.Decl}
return nil, errUnexpectedType{"*ast.TypeSpec", obj.Decl}
}
iface, ok := spec.Type.(*ast.InterfaceType)
if !ok {
return nil, ErrUnexpectedType{"*ast.InterfaceType", spec.Type}
return nil, errUnexpectedType{"*ast.InterfaceType", spec.Type}
}
p.Functions, err = parseInterface(iface)
@ -90,11 +92,11 @@ func parseInterface(iface *ast.InterfaceType) ([]function, error) {
case *ast.Ident:
spec, ok := f.Obj.Decl.(*ast.TypeSpec)
if !ok {
return nil, ErrUnexpectedType{"*ast.TypeSpec", f.Obj.Decl}
return nil, errUnexpectedType{"*ast.TypeSpec", f.Obj.Decl}
}
iface, ok := spec.Type.(*ast.InterfaceType)
if !ok {
return nil, ErrUnexpectedType{"*ast.TypeSpec", spec.Type}
return nil, errUnexpectedType{"*ast.TypeSpec", spec.Type}
}
funcs, err := parseInterface(iface)
if err != nil {
@ -103,7 +105,7 @@ func parseInterface(iface *ast.InterfaceType) ([]function, error) {
}
functions = append(functions, funcs...)
default:
return nil, ErrUnexpectedType{"*astFuncType or *ast.Ident", f}
return nil, errUnexpectedType{"*astFuncType or *ast.Ident", f}
}
}
return functions, nil
@ -137,7 +139,7 @@ func parseArgs(fields []*ast.Field) ([]arg, error) {
var args []arg
for _, f := range fields {
if len(f.Names) == 0 {
return nil, ErrBadReturn
return nil, errBadReturn
}
for _, name := range f.Names {
var typeName string
@ -147,11 +149,11 @@ func parseArgs(fields []*ast.Field) ([]arg, error) {
case *ast.StarExpr:
i, ok := argType.X.(*ast.Ident)
if !ok {
return nil, ErrUnexpectedType{"*ast.Ident", f.Type}
return nil, errUnexpectedType{"*ast.Ident", f.Type}
}
typeName = "*" + i.Name
default:
return nil, ErrUnexpectedType{"*ast.Ident or *ast.StarExpr", f.Type}
return nil, errUnexpectedType{"*ast.Ident or *ast.StarExpr", f.Type}
}
args = append(args, arg{name.Name, typeName})

4
pkg/plugins/pluginrpc-gen/parser_test.go
View file

@ -22,7 +22,7 @@ func TestParseEmptyInterface(t *testing.T) {
func TestParseNonInterfaceType(t *testing.T) {
_, err := Parse(testFixture, "wobble")
if _, ok := err.(ErrUnexpectedType); !ok {
if _, ok := err.(errUnexpectedType); !ok {
t.Fatal("expected type error when parsing non-interface type")
}
}
@ -109,7 +109,7 @@ func TestParseWithMultipleFuncs(t *testing.T) {
func TestParseWithUnamedReturn(t *testing.T) {
_, err := Parse(testFixture, "Fooer4")
if !strings.HasSuffix(err.Error(), ErrBadReturn.Error()) {
if !strings.HasSuffix(err.Error(), errBadReturn.Error()) {
t.Fatalf("expected ErrBadReturn, got %v", err)
}
}