// Define your Service
var _ Service = &MyService{}   // MyService implements Service
type MyService struct {
    orchestration.Recoverable, // Implements the Recover func to satisfy Service interface
    orchestration.Payload,     // Implements the GenerateResponse func to satisfy Service interface
    Datacenter string          // For example, to generate some complexity
}

func (svc *MyService) Name() string { return "MyService" }
func (svc *MyService) Check(_ context.Context) error { ... }
func (svc *MyService) Run(_ context.Context) error { ... }
func (svc *MyService) Rollback(_ context.Context) error { ... }

func main() {
    // Define the Services that you want to execute concurrently
    services := []Service{ &MyService{Datacenter: "DC1"}, &MyService{Datacenter: "DC2"}}
    
    // Call Check, Run, Rollback stages for each Service
    // errs align with services, err[i] corresponds with service[i]. err[i] may be nil
    // err is nil only when all errs are nil. Err contains information about which stage failed.
    errs, err := CallServices(context.TODO(), services)
    
    httpStatusCode, response := GenerateResponse(services, errs, err)
    // 200, {"status":"ok","details":[{"name":"MyService","detail":"<your-response>"}}
}

type Service interface {
    Name() string
    
    Check(ctx context.Context) error
    Recover(ctx context.Context) error // Advanced usage, should return an error if not implemented
    Run(ctx context.Context) error
    Rollback(ctx context.Context) error
    
    GetResponse(err error) interface{}
}

struct MyService {
    Payload
}

func (svc *MyService) Run(_ context.Context) error {
    svc.Payload.Response = "Good!"
    return nil
}

func main() {
    services := []Services{ &MyService{} }
    errs, err := CallServices(context.TODO(), services)
    
    httpStatusCode, response := GenerateResponse(services, errs, err)
    
    // response: 200: {"status":"ok","details":[{"name":"MyService","detail":"Good!"}}
    // or, on check stage error: 500: {"status":"one or more pre-run checks failed","details":[{"name":"MyService","detail":"some-error"}}
    // or, on run stage error: 500: {"status":"one or more runs failed","details":[{"name":"MyService","detail":"some-error"}}
}

type MyService struct {
    LocalRequest MyServiceRequest // Can be read/modified freely
    
    mutex.Lock // Owns SharedRequest
    SharedRequest *MyServiceRequest // Shared state across Services, protected by Lock.
}

type MyUpdateService struct {
    Recoverable // Provides a MyUpdateService.Recovery function pointer
    Request Spec
}

func (svc *MyUpdateService) Check(_ context.Context) error {
    if !database.Has(svc.Request.Name) {
        svc.Recovery = func(ctx context.Context) error {
            return MyCreateService{Request: svc.Request}.Run(ctx)
        }
        return errors.new("cannot update " + svc.Request.Name + " because it is not found")
    }
    return nil
}

orchestration.RollbackErrorReporter = func(services []orchestration.Service, errs []error) {
    for i := 0; i < len(services); i++ {
        if errs[i] != nil {
            log.Printf("Rollback failed for Service %s: %v", services[i].Name(), errs[i])
        }
    }
}

ctx := context.WithValue(context.Background(), "dryRun", true)
_, _ = CallServices(ctx, []Services{ ... }) // Only calls Check stage for each Service

var request Nameable = &SomePostedPayload{}
name, err := request.Name()

var exampleApi RestApi = &MyExampleApi{}
svc := RestApiAsService(exampleApi, "Example Create", name, request)

errs, err := CallServices(context.TODO(), []Service{svc})

sharedState := &Example{mutex.Lock{}, State: SomeState}
stageNum, errs, err := CallStagedServices(context.TODO(), [][]Service{
    {   // Stage 1
        &DependencyServiceA{SharedState: sharedState},
        &DependencyServiceB{SharedState: sharedState},
        MakeDryRun(&OtherServiceA{SharedState: sharedState}),
        MakeDryRun(&OtherServiceB{SharedState: sharedState}),
    },
    {   // Stage 2 - Executed after all Run's of stage 1 were successful
        &OtherServiceA{SharedState: sharedState},
        &OtherServiceB{SharedState: sharedState},
    },
})