initial changes

Author: skshetry

api/swagger.yml

@@ -5597,6 +5597,46 @@ paths:
         default:
           $ref: "#/components/responses/ServerError"
 
+  /repositories/{repository}/refs/{ref}/actions/{action}/trigger:
+    post:
+      tags:
+        - actions
+      operationId: triggerAction
+      summary: manually trigger an action
+      parameters:
+        - in: path
+          name: repository
+          required: true
+          schema:
+            type: string
+        - in: path
+          name: ref
+          required: true
+          schema:
+            type: string
+        - in: path
+          name: action
+          required: true
+          schema:
+            type: string
+      responses:
+        200:
+          description: action run result
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ActionRun"
+        400:
+          $ref: "#/components/responses/BadRequest"
+        401:
+          $ref: "#/components/responses/Unauthorized"
+        404:
+          $ref: "#/components/responses/NotFound"
+        420:
+          description: too many requests
+        default:
+          $ref: "#/components/responses/ServerError"
+
   /repositories/{repository}/metadata/object/{type}/{object_id}:
     parameters:
       - in: path

pkg/actions/action.go

@@ -84,7 +84,10 @@ func isEventSupported(event graveler.EventType) bool {
 		graveler.EventTypePreDeleteTag,
 		graveler.EventTypePostDeleteTag,
 		graveler.EventTypePreRevert,
-		graveler.EventTypePostRevert:
+		graveler.EventTypePostRevert,
+		graveler.EventTypePreCherryPick,
+		graveler.EventTypePostCherryPick,
+		graveler.EventTypeManualTrigger:
 		return true
 	}
 	return false

pkg/actions/service.go

@@ -16,6 +16,7 @@ import (
 	"github.com/hashicorp/go-multierror"
 	"github.com/treeverse/lakefs/pkg/actions/lua/hook"
 	"github.com/treeverse/lakefs/pkg/auth"
+	"github.com/treeverse/lakefs/pkg/catalog"
 	"github.com/treeverse/lakefs/pkg/graveler"
 	"github.com/treeverse/lakefs/pkg/kv"
 	"github.com/treeverse/lakefs/pkg/logging"
@@ -210,6 +211,7 @@ type Service interface {
 	GetTaskResult(ctx context.Context, repositoryID string, runID string, hookRunID string) (*TaskResult, error)
 	ListRunResults(ctx context.Context, repositoryID string, branchID, commitID string, after string) (RunResultIterator, error)
 	ListRunTaskResults(ctx context.Context, repositoryID string, runID string, after string) (TaskResultIterator, error)
+	TriggerAction(ctx context.Context, repository *catalog.Repository, ref string, actionName string) (*RunResult, error)
 	graveler.HooksHandler
 }
 
@@ -606,6 +608,96 @@ func (s *StoreService) PostCherryPickHook(ctx context.Context, record graveler.H
 	return nil
 }
 
+func (s *StoreService) TriggerAction(ctx context.Context, repository *catalog.Repository, ref string, actionName string) (*RunResult, error) {
+	if !s.cfg.Enabled {
+		logging.FromContext(ctx).WithField("repository", repository.Name).Debug("Hooks are disabled, skipping manual trigger")
+		return nil, fmt.Errorf("actions are disabled")
+	}
+
+	// Construct graveler.RepositoryRecord from catalog.Repository
+	repoRecord := &graveler.RepositoryRecord{
+		RepositoryID: graveler.RepositoryID(repository.Name),
+		Repository: &graveler.Repository{
+			StorageID:        graveler.StorageID(repository.StorageID),
+			StorageNamespace: graveler.StorageNamespace(repository.StorageNamespace),
+			CreationDate:     repository.CreationDate,
+			DefaultBranchID:  graveler.BranchID(repository.DefaultBranch),
+			State:           graveler.RepositoryState_ACTIVE,
+			InstanceUID:     "", // Not available from catalog API
+			ReadOnly:        repository.ReadOnly,
+		},
+	}
+
+	runID := s.NewRunID()
+	
+	// Create hook record for manual trigger with all required fields
+	record := graveler.HookRecord{
+		RunID:      runID,
+		EventType:  graveler.EventTypeManualTrigger,
+		Repository: repoRecord,
+		SourceRef:  graveler.Ref(ref),
+		BranchID:   graveler.BranchID(ref), // For manual triggers, we use the ref as branch
+		CommitID:   graveler.CommitID(""), // Empty for manual triggers
+		TagID:      graveler.TagID(""), // Empty for manual triggers
+		MergeSource: graveler.Ref(""), // Empty for manual triggers
+		Commit: graveler.Commit{
+			Message:      "Manual trigger",
+			MetaRangeID:  graveler.MetaRangeID(""),
+			CreationDate: time.Now(),
+			Version:      graveler.CommitVersion(1),
+			Metadata:     map[string]string{},
+			Parents:      []graveler.CommitID{},
+		},
+	}
+
+	// Load actions from the repository
+	actions, err := LoadActions(ctx, s.Source, record)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load actions: %w", err)
+	}
+
+	// Filter actions for manual trigger with specific action name
+	var matchedActions []*Action
+	for _, action := range actions {
+		// Check if action has manual-trigger event and matches the specified action name
+		if actionOn, ok := action.On[graveler.EventTypeManualTrigger]; ok && action.Name == actionName {
+			// For manual triggers, we don't need to check branches since they're triggered explicitly
+			_ = actionOn // actionOn might be nil, which is fine for manual triggers
+			matchedActions = append(matchedActions, action)
+		}
+	}
+
+	if len(matchedActions) == 0 {
+		return nil, fmt.Errorf("no action named '%s' with manual-trigger found", actionName)
+	}
+
+	// Allocate and run tasks
+	tasks, err := s.allocateTasks(runID, matchedActions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to allocate tasks: %w", err)
+	}
+
+	runErr := s.runTasks(ctx, record, tasks)
+
+	// Save run information
+	err = s.saveRunInformation(ctx, record, tasks)
+	if err != nil {
+		return nil, fmt.Errorf("failed to save run information: %w", err)
+	}
+
+	// Return the run result
+	if runErr != nil {
+		// Return the run result even if there was an error, so caller can see what failed
+		runResult, getErr := s.GetRunResult(ctx, string(repoRecord.RepositoryID), runID)
+		if getErr != nil {
+			return nil, fmt.Errorf("action failed and could not retrieve run result: %w", runErr)
+		}
+		return runResult, runErr
+	}
+
+	return s.GetRunResult(ctx, string(repoRecord.RepositoryID), runID)
+}
+
 func (s *StoreService) NewRunID() string {
 	return s.idGen.NewRunID()
 }

pkg/api/controller.go

@@ -86,6 +86,7 @@ type actionsHandler interface {
 	GetTaskResult(ctx context.Context, repositoryID, runID, hookRunID string) (*actions.TaskResult, error)
 	ListRunResults(ctx context.Context, repositoryID, branchID, commitID, after string) (actions.RunResultIterator, error)
 	ListRunTaskResults(ctx context.Context, repositoryID, runID, after string) (actions.TaskResultIterator, error)
+	TriggerAction(ctx context.Context, repository *catalog.Repository, ref, actionName string) (*actions.RunResult, error)
 }
 
 type Migrator interface {
@@ -2703,6 +2704,50 @@ func (c *Controller) GetRun(w http.ResponseWriter, r *http.Request, repository,
 	writeResponse(w, r, http.StatusOK, response)
 }
 
+func (c *Controller) TriggerAction(w http.ResponseWriter, r *http.Request, repository, refParam, action string) {
+	if !c.authorize(w, r, permissions.Node{
+		Permission: permissions.Permission{
+			Action:   permissions.TriggerActionsAction,
+			Resource: permissions.RepoArn(repository),
+		},
+	}) {
+		return
+	}
+	ctx := r.Context()
+	c.LogAction(ctx, "actions_trigger", r, repository, refParam, "")
+
+	// Get repository information
+	repo, err := c.Catalog.GetRepository(ctx, repository)
+	if c.handleAPIError(ctx, w, r, err) {
+		return
+	}
+
+	// Trigger the action
+	runResult, err := c.Actions.TriggerAction(ctx, repo, refParam, action)
+	if c.handleAPIError(ctx, w, r, err) {
+		return
+	}
+
+	// Convert to API response format
+	var status string
+	if runResult.Passed {
+		status = actionStatusCompleted
+	} else {
+		status = actionStatusFailed
+	}
+	
+	response := apigen.ActionRun{
+		RunId:     runResult.RunID,
+		EventType: runResult.EventType,
+		StartTime: runResult.StartTime,
+		EndTime:   &runResult.EndTime,
+		Status:    status,
+		Branch:    runResult.BranchID,
+		CommitId:  runResult.CommitID,
+	}
+	writeResponse(w, r, http.StatusOK, response)
+}
+
 func (c *Controller) ListRunHooks(w http.ResponseWriter, r *http.Request, repository, runID string, params apigen.ListRunHooksParams) {
 	if !c.authorize(w, r, permissions.Node{
 		Permission: permissions.Permission{

pkg/graveler/hooks_handler.go

@@ -27,6 +27,7 @@ const (
 	EventTypePostRevert       EventType = "post-revert"
 	EventTypePreCherryPick    EventType = "pre-cherry-pick"
 	EventTypePostCherryPick   EventType = "post-cherry-pick"
+	EventTypeManualTrigger    EventType = "manual-trigger"
 
 	UnixYear3000 = 32500915200
 )

pkg/permissions/actions.gen.go

@@ -65,6 +65,7 @@ const (
 	DeleteUserExternalPrincipalAction         = "auth:DeleteUserExternalPrincipal"
 	ReadExternalPrincipalAction               = "auth:ReadExternalPrincipal"
 	ReadActionsAction                         = "ci:ReadAction"
+	TriggerActionsAction                      = "ci:TriggerAction"
 	PrepareGarbageCollectionCommitsAction     = "retention:PrepareGarbageCollectionCommits"
 	GetGarbageCollectionRulesAction           = "retention:GetGarbageCollectionRules"
 	SetGarbageCollectionRulesAction           = "retention:SetGarbageCollectionRules"