Golang Operation.Complete方法代码示例

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()
}