// Detect extracts source code information about the provided source repository
func (e SourceRepositoryEnumerator) Detect(dir string) (*SourceRepositoryInfo, error) {
info := &SourceRepositoryInfo{
Path: dir,
}
for _, d := range e.Detectors {
if detected, ok := d(dir); ok {
info.Types = append(info.Types, SourceLanguageType{
Platform: detected.Platform,
Version: detected.Version,
})
}
}
if path, ok, err := e.Tester.Has(dir); err == nil && ok {
file, err := os.Open(path)
if err != nil {
return nil, err
}
defer file.Close()
dockerfile, err := dockerfile.NewParser().Parse(file)
if err != nil {
return nil, err
}
info.Dockerfile = dockerfile
}
if info.Dockerfile == nil && len(info.Types) == 0 {
return nil, ErrNoLanguageDetected
}
return info, nil
}
// NewBuildStrategyRefGenerator creates a BuildStrategyRefGenerator
func NewBuildStrategyRefGenerator(sourceDetectors source.Detectors) *BuildStrategyRefGenerator {
return &BuildStrategyRefGenerator{
gitRepository: git.NewRepository(),
dockerfileFinder: dockerfile.NewFinder(),
dockerfileParser: dockerfile.NewParser(),
sourceDetectors: sourceDetectors,
imageRefGenerator: NewImageRefGenerator(),
}
}
func NewDockerfile(contents string) (Dockerfile, error) {
if len(contents) == 0 {
return nil, fmt.Errorf("Dockerfile is empty")
}
df := dockerfileContents{
contents: contents,
}
if parsed, err := dockerfile.NewParser().Parse(bytes.NewBufferString(contents)); err == nil {
df.parsed = parsed
}
return df, nil
}
func NewDockerfileFromFile(path string) (Dockerfile, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
if len(data) == 0 {
return nil, fmt.Errorf("Dockerfile %q is empty", path)
}
df := dockerfileContents{
contents: string(data),
}
df.parsed, df.err = dockerfile.NewParser().Parse(bytes.NewBuffer(data))
return df, nil
}
// Make sure that buildPipelines defaults DockerImage.Config if needed to
// avoid a nil panic.
func TestBuildPipelinesWithUnresolvedImage(t *testing.T) {
dockerParser := dockerfile.NewParser()
dockerFileInput := strings.NewReader("EXPOSE 1234\nEXPOSE 4567")
dockerFile, err := dockerParser.Parse(dockerFileInput)
if err != nil {
t.Fatal(err)
}
sourceRepo, err := app.NewSourceRepository("https://github.com/foo/bar.git")
if err != nil {
t.Fatal(err)
}
sourceRepo.BuildWithDocker()
sourceRepo.SetInfo(&app.SourceRepositoryInfo{
Dockerfile: dockerFile,
})
refs := app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
Value: "mysql",
Uses: sourceRepo,
ExpectToBuild: true,
ResolvedMatch: &app.ComponentMatch{
Value: "mysql",
},
}),
}
a := AppConfig{}
group, err := a.buildPipelines(refs, app.Environment{})
if err != nil {
t.Error(err)
}
expectedPorts := util.NewStringSet("1234", "4567")
actualPorts := util.NewStringSet()
for port := range group[0].InputImage.Info.Config.ExposedPorts {
actualPorts.Insert(port)
}
if e, a := expectedPorts.List(), actualPorts.List(); !reflect.DeepEqual(e, a) {
t.Errorf("Expected ports=%v, got %v", e, a)
}
}
// NewImageRefGenerator creates a new ImageRefGenerator
func NewImageRefGenerator() ImageRefGenerator {
return &imageRefGenerator{
dockerParser: dockerfile.NewParser(),
}
}
