add endpoints for release and logs

api/server/handlers/cluster/get_incident_event_logs.go

@@ -0,0 +1,64 @@
+package cluster
+
+import (
+	"net/http"
+
+	"github.com/porter-dev/porter/api/server/authz"
+	"github.com/porter-dev/porter/api/server/handlers"
+	"github.com/porter-dev/porter/api/server/shared"
+	"github.com/porter-dev/porter/api/server/shared/apierrors"
+	"github.com/porter-dev/porter/api/server/shared/config"
+	"github.com/porter-dev/porter/api/types"
+	porter_agent "github.com/porter-dev/porter/internal/kubernetes/porter_agent/v2"
+	"github.com/porter-dev/porter/internal/models"
+)
+
+type GetIncidentEventLogsHandler struct {
+	handlers.PorterHandlerReadWriter
+	authz.KubernetesAgentGetter
+}
+
+func NewGetIncidentEventLogsHandler(
+	config *config.Config,
+	decoderValidator shared.RequestDecoderValidator,
+	writer shared.ResultWriter,
+) *GetIncidentEventLogsHandler {
+	return &GetIncidentEventLogsHandler{
+		PorterHandlerReadWriter: handlers.NewDefaultPorterHandler(config, decoderValidator, writer),
+		KubernetesAgentGetter:   authz.NewOutOfClusterAgentGetter(config),
+	}
+}
+
+func (c *GetIncidentEventLogsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	cluster, _ := r.Context().Value(types.ClusterScope).(*models.Cluster)
+
+	request := &types.GetIncidentEventLogsRequest{}
+
+	if ok := c.DecodeAndValidate(w, r, request); !ok {
+		return
+	}
+
+	agent, err := c.GetAgent(r, cluster, "")
+
+	if err != nil {
+		c.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+		return
+	}
+
+	// get agent service
+	agentSvc, err := porter_agent.GetAgentService(agent.Clientset)
+
+	if err != nil {
+		c.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+		return
+	}
+
+	logs, err := porter_agent.GetLogs(agent.Clientset, agentSvc, request.LogID)
+
+	if err != nil {
+		c.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+		return
+	}
+
+	c.WriteResult(w, r, logs)
+}

api/server/handlers/cluster/get_incidents.go

@@ -1,7 +1,6 @@
 package cluster
 
 import (
-	"fmt"
 	"net/http"
 
 	"github.com/porter-dev/porter/api/server/authz"
@@ -43,8 +42,6 @@ func (c *GetIncidentsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
 	releaseName := request.ReleaseName
 	namespace := request.Namespace
 
-	fmt.Printf("incidentID: %s\nreleaseName: %s\nnamespace: %s\n", incidentID, releaseName, namespace)
-
 	agent, err := c.GetAgent(r, cluster, "")
 
 	if err != nil {

api/server/router/cluster.go

@@ -975,5 +975,34 @@ func getClusterRoutes(
 		Router:   r,
 	})
 
+	// GET /api/projects/{project_id}/clusters/{cluster_id}/incidents/logs -> cluster.NewGetIncidentsHandler
+	getIncidentEventLogsEndpoint := factory.NewAPIEndpoint(
+		&types.APIRequestMetadata{
+			Verb:   types.APIVerbGet,
+			Method: types.HTTPVerbGet,
+			Path: &types.Path{
+				Parent:       basePath,
+				RelativePath: relPath + "/incidents/logs",
+			},
+			Scopes: []types.PermissionScope{
+				types.UserScope,
+				types.ProjectScope,
+				types.ClusterScope,
+			},
+		},
+	)
+
+	getIncidentEventLogsHandler := cluster.NewGetIncidentEventLogsHandler(
+		config,
+		factory.GetDecoderValidator(),
+		factory.GetResultWriter(),
+	)
+
+	routes = append(routes, &Route{
+		Endpoint: getIncidentEventLogsEndpoint,
+		Handler:  getIncidentEventLogsHandler,
+		Router:   r,
+	})
+
 	return routes, newPath
 }

api/types/cluster.go

@@ -253,3 +253,7 @@ type GetIncidentsRequest struct {
 	ReleaseName string `schema:"release_name"`
 	Namespace   string `schema:"namespace"`
 }
+
+type GetIncidentEventLogsRequest struct {
+	LogID string `schema:"log_id"`
+}

internal/kubernetes/porter_agent/v2/agent_server.go

@@ -80,5 +80,53 @@ func GetIncidentsByReleaseNamespace(
 	service *v1.Service,
 	releaseName, namespace string,
 ) (*IncidentsResponse, error) {
-	return nil, nil
+	resp := clientset.CoreV1().Services(service.Namespace).ProxyGet(
+		"http",
+		service.Name,
+		fmt.Sprintf("%d", service.Spec.Ports[0].Port),
+		fmt.Sprintf("/incidents/namespaces/%s/releases/%s", namespace, releaseName),
+		nil,
+	)
+
+	rawQuery, err := resp.DoRaw(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	incidentsResp := &IncidentsResponse{}
+
+	err = json.Unmarshal(rawQuery, incidentsResp)
+	if err != nil {
+		return nil, err
+	}
+
+	return incidentsResp, nil
+}
+
+func GetLogs(
+	clientset kubernetes.Interface,
+	service *v1.Service,
+	logID string,
+) (*LogsResponse, error) {
+	resp := clientset.CoreV1().Services(service.Namespace).ProxyGet(
+		"http",
+		service.Name,
+		fmt.Sprintf("%d", service.Spec.Ports[0].Port),
+		fmt.Sprintf("/incidents/logs/%s", logID),
+		nil,
+	)
+
+	rawQuery, err := resp.DoRaw(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	logsResp := &LogsResponse{}
+
+	err = json.Unmarshal(rawQuery, logsResp)
+	if err != nil {
+		return nil, err
+	}
+
+	return logsResp, nil
 }

internal/kubernetes/porter_agent/v2/models.go

@@ -36,6 +36,14 @@ type IncidentsResponse struct {
 }
 
 type EventsResponse struct {
-	IncidentID string      `json:"incident_id" form:"required"`
-	Events     []*PodEvent `json:"events" form:"required"`
+	IncidentID    string      `json:"incident_id" form:"required"`
+	ReleaseName   string      `json:"release_name"`
+	LatestState   string      `json:"latest_state"`
+	LatestReason  string      `json:"latest_reason"`
+	LatestMessage string      `json:"latest_message"`
+	Events        []*PodEvent `json:"events" form:"required"`
+}
+
+type LogsResponse struct {
+	Contents string `json:"contents" form:"required"`
 }