Add Java analyzer

cli/azd/cmd/orchestrate.go

@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"github.com/azure/azure-dev/cli/azd/cmd/actions"
+	"github.com/azure/azure-dev/cli/azd/internal"
+	"github.com/azure/azure-dev/cli/azd/pkg/output"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+)
+
+func newOrchestrateFlags(cmd *cobra.Command, global *internal.GlobalCommandOptions) *orchestrateFlags {
+	flags := &orchestrateFlags{}
+	return flags
+}
+
+func newOrchestrateCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "orchestrate",
+		Short: "Orchestrate an existing application. (Beta)",
+	}
+}
+
+type orchestrateFlags struct {
+	global *internal.GlobalCommandOptions
+}
+
+type orchestrateAction struct {
+}
+
+func (action orchestrateAction) Run(ctx context.Context) (*actions.ActionResult, error) {
+	azureYamlFile, err := os.Create("azure.yaml")
+	if err != nil {
+		return nil, fmt.Errorf("creating azure.yaml: %w", err)
+	}
+	defer azureYamlFile.Close()
+
+	files, err := findPomFiles(".")
+	if err != nil {
+		fmt.Println("Error:", err)
+		return nil, fmt.Errorf("find pom files: %w", err)
+	}
+
+	for _, file := range files {
+		if _, err := azureYamlFile.WriteString(file + "\n"); err != nil {
+			return nil, fmt.Errorf("writing azure.yaml: %w", err)
+		}
+	}
+
+	if err := azureYamlFile.Sync(); err != nil {
+		return nil, fmt.Errorf("saving azure.yaml: %w", err)
+	}
+	return nil, nil
+}
+
+func newOrchestrateAction() actions.Action {
+	return &orchestrateAction{}
+}
+
+func getCmdOrchestrateHelpDescription(*cobra.Command) string {
+	return generateCmdHelpDescription("Orchestrate an existing application in your current directory.",
+		[]string{
+			formatHelpNote(
+				fmt.Sprintf("Running %s without flags specified will prompt "+
+					"you to orchestrate using your existing code.",
+					output.WithHighLightFormat("orchestrate"),
+				)),
+		})
+}
+
+func getCmdOrchestrateHelpFooter(*cobra.Command) string {
+	return generateCmdHelpSamplesBlock(map[string]string{
+		"Orchestrate a existing project.": fmt.Sprintf("%s",
+			output.WithHighLightFormat("azd orchestrate"),
+		),
+	})
+}
+
+func findPomFiles(root string) ([]string, error) {
+	var files []string
+	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() && filepath.Base(path) == "pom.xml" {
+			files = append(files, path)
+		}
+		return nil
+	})
+	return files, err
+}

cli/azd/cmd/root.go

@@ -178,6 +178,19 @@ func NewRootCmd(
 		ActionResolver: newLogoutAction,
 	})
 
+	root.Add("orchestrate", &actions.ActionDescriptorOptions{
+		Command:        newOrchestrateCmd(),
+		FlagsResolver:  newOrchestrateFlags,
+		ActionResolver: newOrchestrateAction,
+		HelpOptions: actions.ActionHelpOptions{
+			Description: getCmdOrchestrateHelpDescription,
+			Footer:      getCmdOrchestrateHelpFooter,
+		},
+		GroupingOptions: actions.CommandGroupOptions{
+			RootLevelHelp: actions.CmdGroupConfig,
+		},
+	})
+
 	root.Add("init", &actions.ActionDescriptorOptions{
 		Command:        newInitCmd(),
 		FlagsResolver:  newInitFlags,

cli/azd/internal/appdetect/appdetect.go

@@ -12,6 +12,7 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/azure/azure-dev/cli/azd/internal/appdetect/javaanalyze"
 	"github.com/azure/azure-dev/cli/azd/pkg/exec"
 	"github.com/azure/azure-dev/cli/azd/pkg/tools/dotnet"
 	"github.com/bmatcuk/doublestar/v4"
@@ -131,6 +132,20 @@ func (db DatabaseDep) Display() string {
 	return ""
 }
 
+//type AzureDep string
+
+type AzureDep interface {
+	ResourceDisplay() string
+}
+
+type AzureDepServiceBus struct {
+	Queues []string
+}
+
+func (a AzureDepServiceBus) ResourceDisplay() string {
+	return "Azure Service Bus"
+}
+
 type Project struct {
 	// The language associated with the project.
 	Language Language
@@ -141,6 +156,9 @@ type Project struct {
 	// Experimental: Database dependencies inferred through heuristics while scanning dependencies in the project.
 	DatabaseDeps []DatabaseDep
 
+	// Experimental: Azure dependencies inferred through heuristics while scanning dependencies in the project.
+	AzureDeps []AzureDep
+
 	// The path to the project directory.
 	Path string
 
@@ -243,6 +261,9 @@ func detectUnder(ctx context.Context, root string, config detectConfig) ([]Proje
 		return nil, fmt.Errorf("scanning directories: %w", err)
 	}
 
+	// call the java analyzer
+	projects = analyze(projects)
+
 	return projects, nil
 }
 
@@ -306,3 +327,50 @@ func walkDirectories(path string, fn walkDirFunc) error {
 
 	return nil
 }
+
+func analyze(projects []Project) []Project {
+	result := []Project{}
+	for _, project := range projects {
+		if project.Language == Java {
+			fmt.Printf("Java project [%s] found", project.Path)
+			_javaProjects := javaanalyze.Analyze(project.Path)
+
+			if len(_javaProjects) == 1 {
+				enrichFromJavaProject(_javaProjects[0], &project)
+				result = append(result, project)
+			} else {
+				for _, _project := range _javaProjects {
+					copiedProject := project
+					enrichFromJavaProject(_project, &copiedProject)
+					result = append(result, copiedProject)
+				}
+			}
+		} else {
+			result = append(result, project)
+		}
+	}
+	return result
+}
+
+func enrichFromJavaProject(azureYaml javaanalyze.AzureYaml, project *Project) {
+	// if there is only one project, we can safely assume that it is the main project
+	for _, resource := range azureYaml.Resources {
+		if resource.GetType() == "Azure Storage" {
+			// project.DatabaseDeps = append(project.DatabaseDeps, Db)
+		} else if resource.GetType() == "MySQL" {
+			project.DatabaseDeps = append(project.DatabaseDeps, DbMySql)
+		} else if resource.GetType() == "PostgreSQL" {
+			project.DatabaseDeps = append(project.DatabaseDeps, DbPostgres)
+		} else if resource.GetType() == "MongoDB" {
+			project.DatabaseDeps = append(project.DatabaseDeps, DbMongo)
+		} else if resource.GetType() == "SQL Server" {
+			project.DatabaseDeps = append(project.DatabaseDeps, DbSqlServer)
+		} else if resource.GetType() == "Redis" {
+			project.DatabaseDeps = append(project.DatabaseDeps, DbRedis)
+		} else if resource.GetType() == "Azure Service Bus" {
+			project.AzureDeps = append(project.AzureDeps, AzureDepServiceBus{
+				Queues: resource.(*javaanalyze.ServiceBusResource).Queues,
+			})
+		}
+	}
+}

cli/azd/internal/appdetect/javaanalyze/azure_yaml.go

@@ -0,0 +1,91 @@
+package javaanalyze
+
+type AzureYaml struct {
+	Service         *Service         `json:"service"`
+	Resources       []IResource      `json:"resources"`
+	ServiceBindings []ServiceBinding `json:"serviceBindings"`
+}
+
+type IResource interface {
+	GetName() string
+	GetType() string
+	GetBicepParameters() []BicepParameter
+	GetBicepProperties() []BicepProperty
+}
+
+type Resource struct {
+	Name            string           `json:"name"`
+	Type            string           `json:"type"`
+	BicepParameters []BicepParameter `json:"bicepParameters"`
+	BicepProperties []BicepProperty  `json:"bicepProperties"`
+}
+
+func (r *Resource) GetName() string {
+	return r.Name
+}
+
+func (r *Resource) GetType() string {
+	return r.Type
+}
+
+func (r *Resource) GetBicepParameters() []BicepParameter {
+	return r.BicepParameters
+}
+
+func (r *Resource) GetBicepProperties() []BicepProperty {
+	return r.BicepProperties
+}
+
+type ServiceBusResource struct {
+	Resource
+	Queues                []string `json:"queues"`
+	TopicAndSubscriptions []string `json:"topicAndSubscriptions"`
+}
+
+type BicepParameter struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Type        string `json:"type"`
+}
+
+type BicepProperty struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Type        string `json:"type"`
+}
+
+type ResourceType int32
+
+const (
+	RESOURCE_TYPE_MYSQL         ResourceType = 0
+	RESOURCE_TYPE_AZURE_STORAGE ResourceType = 1
+)
+
+// Service represents a specific service's configuration.
+type Service struct {
+	Name        string        `json:"name"`
+	Path        string        `json:"path"`
+	ResourceURI string        `json:"resourceUri"`
+	Description string        `json:"description"`
+	Environment []Environment `json:"environment"`
+}
+
+type Environment struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
+type ServiceBinding struct {
+	Name        string   `json:"name"`
+	ResourceURI string   `json:"resourceUri"`
+	AuthType    AuthType `json:"authType"`
+}
+
+type AuthType int32
+
+const (
+	// Authentication type not specified.
+	AuthType_SYSTEM_MANAGED_IDENTITY AuthType = 0
+	// Username and Password Authentication.
+	AuthType_USER_PASSWORD AuthType = 1
+)

cli/azd/internal/appdetect/javaanalyze/project_analyzer_java.go

@@ -0,0 +1,41 @@
+package javaanalyze
+
+import "os"
+
+type javaProject struct {
+	springProject springProject
+	mavenProject  mavenProject
+}
+
+func Analyze(path string) []AzureYaml {
+	var result []AzureYaml
+	rules := []rule{
+		&ruleService{},
+		&ruleMysql{},
+		&rulePostgresql{},
+		&ruleMongo{},
+		&ruleRedis{},
+		&ruleStorage{},
+		&ruleServiceBusScsb{},
+	}
+
+	entries, err := os.ReadDir(path)
+	if err == nil {
+		for _, entry := range entries {
+			if "pom.xml" == entry.Name() {
+				mavenProjects, _ := analyzeMavenProject(path)
+
+				for _, mavenProject := range mavenProjects {
+					javaProject := &javaProject{
+						mavenProject:  mavenProject,
+						springProject: analyzeSpringProject(mavenProject.path),
+					}
+					azureYaml, _ := applyRules(javaProject, rules)
+					result = append(result, *azureYaml)
+				}
+			}
+		}
+	}
+
+	return result
+}