98 lines
3.5 KiB
Go
98 lines
3.5 KiB
Go
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
)
|
|
|
|
type harnessSecretServer struct {
|
|
pb.UnimplementedHarnessSecretServiceServer
|
|
*server
|
|
}
|
|
|
|
// harnessOrg derives scope from a live run credential or the authenticated caller.
|
|
func (s *server) harnessOrg(ctx context.Context, credential string) (string, error) {
|
|
if credential == "" {
|
|
return string(org.OrgFromContext(ctx)), nil
|
|
}
|
|
if s.deps.Grants == nil || s.deps.Tasks == nil {
|
|
return "", status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
id, err := s.deps.Grants.taskFor(ctx, credential)
|
|
if err != nil {
|
|
return "", s.deps.Grants.unavailable(ctx, "harnessOrg", err)
|
|
}
|
|
if id == 0 {
|
|
return "", status.Error(codes.Unauthenticated, "invalid task grant")
|
|
}
|
|
t, err := s.deps.Tasks.TaskByID(ctx, id)
|
|
if err != nil {
|
|
return "", mapError(err)
|
|
}
|
|
target := t.OrgOrDefault()
|
|
if scope, ok := org.Scope(ctx); ok && string(scope) != target {
|
|
return "", status.Error(codes.PermissionDenied, "harness secret belongs to another org")
|
|
}
|
|
return target, nil
|
|
}
|
|
|
|
func (s *harnessSecretServer) GetHarnessSecret(ctx context.Context, r *pb.GetHarnessSecretRequest) (*pb.GetHarnessSecretResponse, error) {
|
|
if s.deps.HarnessSecrets == nil {
|
|
return nil, status.Error(codes.Unavailable, "harness secret store unavailable")
|
|
}
|
|
orgID, err := s.harnessOrg(ctx, r.RunCredential)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
secret, err := s.deps.HarnessSecrets.GetHarnessSecret(ctx, orgID, r.Service)
|
|
if err != nil {
|
|
return nil, s.logErr("GetHarnessSecret", err)
|
|
}
|
|
return &pb.GetHarnessSecretResponse{Secret: harnessSecretProto(secret), Org: orgID}, nil
|
|
}
|
|
|
|
func (s *harnessSecretServer) PutHarnessSecret(ctx context.Context, r *pb.PutHarnessSecretRequest) (*pb.PutHarnessSecretResponse, error) {
|
|
if s.deps.HarnessSecrets == nil {
|
|
return nil, status.Error(codes.Unavailable, "harness secret store unavailable")
|
|
}
|
|
value := harnessSecretValue(r.Secret)
|
|
orgID, err := s.harnessOrg(ctx, r.RunCredential)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value.Org = orgID
|
|
if err := s.deps.HarnessSecrets.PutHarnessSecret(ctx, value); err != nil {
|
|
return nil, s.logErr("PutHarnessSecret", err)
|
|
}
|
|
return &pb.PutHarnessSecretResponse{}, nil
|
|
}
|
|
|
|
// GetHarnessSecret returns the stored OAuth token set for an org/service
|
|
// credential binding, or storecontract.ErrHarnessSecretNotFound.
|
|
func (c *Client) GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error) {
|
|
r, err := c.harnessSecret.GetHarnessSecret(ctx, &pb.GetHarnessSecretRequest{Service: service, RunCredential: harnesssecret.RunCredential(ctx)})
|
|
if err != nil {
|
|
return harnesssecret.Secret{}, unmapError(err)
|
|
}
|
|
if r.Org != org {
|
|
return harnesssecret.Secret{}, status.Error(codes.PermissionDenied, "harness secret belongs to another org")
|
|
}
|
|
value := harnessSecretValue(r.Secret)
|
|
value.Org = r.Org
|
|
return value, nil
|
|
}
|
|
|
|
// PutHarnessSecret upserts an org/service credential binding's OAuth token
|
|
// set, called by the setup terminal's first capture and by the egress
|
|
// proxy's every refresh.
|
|
func (c *Client) PutHarnessSecret(ctx context.Context, s harnesssecret.Secret) error {
|
|
_, err := c.harnessSecret.PutHarnessSecret(ctx, &pb.PutHarnessSecretRequest{Secret: harnessSecretProto(s), RunCredential: harnesssecret.RunCredential(ctx)})
|
|
return unmapError(err)
|
|
}
|