Merge branch 'hotfix/v1.0.33-migrate-apiv1-to-apiv2'

client/projects.go

@@ -45,7 +45,7 @@ func (c *Client) ListProjects(name, repo string) ([]Project, error) {
 
 	klog.Debug("retrieving project list...")
 
-	req, err := c.newRequest("GET", "/api/v1/projects", nil)
+	req, err := c.newRequest("GET", "/api/v2/projects", nil)
 	if err != nil {
 		return projects, err
 	}
@@ -142,20 +142,19 @@ func (c *Client) CreateProject(pd ProjectDetail) (*Project, error) {
 }
 
 type ReleaseStatus struct {
-	Status  string             `json:"status" bson:"status"`
-	SAST    PlaybookTypeDetail `json:"sast" bson:"sast"`
-	DAST    PlaybookTypeDetail `json:"dast" bson:"dast"`
-	PENTEST PlaybookTypeDetail `json:"pentest" bson:"pentest"`
-	IAST    PlaybookTypeDetail `json:"iast" bson:"iast"`
-	SCA     PlaybookTypeDetail `json:"sca" bson:"sca"`
-	CS      PlaybookTypeDetail `json:"cs" bson:"cs"`
-	IAC     PlaybookTypeDetail `json:"iac" bson:"iac"`
+	Status  string             `json:"status"`
+	SAST    PlaybookTypeDetail `json:"sast"`
+	DAST    PlaybookTypeDetail `json:"dast"`
+	PENTEST PlaybookTypeDetail `json:"pentest"`
+	IAST    PlaybookTypeDetail `json:"iast"`
+	SCA     PlaybookTypeDetail `json:"sca"`
+	CS      PlaybookTypeDetail `json:"cs"`
+	IAC     PlaybookTypeDetail `json:"iac"`
+	MAST    PlaybookTypeDetail `json:"mast"`
 }
 
 type PlaybookTypeDetail struct {
-	Tool   string `json:"tool" bson:"tool"`
 	Status string `json:"status" bson:"status"`
-	Manual bool   `json:"manual" bson:"manual"`
 	ScanID string `json:"scan_id,omitempty" bson:"scan_id"`
 }
 
@@ -164,7 +163,7 @@ func (c *Client) ReleaseStatus(project, branch string) (*ReleaseStatus, error) {
 		return nil, errors.New("missing project id or name")
 	}
 
-	path := fmt.Sprintf("/api/v1/projects/%s/release", project)
+	path := fmt.Sprintf("/api/v2/projects/%s/release", project)
 
 	req, err := c.newRequest("GET", path, nil)
 	if err != nil {

client/scanners.go

@@ -15,6 +15,30 @@ import (
 	"github.com/google/go-querystring/query"
 )
 
+type ScannerType string
+
+const (
+	ScannerTypeSAST ScannerType = "sast"
+	ScannerTypeDAST ScannerType = "dast"
+	ScannerTypeSCA  ScannerType = "sca"
+	ScannerTypeCS   ScannerType = "cs"
+	ScannerTypeIAC  ScannerType = "iac"
+	ScannerTypeIAST ScannerType = "iast"
+	ScannerTypeCSPM ScannerType = "cspm"
+	ScannerTypeMAST ScannerType = "mast"
+)
+
+func (s ScannerType) String() string {
+	return string(s)
+}
+
+func ScannerTypes() []ScannerType {
+	return []ScannerType{
+		ScannerTypeSAST, ScannerTypeDAST, ScannerTypeSCA, ScannerTypeCS,
+		ScannerTypeIAC, ScannerTypeIAST, ScannerTypeCSPM, ScannerTypeMAST,
+	}
+}
+
 type (
 	ScannersSearchParams struct {
 		Types  string `url:"types"`
@@ -117,17 +141,45 @@ const (
 	ScannerLabelCreatableOnTool = "creatable-on-tool"
 )
 
+type ListActiveScannersInput struct {
+	Types  []ScannerType
+	Labels string
+	Name   string
+	Limit  int
+}
+
+func (i *ListActiveScannersInput) prepareRequestQueryParameters() ScannersSearchParams {
+	var scannerTypes = make([]string, 0)
+
+	if len(i.Types) == 0 {
+		for _, t := range ScannerTypes() {
+			scannerTypes = append(scannerTypes, t.String())
+		}
+	} else {
+		for _, t := range i.Types {
+			scannerTypes = append(scannerTypes, t.String())
+		}
+	}
+
+	return ScannersSearchParams{
+		Types:  strings.Join(scannerTypes, ","),
+		Labels: i.Labels,
+		Name:   i.Name,
+		Limit:  i.Limit,
+	}
+}
+
 // ListActiveScanners returns a list of active scanners
-func (c *Client) ListActiveScanners(params *ScannersSearchParams) (*ScannersResponse, error) {
+func (c *Client) ListActiveScanners(input *ListActiveScannersInput) (*ScannersResponse, error) {
 	klog.Debugf("retrieving active scanners")
 
-	path := fmt.Sprintf("/api/v1/scanners/active")
+	path := fmt.Sprintf("/api/v2/scanners/active")
 	req, err := c.newRequest(http.MethodGet, path, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	v, err := query.Values(params)
+	v, err := query.Values(input.prepareRequestQueryParameters())
 	if err != nil {
 		return nil, err
 	}
@@ -150,7 +202,9 @@ func (c *Client) ListActiveScanners(params *ScannersSearchParams) (*ScannersResp
 func (c *Client) IsValidTool(tool string) bool {
 	klog.Debugf("validating given tool name [%s]", tool)
 
-	scanners, err := c.ListActiveScanners(&ScannersSearchParams{Name: tool})
+	scanners, err := c.ListActiveScanners(&ListActiveScannersInput{
+		Name: tool,
+	})
 	if err != nil {
 		klog.Debugf("failed to get active tools: %v", err)
 		return false

client/scans.go

@@ -24,6 +24,15 @@ import (
 )
 
 type (
+	ImageScanParams struct {
+		Project     string `json:"project"`
+		Tool        string `json:"tool"`
+		Branch      string `json:"branch"`
+		Image       string `json:"image"`
+		MetaData    string `json:"meta_data"`
+		Environment string `json:"environment"`
+	}
+
 	ScanDetail struct {
 		ID          string     `json:"id"`
 		Name        string     `json:"name"`
@@ -156,7 +165,7 @@ func (c *Client) CreateNewScan(scan *Scan) (string, error) {
 
 func (c *Client) RestartScanByScanID(id string) (string, error) {
 	klog.Debug("starting scan by scan_id")
-	path := fmt.Sprintf("/api/v1/scans/%s/restart", id)
+	path := fmt.Sprintf("/api/v2/scans/%s/restart", id)
 	req, err := c.newRequest(http.MethodGet, path, nil)
 	if err != nil {
 		return "", err
@@ -180,7 +189,7 @@ func (c *Client) RestartScanWithOption(id string, opt *ScanPROptions) (string, e
 		return "", errors.New("missing scan options")
 	}
 
-	path := fmt.Sprintf("/api/v1/scans/%s/restart_with_option", id)
+	path := fmt.Sprintf("/api/v2/scans/%s/restart_with_option", id)
 	req, err := c.newRequest(http.MethodPost, path, opt)
 	if err != nil {
 		return "", err
@@ -207,19 +216,30 @@ func (c *Client) RestartScanWithOption(id string, opt *ScanPROptions) (string, e
 	return rsr.Event, nil
 }
 
-type ImageScanParams struct {
-	Project     string `json:"project"`
-	Tool        string `json:"tool"`
-	Branch      string `json:"branch"`
-	Image       string `json:"image"`
-	MetaData    string `json:"meta_data"`
-	Environment string `json:"environment"`
+type ScanByImageInput struct {
+	Project     string
+	Tool        string
+	Branch      string
+	Image       string
+	MetaData    string
+	Environment string
+}
+
+func (i *ScanByImageInput) prepareRequestQueryParameters() ImageScanParams {
+	return ImageScanParams{
+		Project:     i.Project,
+		Tool:        i.Tool,
+		Branch:      i.Branch,
+		Image:       i.Image,
+		MetaData:    i.MetaData,
+		Environment: i.Environment,
+	}
 }
 
-func (c *Client) ScanByImage(pr *ImageScanParams) (string, error) {
-	path := "/api/v1/scans/image"
+func (c *Client) ScanByImage(pr *ScanByImageInput) (string, error) {
+	path := "/api/v2/scans/image"
 
-	req, err := c.newRequest(http.MethodPost, path, pr)
+	req, err := c.newRequest(http.MethodPost, path, pr.prepareRequestQueryParameters())
 	if err != nil {
 		return "", fmt.Errorf("failed to create HTTP request: %w", err)
 	}
@@ -247,7 +267,7 @@ type ImportForm map[string]string
 func (c *Client) ImportScanResult(file string, form ImportForm) (string, error) {
 	klog.Debugf("importing scan results using the file:%s", file)
 
-	path := "/api/v1/scans/import"
+	path := "/api/v2/scans/import"
 	rel := &url.URL{Path: path}
 	u := c.BaseURL.ResolveReference(rel)
 
@@ -312,7 +332,7 @@ func (c *Client) ListScans(project string, params *ScanSearchParams) ([]ScanDeta
 	klog.Debugf("retrieving scans of the project: %s", project)
 
 	scans := make([]ScanDetail, 0)
-	path := fmt.Sprintf("/api/v1/projects/%s/scans", project)
+	path := fmt.Sprintf("/api/v2/projects/%s/scans", project)
 	req, err := c.newRequest(http.MethodGet, path, nil)
 	if err != nil {
 		return scans, err
@@ -325,7 +345,7 @@ func (c *Client) ListScans(project string, params *ScanSearchParams) ([]ScanDeta
 	req.URL.RawQuery = v.Encode()
 
 	type getProjectScansResponse struct {
-		Scans []ScanDetail `json:"data"`
+		Scans []ScanDetail `json:"scans"`
 		Total int          `json:"total"`
 	}
 	var ps getProjectScansResponse
@@ -360,7 +380,7 @@ func (c *Client) FindScan(project string, params *ScanSearchParams) (*ScanDetail
 }
 
 func (c *Client) FindScanByID(id string) (*ScanDetail, error) {
-	path := fmt.Sprintf("/api/v1/scans/%s", id)
+	path := fmt.Sprintf("/api/v2/scans/%s", id)
 	req, err := c.newRequest(http.MethodGet, path, nil)
 	if err != nil {
 		return nil, err
@@ -400,7 +420,7 @@ func (c *Client) GetScanStatus(eventId string) (*Event, error) {
 }
 
 func (c *Client) GetLastResults(id string) (map[string]*ResultSet, error) {
-	path := fmt.Sprintf("/api/v1/scans/%s/last_results", id)
+	path := fmt.Sprintf("/api/v2/scans/%s/last_results", id)
 	req, err := c.newRequest(http.MethodGet, path, nil)
 	if err != nil {
 		return nil, err

client/team.go

@@ -24,7 +24,7 @@ func (c *Client) CreateTeam(teamName, responsible string) error {
 		},
 	}
 
-	req, err := c.newRequest(http.MethodPost, "/api/v3/teams", team)
+	req, err := c.newRequest(http.MethodPost, "/api/v2/teams", team)
 	if err != nil {
 		return err
 	}

cmd/listScanners.go

@@ -18,10 +18,15 @@ var listScannersCmd = &cobra.Command{
 			qwe(ExitCodeError, err, "could not initialize Kondukto client")
 		}
 
-		scannerType := cmd.Flag("type").Value.String()
+		var scannerTypes []client.ScannerType
+		var scannerTypeFlag = cmd.Flag("type").Value.String()
+		if scannerTypeFlag != "" {
+			scannerTypes = []client.ScannerType{client.ScannerType(scannerTypeFlag)}
+		}
+
 		scannerLabels := cmd.Flag("labels").Value.String()
-		activeScanners, err := c.ListActiveScanners(&client.ScannersSearchParams{
-			Types:  scannerType,
+		activeScanners, err := c.ListActiveScanners(&client.ListActiveScannersInput{
+			Types:  scannerTypes,
 			Labels: scannerLabels,
 		})
 		if err != nil {

cmd/project.go

@@ -29,11 +29,11 @@ const (
 	VCSToolBitbucket = "bitbucket"
 	// VCSToolBitbucketServer represents the Bitbucket server VCS tool name
 	VCSToolBitbucketServer = "bitbucketserver"
-	// VCSToolGitHub represents the Github VCS tool name
+	// VCSToolGitHub represents the GitHub VCS tool name
 	VCSToolGitHub = "github"
-	// VCSToolGitLab represents the Gitlab Cloud VCS tool name
+	// VCSToolGitLabCloud represents the Gitlab Cloud VCS tool name
 	VCSToolGitLabCloud = "gitlabcloud"
-	// VCSToolGitLab represents the Gitlab On-Prem VCS tool name
+	// VCSToolGitLabOnPrem represents the Gitlab On-Prem VCS tool name
 	VCSToolGitLabOnPrem = "gitlabonprem"
 	// VCSToolGit represents the Git VCS tool name
 	VCSToolGit = "git"

cmd/release.go

@@ -65,9 +65,9 @@ func releaseRootCommand(cmd *cobra.Command, _ []string) {
 	}
 
 	releaseCriteriaRows := []Row{
-		{Columns: []string{"STATUS", "SAST", "DAST", "PENTEST", "IAST", "SCA", "CS", "IAC"}},
-		{Columns: []string{"------", "----", "----", "-------", "----", "---", "--", "---"}},
-		{Columns: []string{rs.Status, rs.SAST.Status, rs.DAST.Status, rs.PENTEST.Status, rs.IAST.Status, rs.SCA.Status, rs.CS.Status, rs.IAC.Status}},
+		{Columns: []string{"STATUS", "SAST", "DAST", "PENTEST", "IAST", "SCA", "CS", "IAC", "MAST"}},
+		{Columns: []string{"------", "----", "----", "-------", "----", "---", "--", "---", "----"}},
+		{Columns: []string{rs.Status, rs.SAST.Status, rs.DAST.Status, rs.PENTEST.Status, rs.IAST.Status, rs.SCA.Status, rs.CS.Status, rs.IAC.Status, rs.MAST.Status}},
 	}
 	TableWriter(releaseCriteriaRows...)
 
@@ -106,7 +106,12 @@ func releaseRootCommand(cmd *cobra.Command, _ []string) {
 		qwm(ExitCodeError, "failed to parse iac flag")
 	}
 
-	isSpecific := sast || dast || pentest || iast || sca || cs || iac
+	mast, err := cmd.Flags().GetBool("mast")
+	if err != nil {
+		qwm(ExitCodeError, "failed to parse mast flag")
+	}
+
+	isSpecific := sast || dast || pentest || iast || sca || cs || iac || mast
 
 	var spesificMap = make(map[string]bool, 0)
 	spesificMap["SAST"] = sast
@@ -116,6 +121,7 @@ func releaseRootCommand(cmd *cobra.Command, _ []string) {
 	spesificMap["SCA"] = sca
 	spesificMap["CS"] = cs
 	spesificMap["IAC"] = iac
+	spesificMap["MAST"] = mast
 
 	isReleaseFailed(rs, isSpecific, spesificMap)
 }
@@ -150,6 +156,9 @@ func isReleaseFailed(release *client.ReleaseStatus, isSpecific bool, specificMap
 	if release.IAC.Status == statusFail {
 		failedScans["IAC"] = release.IAC.ScanID
 	}
+	if release.MAST.Status == statusFail {
+		failedScans["MAST"] = release.MAST.ScanID
+	}
 
 	if verbose {
 		c, err := client.New()

cmd/scan.go

@@ -248,7 +248,7 @@ func (s *Scan) scanByImage() (string, error) {
 	if image == "" {
 		return "", errors.New("image name is required")
 	}
-	var pr = &client.ImageScanParams{
+	var pr = &client.ScanByImageInput{
 		Project:     project.ID,
 		Tool:        tool,
 		Branch:      branch,
@@ -1025,7 +1025,7 @@ func (s *Scan) checkForRescanOnlyTool() (bool, *client.ScannerInfo, error) {
 	if err != nil || name == "" {
 		return false, nil, errors.New("missing require tool flag")
 	}
-	scanners, err := s.client.ListActiveScanners(&client.ScannersSearchParams{Name: name, Limit: 1})
+	scanners, err := s.client.ListActiveScanners(&client.ListActiveScannersInput{Name: name, Limit: 1})
 	if err != nil {
 		return false, nil, fmt.Errorf("failed to get active scanners: %w", err)
 	}
@@ -1237,6 +1237,9 @@ func isScanReleaseFailed(scan *client.ScanDetail, release *client.ReleaseStatus,
 	if release.IAC.Status == statusFail {
 		failedScans["IAC"] = scan.ID
 	}
+	if release.MAST.Status == statusFail {
+		failedScans["MAST"] = scan.ID
+	}
 
 	if breakByScannerType {
 		scannerType := strings.ToUpper(scan.ScannerType)
@@ -1449,8 +1452,8 @@ func appendKeyToParamsMap(key string, custom client.Custom, parsedValue interfac
 		custom.Params[key0] = key0map
 
 	default:
-		klog.Debugf("unsupportted key: [%s]", key)
-		qwm(ExitCodeError, "unsupportted key, key can only contain one or two dots")
+		klog.Debugf("unsupported key: [%s]", key)
+		qwm(ExitCodeError, "unsupported key, key can only contain one or two dots")
 	}
 	return custom
 }