func (s *pingService) HandlePatch(ctx context.Context, op *operation.Operation) {
req := &pingRequest{}
err := op.DecodeBody(req)
if err != nil {
op.Fail(err)
return
}
op.SetStatusCode(http.StatusCreated)
op.Complete()
// Ping specified URL
pingOp := operation.NewPatch(ctx, req.URI, nil)
pingOp.SetBody(req)
client.Send(pingOp)
}
func (s *ServiceContext) HandleStart(ctx context.Context, op *operation.Operation) {
err := op.DecodeBody(s.h.GetState())
if err != nil && err != operation.ErrBodyNotSet {
op.Fail(err)
return
}
// Run the service handler's start handler if available
if h, ok := s.h.(StartHandler); ok {
err = op.CreateChild(ctx).Go(ctx, h.HandleStart).Wait()
if err != nil {
op.Fail(err)
return
}
}
op.Complete()
}
// handlePost calls out to the factory service implementation's POST handler,
// if it exists, and waits for completion. If this runs and completes without
// error, the returned body is passed to the start operation for the service
// created by this factory.
func (f *FactoryServiceContext) handlePost(ctx context.Context, op *operation.Operation) {
var err error
var sd *common.ServiceDocument
if h, ok := f.h.(PostHandler); ok {
// Run the factory service's POST handler and wait for completion.
err = op.CreateChild(ctx).Go(ctx, h.HandlePost).Wait()
if err != nil {
op.Fail(err)
return
}
}
doc := f.h.CreateDocument()
err = op.DecodeBody(doc)
if err != nil && err != io.EOF {
op.Fail(err)
return
}
sd = doc.GetServiceDocument()
sd.SelfLink = path.Join(f.SelfLink(), uuid.New())
op.SetBody(doc)
buf, err := op.EncodeBodyAsBuffer()
if err != nil {
op.Fail(err)
return
}
// Start child service at service document's selflink
startOp := op.NewPost(ctx, uri.Extend(uri.Local(), sd.SelfLink), buf)
f.Host().StartService(startOp, f.h.CreateService())
err = startOp.Wait()
if err != nil {
op.Fail(err)
return
}
op.Complete()
}
// startService executes the necessary actions to move a service from
// the available stage, to the started stage, to the available stage.
func (h *ServiceHost) startService(op *operation.Operation, s Service) {
ctx := context.Background()
err := op.CreateChild(ctx).Go(ctx, s.HandleStart).Wait()
if err != nil {
op.Fail(err)
return
}
if err := s.SetStage(StageStarted); err != nil {
op.Fail(err)
return
}
// Stuff may happen between the started and available stages.
// This separation is kept here for parity with the Java XENON implementation.
if err := s.SetStage(StageAvailable); err != nil {
op.Fail(err)
return
}
op.Complete()
}
func (m *MinimalService) HandleStart(ctx context.Context, op *operation.Operation) {
op.Complete()
}
func (f *FactoryServiceContext) HandleStart(ctx context.Context, op *operation.Operation) {
op.Complete()
}