[DEVHAS-418]add dockerfile as an alternate name for Dockerfile

cdq-analysis/pkg/detect.go

@@ -122,30 +122,31 @@
 							}
 						}
 					}
-				} else if f.Name() == DockerfileName {
-					// Check for Dockerfile
+				} else if f.Name() == DockerfileName || f.Name() == AlternateDockerfileName {
+					// Check for Dockerfile or dockerfile
 					// NOTE: if a Dockerfile is named differently, for example, Dockerfile.jvm;
 					// thats ok. As we finish iterating through all the files in the localpath
 					// we will read the devfile to ensure a Dockerfile has been referenced.
 					// However, if a Dockerfile is named differently and not referenced in the devfile
 					// it will go undetected
-					dockerfileContextMapFromRepo[context] = DockerfileName
+					dockerfileContextMapFromRepo[context] = f.Name()
 					isDockerfilePresent = true
 				} else if f.Name() == ContainerfileName {
 					// Check for Containerfile
 					dockerfileContextMapFromRepo[context] = ContainerfileName
 					isDockerfilePresent = true
 				} else if f.IsDir() && (f.Name() == DockerDir || f.Name() == HiddenDockerDir || f.Name() == BuildDir) {
 					// Check for docker/Dockerfile, .docker/Dockerfile and build/Dockerfile
+					// OR docker/dockerfile, .docker/dockerfile and build/dockerfile
 					// OR docker/Containerfile, .docker/Containerfile and build/Containerfile
 					dirName := f.Name()
 					dirPath := path.Join(curPath, dirName)
 					files, err := os.ReadDir(dirPath)
 					if err != nil {
 						return nil, nil, nil, nil, err
 					}
 					for _, f := range files {
-						if f.Name() == DockerfileName || f.Name() == ContainerfileName {
+						if f.Name() == DockerfileName || f.Name() == AlternateDockerfileName || f.Name() == ContainerfileName {
 							dockerfileContextMapFromRepo[context] = path.Join(dirName, f.Name())
 							isDockerfilePresent = true
 						}
@@ -170,8 +171,8 @@
 	}
 
 	if len(devfilesURLMapFromRepo) == 0 && len(devfileMapFromRepo) == 0 && len(dockerfileContextMapFromRepo) == 0 {
 		// if we didnt find any devfile or Dockerfile we should return an err
 		log.Info(fmt.Sprintf("no devfile or Dockerfile found in the specified location %s", localpath))
 	}
 
 	return devfileMapFromRepo, devfilesURLMapFromRepo, dockerfileContextMapFromRepo, componentPortsMapFromRepo, err
@@ -256,9 +257,9 @@
 			if detectedPorts != nil && !reflect.DeepEqual(detectedPorts, []int{}) {
 				componentPortsMapFromRepo[context] = detectedPorts
 			}
 		} else {
 			log.Info(fmt.Sprintf("failed to detect port from context: %v, error: %v", context, err))
 		}
 	}
 	return nil
 }

cdq-analysis/pkg/devfile.go

@@ -34,24 +34,29 @@
 )
 
 const (
-	DevfileName       = "devfile.yaml"
-	HiddenDevfileName = ".devfile.yaml"
-	HiddenDevfileDir  = ".devfile"
-	DockerfileName    = "Dockerfile"
-	ContainerfileName = "Containerfile"
-	HiddenDockerDir   = ".docker"
-	DockerDir         = "docker"
-	BuildDir          = "build"
+	DevfileName             = "devfile.yaml"
+	HiddenDevfileName       = ".devfile.yaml"
+	HiddenDevfileDir        = ".devfile"
+	DockerfileName          = "Dockerfile"
+	AlternateDockerfileName = "dockerfile"
+	ContainerfileName       = "Containerfile"
+	HiddenDockerDir         = ".docker"
+	DockerDir               = "docker"
+	BuildDir                = "build"
 
 	Devfile                = DevfileName                                // devfile.yaml
 	HiddenDevfile          = HiddenDevfileName                          // .devfile.yaml
 	HiddenDirDevfile       = HiddenDevfileDir + "/" + DevfileName       // .devfile/devfile.yaml
 	HiddenDirHiddenDevfile = HiddenDevfileDir + "/" + HiddenDevfileName // .devfile/.devfile.yaml
 
-	Dockerfile          = DockerfileName                         // Dockerfile
-	HiddenDirDockerfile = HiddenDockerDir + "/" + DockerfileName // .docker/Dockerfile
-	DockerDirDockerfile = DockerDir + "/" + DockerfileName       // docker/Dockerfile
-	BuildDirDockerfile  = BuildDir + "/" + DockerfileName        // build/Dockerfile
+	Dockerfile                   = DockerfileName                                  // Dockerfile
+	HiddenDirDockerfile          = HiddenDockerDir + "/" + DockerfileName          // .docker/Dockerfile
+	DockerDirDockerfile          = DockerDir + "/" + DockerfileName                // docker/Dockerfile
+	BuildDirDockerfile           = BuildDir + "/" + DockerfileName                 // build/Dockerfile
+	AlternateDockerfile          = AlternateDockerfileName                         // dockerfile
+	HiddenDirAlternateDockerfile = HiddenDockerDir + "/" + AlternateDockerfileName // .docker/dockerfile
+	DockerDirAlternateDockerfile = DockerDir + "/" + AlternateDockerfileName       // docker/dockerfile
+	BuildDirAlternateDockerfile  = BuildDir + "/" + AlternateDockerfileName        // build/dockerfile
 
 	Containerfile          = ContainerfileName                         // Containerfile
 	HiddenDirContainerfile = HiddenDockerDir + "/" + ContainerfileName // .docker/Containerfile
@@ -104,8 +109,8 @@
 				switch merr.Errors[i].(type) {
 				case *devfileValidation.MissingDefaultCmdWarning:
 					log.Info(fmt.Sprintf("devfile is missing default command, found a warning: %v", merr.Errors[i]))
 				default:
 					newErr = multierror.Append(newErr, merr.Errors[i])
 				}
 			}
 		} else {
@@ -120,13 +125,13 @@
 	}
 	deployCompMap, err := parser.GetDeployComponents(devfileData)
 	if err != nil {
 		log.Error(err, fmt.Sprintf("failed to get deploy components from %s", URL))
 		return shouldIgnoreDevfile, nil, fmt.Errorf(fmt.Sprintf("err: %v, failed to get deploy components from %s", err, URL))
 	}
 	devfileBytes, err = yaml.Marshal(devfileData)
 	if err != nil {
 		return shouldIgnoreDevfile, nil, err
 	}
 	kubeCompFilter := common.DevfileOptions{
 		ComponentOptions: common.ComponentOptions{
 			ComponentType: v1alpha2.KubernetesComponentType,
@@ -134,10 +139,10 @@
 	}
 	kubeComp, err := devfileData.GetComponents(kubeCompFilter)
 	if err != nil {
 		log.Error(err, fmt.Sprintf("failed to get kubernetes component from %s", URL))
 		shouldIgnoreDevfile = true
 		return shouldIgnoreDevfile, nil, nil
 	}
 	if len(kubeComp) == 0 {
 		log.Info(fmt.Sprintf("Found 0 kubernetes components being defined in devfile from %s, it is not a valid outerloop definition, the devfile will be ignored. A devfile will be matched from registry...", URL))
 		shouldIgnoreDevfile = true
@@ -147,8 +152,8 @@
 			found := false
 			for _, component := range kubeComp {
 				if _, ok := deployCompMap[component.Name]; ok {
 					found = true
 					break
 				}
 			}
 			if !found {
@@ -166,9 +171,9 @@
 	}
 	imageComp, err := devfileData.GetComponents(imageCompFilter)
 	if err != nil {
 		log.Error(err, fmt.Sprintf("failed to get image component from %s", URL))
 		return shouldIgnoreDevfile, nil, fmt.Errorf(fmt.Sprintf("err: %v, failed to get image component from %s", err, URL))
 	}
 	if len(imageComp) == 0 {
 		log.Info(fmt.Sprintf("Found 0 image components being defined in devfile from %s, it is not a valid outerloop definition, the devfile will be ignored. A devfile will be matched from registry...", URL))
 		shouldIgnoreDevfile = true
@@ -181,21 +186,21 @@
 					dockerfileURI := component.Image.Dockerfile.DockerfileSrc.Uri
 					absoluteURI := strings.HasPrefix(dockerfileURI, "http://") || strings.HasPrefix(dockerfileURI, "https://")
 					if absoluteURI {
 						// image uri
 						_, err = CurlEndpoint(dockerfileURI)
 					} else {
 						if devfileSrc.Path != "" {
 							// local devfile src with relative Dockerfile uri
 							dockerfileURI = path.Join(path.Dir(URL), dockerfileURI)
 							err = parserUtil.ValidateFile(dockerfileURI)
 						} else {
 							// remote devfile src with relative Dockerfile uri
 							var u *url.URL
 							u, err = url.Parse(URL)
 							if err != nil {
 								log.Error(err, fmt.Sprintf("failed to parse URL from %s", URL))
 								return shouldIgnoreDevfile, nil, fmt.Errorf(fmt.Sprintf("failed to parse URL from %s", URL))
 							}
 							u.Path = path.Join(u.Path, dockerfileURI)
 							dockerfileURI = u.String()
 							_, err = CurlEndpoint(dockerfileURI)
@@ -206,16 +211,16 @@
 						return shouldIgnoreDevfile, nil, fmt.Errorf(fmt.Sprintf("failed to get Dockerfile from the URI %s, invalid image component: %s", URL, component.Name))
 					}
 				}
 				if _, ok := deployCompMap[component.Name]; ok {
 					found = true
 					break
 				}
 			}
 			if !found {
 				err = fmt.Errorf("found more than one image components, but no deploy command associated with any being defined in the devfile from %s", URL)
 				log.Error(err, "failed to validate devfile")
 				return shouldIgnoreDevfile, nil, err
 			}
 		}
 		// TODO: if only one image component, should return a warning that no apply command being defined
 	}
@@ -248,8 +253,8 @@
 	} else if src.Path != "" {
 		parserArgs.Path = src.Path
 	} else {
 		return nil, fmt.Errorf("cannot parse devfile without a src")
 	}
 	devfileObj, _, err := devfilePkg.ParseDevfileAndValidate(parserArgs)
 	return devfileObj.Data, err
 }

controllers/componentdetectionquery_controller_test.go

@@ -1443,7 +1443,7 @@ var _ = Describe("Component Detection Query controller", func() {
 					Expect(component.ComponentStub.Source.GitSource.Revision).Should(Equal("main"))
 				}
 
-				// Make sure the devfiles are detected
+				// Make sure the components are detected
 				Expect(len(createdHasCompDetectionQuery.Status.ComponentDetected)).Should(Equal(3)) // mocked, not accurate. check unit test for accurate detection that uses the alizer client instead of the mock client.
 				for _, componentDesc := range createdHasCompDetectionQuery.Status.ComponentDetected {
 					Expect(componentDesc.ComponentStub.Source.GitSource).ShouldNot(BeNil())

pkg/devfile/devfile.go

@@ -95,8 +95,8 @@
 
 						ingressEndpoint, err := GetIngressFromEndpoint(endpoint.Name, compName, fmt.Sprintf("%d", endpoint.TargetPort), endpoint.Path, isSecure, endpoint.Annotations, hostname)
 						if err != nil {
 							return parser.KubernetesResources{}, err
 						}
 						endpointIngresses = append(endpointIngresses, ingressEndpoint)
 
 						endpointRoutes = append(endpointRoutes, GetRouteFromEndpoint(endpoint.Name, compName, fmt.Sprintf("%d", endpoint.TargetPort), endpoint.Path, isSecure, endpoint.Annotations))
@@ -441,8 +441,8 @@
 
 	portNumber, err := strconv.ParseInt(port, 10, 32)
 	if err != nil {
 		return networkingv1.Ingress{}, err
 	}
 
 	ingress := networkingv1.Ingress{
 		TypeMeta:   generator.GetTypeMeta("Ingress", "networking.k8s.io/v1"),
@@ -744,6 +744,7 @@
 	var err error
 	// Containerfile is an alternate name for Dockerfile
 	validDockerfileLocations := []string{cdqanalysis.Dockerfile, cdqanalysis.DockerDirDockerfile, cdqanalysis.HiddenDirDockerfile, cdqanalysis.BuildDirDockerfile,
+		cdqanalysis.AlternateDockerfile, cdqanalysis.DockerDirAlternateDockerfile, cdqanalysis.HiddenDirAlternateDockerfile, cdqanalysis.BuildDirAlternateDockerfile,
 		cdqanalysis.Containerfile, cdqanalysis.DockerDirContainerfile, cdqanalysis.HiddenDirContainerfile, cdqanalysis.BuildDirContainerfile}
 
 	for _, path := range validDockerfileLocations {

pkg/devfile/devfile_test.go

@@ -288,6 +288,11 @@ func TestFindAndDownloadDockerfile(t *testing.T) {
 			url:                   "https://raw.githubusercontent.com/yangcao77/dockerfile-priority/main/case8",
 			wantDockerfileContext: "build/Containerfile",
 		},
+		{
+			name:                  "Curl dockerfile",
+			url:                   "https://raw.githubusercontent.com/yangcao77/dockerfile-priority/main/case9",
+			wantDockerfileContext: "dockerfile",
+		},
 		{
 			name:    "Cannot curl for a Dockerfile or a Containerfile",
 			url:     "https://github.com/octocat/Hello-World",