Skip to content

Commit

Permalink
edgexfoundry#196: Applied URLClient pattern to scheduler.
Browse files Browse the repository at this point in the history 
Signed-off-by: Brandon Forster <me@brandonforster.com>
  • Loading branch information
@brandonforster
brandonforster committed Jan 21, 2020
1 parent 69f0ac3 commit 6d3824e
Show file tree
Hide file tree
Showing 2 changed files with 130 additions and 92 deletions.
109 changes: 61 additions & 48 deletions clients/scheduler/interval.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,9 +12,7 @@
* the License.
*******************************************************************************/

/*
Package scheduler provides clients used for integration with the support-scheduler service.
*/
// scheduler provides clients used for integration with the support-scheduler service.
package scheduler

import (
Expand All @@ -25,12 +23,11 @@ import (
"github.com/edgexfoundry/go-mod-core-contracts/clients"
"github.com/edgexfoundry/go-mod-core-contracts/clients/interfaces"
"github.com/edgexfoundry/go-mod-core-contracts/clients/types"
"github.com/edgexfoundry/go-mod-core-contracts/clients/urlclient"
"github.com/edgexfoundry/go-mod-core-contracts/models"
)

/*
IntervalClient defines the interface for interactions with the Interval endpoint on the EdgeX Foundry support-scheduler service.
*/
// IntervalClient defines the interface for interactions with the Interval endpoint on support-scheduler.
type IntervalClient interface {
// Add a new scheduling interval
Add(dev *models.Interval, ctx context.Context) (string, error)
Expand All @@ -49,84 +46,100 @@ type IntervalClient interface {
}

type intervalRestClient struct {
url string
endpoint interfaces.Endpointer
urlClient interfaces.URLClient
}

// NewIntervalClient creates an instance of IntervalClient
func NewIntervalClient(params types.EndpointParams, m interfaces.Endpointer) IntervalClient {
s := intervalRestClient{endpoint: m}
s.init(params)
return &s
return &intervalRestClient{urlClient: urlclient.New(params, m)}
}

func (s *intervalRestClient) init(params types.EndpointParams) {
if params.UseRegistry {
go func(ch chan string) {
for {
select {
case url := <-ch:
s.url = url
}
}
}(s.endpoint.Monitor(params))
} else {
s.url = params.Url
func (ic *intervalRestClient) Add(interval *models.Interval, ctx context.Context) (string, error) {
url, err := ic.urlClient.Prefix()
if err != nil {
return "", err
}
}

func (s *intervalRestClient) Add(interval *models.Interval, ctx context.Context) (string, error) {
return clients.PostJsonRequest(s.url, interval, ctx)
return clients.PostJsonRequest(url, interval, ctx)
}

func (s *intervalRestClient) Delete(id string, ctx context.Context) error {
return clients.DeleteRequest(s.url+"/id/"+id, ctx)
}
func (ic *intervalRestClient) Delete(id string, ctx context.Context) error {
urlPrefix, err := ic.urlClient.Prefix()
if err != nil {
return err
}

func (s *intervalRestClient) DeleteByName(name string, ctx context.Context) error {
return clients.DeleteRequest(s.url+"/name/"+url.QueryEscape(name), ctx)
return clients.DeleteRequest(urlPrefix+"/id/"+id, ctx)
}

func (s *intervalRestClient) Interval(id string, ctx context.Context) (models.Interval, error) {
return s.requestInterval(s.url+"/"+id, ctx)
func (ic *intervalRestClient) DeleteByName(name string, ctx context.Context) error {
urlPrefix, err := ic.urlClient.Prefix()
if err != nil {
return err
}

return clients.DeleteRequest(urlPrefix+"/name/"+url.QueryEscape(name), ctx)
}

func (s *intervalRestClient) IntervalForName(name string, ctx context.Context) (models.Interval, error) {
return s.requestInterval(s.url+"/name/"+url.QueryEscape(name), ctx)
func (ic *intervalRestClient) Interval(id string, ctx context.Context) (models.Interval, error) {
return ic.requestInterval("/"+id, ctx)
}

func (s *intervalRestClient) Intervals(ctx context.Context) ([]models.Interval, error) {
return s.requestIntervalSlice(s.url, ctx)
func (ic *intervalRestClient) IntervalForName(name string, ctx context.Context) (models.Interval, error) {
return ic.requestInterval("/name/"+url.QueryEscape(name), ctx)
}

func (s *intervalRestClient) Update(interval models.Interval, ctx context.Context) error {
return clients.UpdateRequest(s.url, interval, ctx)
func (ic *intervalRestClient) Intervals(ctx context.Context) ([]models.Interval, error) {
return ic.requestIntervalSlice("", ctx)
}

//
// Helper functions
//
func (ic *intervalRestClient) Update(interval models.Interval, ctx context.Context) error {
url, err := ic.urlClient.Prefix()
if err != nil {
return err
}

return clients.UpdateRequest(url, interval, ctx)
}

// helper request and decode an interval
func (s *intervalRestClient) requestInterval(url string, ctx context.Context) (models.Interval, error) {
data, err := clients.GetRequest(url, ctx)
func (ic *intervalRestClient) requestInterval(urlSuffix string, ctx context.Context) (models.Interval, error) {
urlPrefix, err := ic.urlClient.Prefix()
if err != nil {
return models.Interval{}, err
}

data, err := clients.GetRequest(urlPrefix+urlSuffix, ctx)
if err != nil {
return models.Interval{}, err
}

interval := models.Interval{}
err = json.Unmarshal(data, &interval)
return interval, err
if err != nil {
return models.Interval{}, err
}

return interval, nil
}

// helper returns a slice of intervals
func (s *intervalRestClient) requestIntervalSlice(url string, ctx context.Context) ([]models.Interval, error) {
data, err := clients.GetRequest(url, ctx)
func (ic *intervalRestClient) requestIntervalSlice(urlSuffix string, ctx context.Context) ([]models.Interval, error) {
urlPrefix, err := ic.urlClient.Prefix()
if err != nil {
return []models.Interval{}, err
}

data, err := clients.GetRequest(urlPrefix+urlSuffix, ctx)
if err != nil {
return []models.Interval{}, err
}

sSlice := make([]models.Interval, 0)
err = json.Unmarshal(data, &sSlice)
return sSlice, err
if err != nil {
return []models.Interval{}, err
}

return sSlice, nil
}
113 changes: 69 additions & 44 deletions clients/scheduler/interval_action.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,12 +22,11 @@ import (
"github.com/edgexfoundry/go-mod-core-contracts/clients"
"github.com/edgexfoundry/go-mod-core-contracts/clients/interfaces"
"github.com/edgexfoundry/go-mod-core-contracts/clients/types"
"github.com/edgexfoundry/go-mod-core-contracts/clients/urlclient"
"github.com/edgexfoundry/go-mod-core-contracts/models"
)

/*
IntervalActionClient defines the interface for interactions with the IntervalAction endpoint on the EdgeX Foundry support-scheduler service.
*/
// IntervalActionClient defines the interface for interactions with the IntervalAction endpoint on support-scheduler.
type IntervalActionClient interface {
// Add a new schedule interval action
Add(dev *models.IntervalAction, ctx context.Context) (string, error)
Expand All @@ -48,84 +47,110 @@ type IntervalActionClient interface {
}

type intervalActionRestClient struct {
url string
endpoint interfaces.Endpointer
urlClient interfaces.URLClient
}

// NewIntervalActionClient creates an instance of IntervalActionClient
func NewIntervalActionClient(params types.EndpointParams, m interfaces.Endpointer) IntervalActionClient {
s := intervalActionRestClient{endpoint: m}
s.init(params)
return &s
return &intervalActionRestClient{urlClient: urlclient.New(params, m)}
}

func (s *intervalActionRestClient) init(params types.EndpointParams) {
if params.UseRegistry {
go func(ch chan string) {
for {
select {
case url := <-ch:
s.url = url
}
}
}(s.endpoint.Monitor(params))
} else {
s.url = params.Url
// Helper method to request and decode an interval action
func (iac *intervalActionRestClient) requestIntervalAction(
urlSuffix string,
ctx context.Context) (models.IntervalAction, error) {

urlPrefix, err := iac.urlClient.Prefix()
if err != nil {
return models.IntervalAction{}, err
}
}

// Helper method to request and decode an interval action
func (s *intervalActionRestClient) requestIntervalAction(url string, ctx context.Context) (models.IntervalAction, error) {
data, err := clients.GetRequest(url, ctx)
data, err := clients.GetRequest(urlPrefix+urlSuffix, ctx)
if err != nil {
return models.IntervalAction{}, err
}

ia := models.IntervalAction{}
err = json.Unmarshal(data, &ia)
return ia, err
if err != nil {
return models.IntervalAction{}, err
}

return ia, nil
}

// Helper method to request and decode an interval action slice
func (s *intervalActionRestClient) requestIntervalActionSlice(url string, ctx context.Context) ([]models.IntervalAction, error) {
data, err := clients.GetRequest(url, ctx)
func (iac *intervalActionRestClient) requestIntervalActionSlice(
urlSuffix string,
ctx context.Context) ([]models.IntervalAction, error) {

urlPrefix, err := iac.urlClient.Prefix()
if err != nil {
return nil, err
}

data, err := clients.GetRequest(urlPrefix+urlSuffix, ctx)
if err != nil {
return []models.IntervalAction{}, err
}

iaSlice := make([]models.IntervalAction, 0)
err = json.Unmarshal(data, &iaSlice)
return iaSlice, err
if err != nil {
return []models.IntervalAction{}, err
}

return iaSlice, nil
}

func (s *intervalActionRestClient) Add(ia *models.IntervalAction, ctx context.Context) (string, error) {
return clients.PostJsonRequest(s.url, ia, ctx)
func (iac *intervalActionRestClient) Add(ia *models.IntervalAction, ctx context.Context) (string, error) {
url, err := iac.urlClient.Prefix()
if err != nil {
return "", err
}

return clients.PostJsonRequest(url, ia, ctx)
}

func (s *intervalActionRestClient) Delete(id string, ctx context.Context) error {
return clients.DeleteRequest(s.url+"/id/"+id, ctx)
func (iac *intervalActionRestClient) Delete(id string, ctx context.Context) error {
urlPrefix, err := iac.urlClient.Prefix()
if err != nil {
return err
}

return clients.DeleteRequest(urlPrefix+"/id/"+id, ctx)
}

func (s *intervalActionRestClient) DeleteByName(name string, ctx context.Context) error {
return clients.DeleteRequest(s.url+"/name/"+url.QueryEscape(name), ctx)
func (iac *intervalActionRestClient) DeleteByName(name string, ctx context.Context) error {
urlPrefix, err := iac.urlClient.Prefix()
if err != nil {
return err
}

return clients.DeleteRequest(urlPrefix+"/name/"+url.QueryEscape(name), ctx)
}

func (s *intervalActionRestClient) IntervalAction(id string, ctx context.Context) (models.IntervalAction, error) {
return s.requestIntervalAction(s.url+"/"+id, ctx)
func (iac *intervalActionRestClient) IntervalAction(id string, ctx context.Context) (models.IntervalAction, error) {
return iac.requestIntervalAction("/"+id, ctx)
}

func (s *intervalActionRestClient) IntervalActionForName(name string, ctx context.Context) (models.IntervalAction, error) {
return s.requestIntervalAction(s.url+"/name/"+url.QueryEscape(name), ctx)
func (iac *intervalActionRestClient) IntervalActionForName(name string, ctx context.Context) (models.IntervalAction, error) {
return iac.requestIntervalAction("/name/"+url.QueryEscape(name), ctx)
}

func (s *intervalActionRestClient) IntervalActions(ctx context.Context) ([]models.IntervalAction, error) {
return s.requestIntervalActionSlice(s.url, ctx)
func (iac *intervalActionRestClient) IntervalActions(ctx context.Context) ([]models.IntervalAction, error) {
return iac.requestIntervalActionSlice("", ctx)
}

func (s *intervalActionRestClient) IntervalActionsForTargetByName(name string, ctx context.Context) ([]models.IntervalAction, error) {
return s.requestIntervalActionSlice(s.url+"/target/"+url.QueryEscape(name), ctx)
func (iac *intervalActionRestClient) IntervalActionsForTargetByName(name string, ctx context.Context) ([]models.IntervalAction, error) {
return iac.requestIntervalActionSlice("/target/"+url.QueryEscape(name), ctx)
}

func (s *intervalActionRestClient) Update(ia models.IntervalAction, ctx context.Context) error {
return clients.UpdateRequest(s.url, ia, ctx)
func (iac *intervalActionRestClient) Update(ia models.IntervalAction, ctx context.Context) error {
url, err := iac.urlClient.Prefix()
if err != nil {
return err
}

return clients.UpdateRequest(url, ia, ctx)
}

0 comments on commit 6d3824e

Please sign in to comment.