Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

RSDK-901 - Add resource.Name to Reconfigurable #1616

Merged
merged 2 commits into from
Nov 23, 2022
Merged

RSDK-901 - Add resource.Name to Reconfigurable #1616

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
b3ccfed
RSDK-901 - Add resource.Name to Reconfigurable
edaniels Nov 23, 2022
5a2afb0
fix test
edaniels Nov 23, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 7 additions & 2 deletions components/arm/arm.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -190,9 +190,14 @@ func CreateStatus(ctx context.Context, resource interface{}) (*pb.Status, error)

type reconfigurableArm struct {
mu sync.RWMutex
name resource.Name
actual Arm
}

func (r *reconfigurableArm) Name() resource.Name {
return r.name
}

func (r *reconfigurableArm) DoCommand(ctx context.Context, cmd map[string]interface{}) (map[string]interface{}, error) {
r.mu.RLock()
defer r.mu.RUnlock()
Expand Down Expand Up @@ -321,7 +326,7 @@ func (r *reconfigurableLocalArm) Reconfigure(ctx context.Context, newArm resourc
// WrapWithReconfigurable converts a regular Arm implementation to a reconfigurableArm
// and a localArm into a reconfigurableLocalArm
// If arm is already a Reconfigurable, then nothing is done.
func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
func WrapWithReconfigurable(r interface{}, name resource.Name) (resource.Reconfigurable, error) {
arm, ok := r.(Arm)
if !ok {
return nil, NewUnimplementedInterfaceError(r)
Expand All @@ -331,7 +336,7 @@ func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
return reconfigurable, nil
}

rArm := &reconfigurableArm{actual: arm}
rArm := &reconfigurableArm{name: name, actual: arm}
localArm, ok := r.(LocalArm)
if !ok {
// is an arm but is not a local arm
Expand Down
24 changes: 12 additions & 12 deletions components/arm/arm_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -248,21 +248,21 @@ func TestArmName(t *testing.T) {

func TestWrapWithReconfigurable(t *testing.T) {
var actualArm1 arm.Arm = &mock{Name: testArmName}
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1)
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

_, err = arm.WrapWithReconfigurable(nil)
_, err = arm.WrapWithReconfigurable(nil, resource.Name{})
test.That(t, err, test.ShouldBeError, arm.NewUnimplementedInterfaceError(nil))

reconfArm2, err := arm.WrapWithReconfigurable(reconfArm1)
reconfArm2, err := arm.WrapWithReconfigurable(reconfArm1, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfArm2, test.ShouldEqual, reconfArm1)

var actualArm2 arm.LocalArm = &mockLocal{Name: testArmName}
reconfArm3, err := arm.WrapWithReconfigurable(actualArm2)
reconfArm3, err := arm.WrapWithReconfigurable(actualArm2, resource.Name{})
test.That(t, err, test.ShouldBeNil)

reconfArm4, err := arm.WrapWithReconfigurable(reconfArm3)
reconfArm4, err := arm.WrapWithReconfigurable(reconfArm3, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfArm4, test.ShouldResemble, reconfArm3)

Expand All @@ -272,12 +272,12 @@ func TestWrapWithReconfigurable(t *testing.T) {

func TestReconfigurableArm(t *testing.T) {
actualArm1 := &mockLocal{Name: testArmName}
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1)
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfArm1, test.ShouldNotBeNil)

actualArm2 := &mockLocal{Name: testArmName2}
reconfArm2, err := arm.WrapWithReconfigurable(actualArm2)
reconfArm2, err := arm.WrapWithReconfigurable(actualArm2, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfArm2, test.ShouldNotBeNil)
test.That(t, actualArm1.reconfCount, test.ShouldEqual, 0)
Expand All @@ -300,7 +300,7 @@ func TestReconfigurableArm(t *testing.T) {
test.That(t, err, test.ShouldBeError, rutils.NewUnexpectedTypeError(reconfArm1, nil))

actualArm3 := &mock{Name: failArmName}
reconfArm3, err := arm.WrapWithReconfigurable(actualArm3)
reconfArm3, err := arm.WrapWithReconfigurable(actualArm3, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfArm3, test.ShouldNotBeNil)

Expand All @@ -314,7 +314,7 @@ func TestReconfigurableArm(t *testing.T) {
test.That(t, err, test.ShouldBeError, rutils.NewUnexpectedTypeError(reconfArm3, reconfArm1))

actualArm4 := &mock{Name: testArmName2}
reconfArm4, err := arm.WrapWithReconfigurable(actualArm4)
reconfArm4, err := arm.WrapWithReconfigurable(actualArm4, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfArm4, test.ShouldNotBeNil)

Expand All @@ -325,7 +325,7 @@ func TestReconfigurableArm(t *testing.T) {

func TestStop(t *testing.T) {
actualArm1 := &mockLocal{Name: testArmName}
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1)
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

test.That(t, actualArm1.stopCount, test.ShouldEqual, 0)
Expand All @@ -335,7 +335,7 @@ func TestStop(t *testing.T) {

func TestClose(t *testing.T) {
actualArm1 := &mockLocal{Name: testArmName}
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1)
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

test.That(t, actualArm1.reconfCount, test.ShouldEqual, 0)
Expand All @@ -345,7 +345,7 @@ func TestClose(t *testing.T) {

func TestExtraOptions(t *testing.T) {
actualArm1 := &mockLocal{Name: testArmName}
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1)
reconfArm1, err := arm.WrapWithReconfigurable(actualArm1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

test.That(t, actualArm1.extra, test.ShouldEqual, nil)
Expand Down
8 changes: 7 additions & 1 deletion components/audioinput/audio_input.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -76,7 +76,7 @@ func DependencyTypeError(name, actual interface{}) error {
}

// WrapWithReconfigurable wraps an audio input with a reconfigurable and locking interface.
func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
func WrapWithReconfigurable(r interface{}, name resource.Name) (resource.Reconfigurable, error) {
i, ok := r.(AudioInput)
if !ok {
return nil, NewUnimplementedInterfaceError(r)
Expand All @@ -86,6 +86,7 @@ func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
}
cancelCtx, cancel := context.WithCancel(context.Background())
return &reconfigurableAudioInput{
name: name,
actual: i,
cancelCtx: cancelCtx,
cancel: cancel,
Expand Down Expand Up @@ -194,11 +195,16 @@ func (as *audioSource) Close(ctx context.Context) error {

type reconfigurableAudioInput struct {
mu sync.RWMutex
name resource.Name
actual AudioInput
cancelCtx context.Context
cancel func()
}

func (i *reconfigurableAudioInput) Name() resource.Name {
return i.name
}

func (i *reconfigurableAudioInput) ProxyFor() interface{} {
i.mu.RLock()
defer i.mu.RUnlock()
Expand Down
14 changes: 7 additions & 7 deletions components/audioinput/audioinput_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -156,24 +156,24 @@ func TestAudioInputName(t *testing.T) {

func TestWrapWithReconfigurable(t *testing.T) {
var actualaudioInput1 audioinput.AudioInput = &mock{Name: testAudioInputName}
reconfaudioInput1, err := audioinput.WrapWithReconfigurable(actualaudioInput1)
reconfaudioInput1, err := audioinput.WrapWithReconfigurable(actualaudioInput1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

_, err = audioinput.WrapWithReconfigurable(nil)
_, err = audioinput.WrapWithReconfigurable(nil, resource.Name{})
test.That(t, err, test.ShouldBeError, audioinput.NewUnimplementedInterfaceError(nil))

reconfAudioInput2, err := audioinput.WrapWithReconfigurable(reconfaudioInput1)
reconfAudioInput2, err := audioinput.WrapWithReconfigurable(reconfaudioInput1, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfAudioInput2, test.ShouldEqual, reconfaudioInput1)
}

func TestReconfigurableAudioInput(t *testing.T) {
actualaudioInput1 := &mock{Name: testAudioInputName}
reconfaudioInput1, err := audioinput.WrapWithReconfigurable(actualaudioInput1)
reconfaudioInput1, err := audioinput.WrapWithReconfigurable(actualaudioInput1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

actualAudioInput2 := &mock{Name: testAudioInputName2}
reconfAudioInput2, err := audioinput.WrapWithReconfigurable(actualAudioInput2)
reconfAudioInput2, err := audioinput.WrapWithReconfigurable(actualAudioInput2, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, actualaudioInput1.reconfCount, test.ShouldEqual, 0)

Expand Down Expand Up @@ -210,7 +210,7 @@ func TestReconfigurableAudioInput(t *testing.T) {

func TestClose(t *testing.T) {
actualaudioInput1 := &mock{Name: testAudioInputName}
reconfaudioInput1, err := audioinput.WrapWithReconfigurable(actualaudioInput1)
reconfaudioInput1, err := audioinput.WrapWithReconfigurable(actualaudioInput1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

test.That(t, actualaudioInput1.reconfCount, test.ShouldEqual, 0)
Expand Down Expand Up @@ -295,7 +295,7 @@ func TestNewAudioInput(t *testing.T) {
test.That(t, audioData, test.ShouldResemble, audioData1)

// audioInput1 wrapped with reconfigurable
_, err = audioinput.WrapWithReconfigurable(audioInput1)
_, err = audioinput.WrapWithReconfigurable(audioInput1, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, audioInput1.Close(context.Background()), test.ShouldBeNil)
}
9 changes: 7 additions & 2 deletions components/base/base.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -159,9 +159,14 @@ func CreateStatus(ctx context.Context, resource interface{}) (*commonpb.Actuator

type reconfigurableBase struct {
mu sync.RWMutex
name resource.Name
actual Base
}

func (r *reconfigurableBase) Name() resource.Name {
return r.name
}

func (r *reconfigurableBase) ProxyFor() interface{} {
r.mu.RLock()
defer r.mu.RUnlock()
Expand Down Expand Up @@ -272,7 +277,7 @@ func (r *reconfigurableLocalBase) Reconfigure(ctx context.Context, newBase resou

// WrapWithReconfigurable converts a regular LocalBase implementation to a reconfigurableBase.
// If base is already a reconfigurableBase, then nothing is done.
func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
func WrapWithReconfigurable(r interface{}, name resource.Name) (resource.Reconfigurable, error) {
base, ok := r.(Base)
if !ok {
return nil, NewUnimplementedInterfaceError(r)
Expand All @@ -281,7 +286,7 @@ func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
return reconfigurable, nil
}

rBase := &reconfigurableBase{actual: base}
rBase := &reconfigurableBase{name: name, actual: base}
localBase, ok := r.(LocalBase)
if !ok {
return rBase, nil
Expand Down
20 changes: 10 additions & 10 deletions components/base/base_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -184,21 +184,21 @@ func TestCreateStatus(t *testing.T) {

func TestWrapWithReconfigurable(t *testing.T) {
var actualBase1 base.Base = &mock{Name: testBaseName}
reconfBase1, err := base.WrapWithReconfigurable(actualBase1)
reconfBase1, err := base.WrapWithReconfigurable(actualBase1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

_, err = base.WrapWithReconfigurable(nil)
_, err = base.WrapWithReconfigurable(nil, resource.Name{})
test.That(t, err, test.ShouldBeError, base.NewUnimplementedInterfaceError(nil))

reconfBase2, err := base.WrapWithReconfigurable(reconfBase1)
reconfBase2, err := base.WrapWithReconfigurable(reconfBase1, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfBase2, test.ShouldEqual, reconfBase1)

var actualBase2 base.LocalBase = &mockLocal{Name: testBaseName}
reconfBase3, err := base.WrapWithReconfigurable(actualBase2)
reconfBase3, err := base.WrapWithReconfigurable(actualBase2, resource.Name{})
test.That(t, err, test.ShouldBeNil)

reconfBase4, err := base.WrapWithReconfigurable(reconfBase3)
reconfBase4, err := base.WrapWithReconfigurable(reconfBase3, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfBase4, test.ShouldResemble, reconfBase3)

Expand All @@ -208,11 +208,11 @@ func TestWrapWithReconfigurable(t *testing.T) {

func TestReconfigurableBase(t *testing.T) {
actualBase1 := &mockLocal{Name: testBaseName}
reconfBase1, err := base.WrapWithReconfigurable(actualBase1)
reconfBase1, err := base.WrapWithReconfigurable(actualBase1, resource.Name{})
test.That(t, err, test.ShouldBeNil)

actualBase2 := &mockLocal{Name: testBaseName2}
reconfBase2, err := base.WrapWithReconfigurable(actualBase2)
reconfBase2, err := base.WrapWithReconfigurable(actualBase2, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, actualBase1.reconfCount, test.ShouldEqual, 0)

Expand All @@ -234,7 +234,7 @@ func TestReconfigurableBase(t *testing.T) {
test.That(t, err, test.ShouldBeError, rutils.NewUnexpectedTypeError(reconfBase1, nil))

actualBase3 := &mock{Name: failBaseName}
reconfBase3, err := base.WrapWithReconfigurable(actualBase3)
reconfBase3, err := base.WrapWithReconfigurable(actualBase3, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfBase3, test.ShouldNotBeNil)

Expand All @@ -247,7 +247,7 @@ func TestReconfigurableBase(t *testing.T) {
test.That(t, err, test.ShouldBeError, rutils.NewUnexpectedTypeError(reconfBase3, reconfBase1))

actualBase4 := &mock{Name: testBaseName2}
reconfBase4, err := base.WrapWithReconfigurable(actualBase4)
reconfBase4, err := base.WrapWithReconfigurable(actualBase4, resource.Name{})
test.That(t, err, test.ShouldBeNil)
test.That(t, reconfBase4, test.ShouldNotBeNil)

Expand All @@ -258,7 +258,7 @@ func TestReconfigurableBase(t *testing.T) {

func TestClose(t *testing.T) {
actualBase1 := &mockLocal{Name: testBaseName}
reconfBase1, _ := base.WrapWithReconfigurable(actualBase1)
reconfBase1, _ := base.WrapWithReconfigurable(actualBase1, resource.Name{})

test.That(t, actualBase1.reconfCount, test.ShouldEqual, 0)
test.That(t, utils.TryClose(context.Background(), reconfBase1), test.ShouldBeNil)
Expand Down
8 changes: 7 additions & 1 deletion components/board/board.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -208,11 +208,16 @@ func NamesFromRobot(r robot.Robot) []string {

type reconfigurableBoard struct {
mu sync.RWMutex
name resource.Name
actual Board
analogs map[string]*reconfigurableAnalogReader
digitals map[string]*reconfigurableDigitalInterrupt
}

func (r *reconfigurableBoard) Name() resource.Name {
return r.name
}

func (r *reconfigurableBoard) ProxyFor() interface{} {
r.mu.RLock()
defer r.mu.RUnlock()
Expand Down Expand Up @@ -458,7 +463,7 @@ func (r *reconfigurableLocalBoard) Reconfigure(ctx context.Context, newBoard res

// WrapWithReconfigurable converts a regular Board implementation to a reconfigurableBoard.
// If board is already a reconfigurableBoard, then nothing is done.
func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
func WrapWithReconfigurable(r interface{}, name resource.Name) (resource.Reconfigurable, error) {
board, ok := r.(Board)
if !ok {
return nil, NewUnimplementedInterfaceError(r)
Expand All @@ -469,6 +474,7 @@ func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error) {
}

rb := reconfigurableBoard{
name: name,
actual: board,
analogs: map[string]*reconfigurableAnalogReader{},
digitals: map[string]*reconfigurableDigitalInterrupt{},
Expand Down
Loading