warricksothr
/
pinned-package-updater
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Code cleanup

master
Drew Short 3 years ago
parent
a36b081e37
commit
6d4455c343
3 changed files with 161 additions and 135 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 182
      internal/parser/debian.go
  2. 106
      internal/parser/dockerfile/dockerfile.go
  3. 8
      internal/parser/parser.go

182
internal/parser/debian.go
View File

@ -32,6 +32,94 @@ type DebianCommandParser struct {
printer *syntax.Printer printer *syntax.Printer
} }
// GetRepositories Returns a list of Repository entries that were identified
func (c DebianCommandParser) GetRepositories(command string) ([]*Repository, error) {
var repositories []*Repository
reader := strings.NewReader(command)
parsedScript, scriptParseErr := c.parser.Parse(reader, "")
if scriptParseErr != nil {
log.Fatalf("Failed to parse script \"%s\": %s", command, scriptParseErr)
return nil, scriptParseErr
}
var hasErrorWhileWalkingScript bool = false
var errorWhileWalkingScript error
syntax.Walk(parsedScript, func(node syntax.Node) bool {
switch parsedStatement := node.(type) {
case *syntax.Stmt:
switch parsedCommand := parsedStatement.Cmd.(type) {
case *syntax.CallExpr:
if isAddRepositoryExpression(*parsedCommand, parsedStatement.Redirs) {
repositoryInformation, repositoryParseErr := c.getAddedRepository(*parsedCommand, parsedStatement.Redirs)
if repositoryParseErr != nil {
log.Fatalf("Unexpected error while parsing repository from \"%s\": %s", c.shellNodeToString(node), repositoryParseErr)
hasErrorWhileWalkingScript = true
errorWhileWalkingScript = repositoryParseErr
// Terminate walking early so we can raise an error
return false
}
repositories = append(repositories, &Repository{Information: repositoryInformation})
log.Debugf("Found repository \"%s\"", repositoryInformation)
}
}
}
return true
})
if hasErrorWhileWalkingScript {
return repositories, errorWhileWalkingScript
}
return repositories, nil
}
// GetPinnedPackages get a list of all pinned packages
func (c DebianCommandParser) GetPinnedPackages(command string) ([]*Package, error) {
var packages []*Package
reader := strings.NewReader(command)
parsedScript, scriptParseErr := c.parser.Parse(reader, "")
if scriptParseErr != nil {
log.Fatalf("Failed to parse script \"%s\"", command)
return nil, scriptParseErr
}
var hasErrorWhileWalkingScript bool = false
var errorWhileWalkingScript error
syntax.Walk(parsedScript, func(node syntax.Node) bool {
switch parsedStatement := node.(type) {
case *syntax.Stmt:
switch parsedCommand := parsedStatement.Cmd.(type) {
case *syntax.CallExpr:
if isInstallerExpression(*parsedCommand) {
pinnedPackages, pinnedPackageParseErr := c.getInstalledPinnedPackages(*parsedCommand)
if pinnedPackageParseErr != nil {
log.Fatalf("Unexpected error while parsing pinned packages from \"%s\": %s", c.shellNodeToString(node), pinnedPackageParseErr)
hasErrorWhileWalkingScript = true
errorWhileWalkingScript = pinnedPackageParseErr
// Terminate walking early so we can raise an error
return false
}
for _, pinnedPackage := range pinnedPackages {
packages = append(packages, pinnedPackage)
log.Debugf("Found pinned package \"%s=%s\"", pinnedPackage.Name, pinnedPackage.Version)
}
}
}
}
return true
})
if hasErrorWhileWalkingScript {
return packages, errorWhileWalkingScript
}
return packages, nil
}
/*
General Helpers
*/
// newDebianCommandParser Provision a new instance of DebianCommandParser with required components // newDebianCommandParser Provision a new instance of DebianCommandParser with required components
func newDebianCommandParser() DebianCommandParser { func newDebianCommandParser() DebianCommandParser {
return DebianCommandParser{ return DebianCommandParser{
@ -50,6 +138,20 @@ func (c DebianCommandParser) shellNodeToString(node syntax.Node) string {
return buffer.String() return buffer.String()
} }
// trimQuotes return a string without surrounding matching quotes
func trimQuotes(value string) string {
if value[0] == '"' && value[len(value)-1] == '"' {
return value[1 : len(value)-1]
} else if value[0] == '\'' && value[len(value)-1] == '\'' {
return value[1 : len(value)-1]
}
return value
}
/*
Repository Helpers
*/
// isRedirectedToAptSourcesList Checks if the list of redirects contains the apt sources list directory // isRedirectedToAptSourcesList Checks if the list of redirects contains the apt sources list directory
func isRedirectedToAptSourcesList(redirects []*syntax.Redirect) bool { func isRedirectedToAptSourcesList(redirects []*syntax.Redirect) bool {
if redirects != nil && len(redirects) > 0 { if redirects != nil && len(redirects) > 0 {
@ -74,16 +176,6 @@ func isAddRepositoryExpression(command syntax.CallExpr, redirects []*syntax.Redi
return false return false
} }
// trimQuotes return a string without surrounding quotes
func trimQuotes(value string) string {
if value[0] == '"' && value[len(value)-1] == '"' {
return value[1 : len(value)-1]
} else if value[0] == '\'' && value[len(value)-1] == '\'' {
return value[1 : len(value)-1]
}
return value
}
// getAddedRepository parse the repository information from the shell commands // getAddedRepository parse the repository information from the shell commands
func (c DebianCommandParser) getAddedRepository(command syntax.CallExpr, redirects []*syntax.Redirect) (string, error) { func (c DebianCommandParser) getAddedRepository(command syntax.CallExpr, redirects []*syntax.Redirect) (string, error) {
// Adding via debian tooling // Adding via debian tooling
@ -102,38 +194,6 @@ func (c DebianCommandParser) getAddedRepository(command syntax.CallExpr, redirec
return "", errors.New("failed to parse repository") return "", errors.New("failed to parse repository")
} }
// GetRepositories Returns a list of Repository entries that were identified
func (c DebianCommandParser) GetRepositories(command string) ([]*Repository, error) {
var repositories []*Repository
reader := strings.NewReader(command)
parsedScript, err := c.parser.Parse(reader, "")
if err != nil {
log.Fatalf("Failed to parse script \"%s\"", command)
return nil, err
}
syntax.Walk(parsedScript, func(node syntax.Node) bool {
switch parsedStatement := node.(type) {
case *syntax.Stmt:
switch parsedCommand := parsedStatement.Cmd.(type) {
case *syntax.CallExpr:
if isAddRepositoryExpression(*parsedCommand, parsedStatement.Redirs) {
repositoryInformation, err := c.getAddedRepository(*parsedCommand, parsedStatement.Redirs)
if err != nil {
log.Fatalf("Unexpected error while parsing repository from \"%s\": %s", c.shellNodeToString(node), err)
}
repositories = append(repositories, &Repository{Information: repositoryInformation})
log.Debugf("Found repository \"%s\"", repositoryInformation)
}
}
}
return true
})
return repositories, nil
}
// isAddRepositoryExpression Checks for expressions that add to the repository // isAddRepositoryExpression Checks for expressions that add to the repository
func isInstallerExpression(command syntax.CallExpr) bool { func isInstallerExpression(command syntax.CallExpr) bool {
// Adding via debian tooling // Adding via debian tooling
@ -144,6 +204,10 @@ func isInstallerExpression(command syntax.CallExpr) bool {
return false return false
} }
/*
Pinned Package Helpers
*/
func (c DebianCommandParser) getInstalledPinnedPackages(command syntax.CallExpr) ([]*Package, error) { func (c DebianCommandParser) getInstalledPinnedPackages(command syntax.CallExpr) ([]*Package, error) {
var packages []*Package var packages []*Package
@ -165,37 +229,3 @@ func (c DebianCommandParser) getInstalledPinnedPackages(command syntax.CallExpr)
} }
return packages, errors.New("failed to parse packages") return packages, errors.New("failed to parse packages")
} }
// GetPinnedPackages get a list of all pinned packages
func (c DebianCommandParser) GetPinnedPackages(command string) ([]*Package, error) {
var packages []*Package
reader := strings.NewReader(command)
parsedScript, err := c.parser.Parse(reader, "")
if err != nil {
log.Fatalf("Failed to parse script \"%s\"", command)
return nil, err
}
syntax.Walk(parsedScript, func(node syntax.Node) bool {
switch parsedStatement := node.(type) {
case *syntax.Stmt:
switch parsedCommand := parsedStatement.Cmd.(type) {
case *syntax.CallExpr:
if isInstallerExpression(*parsedCommand) {
pinnedPackages, err := c.getInstalledPinnedPackages(*parsedCommand)
if err != nil {
log.Fatalf("Unexpected error while parsing pinned packages from \"%s\": %s", c.shellNodeToString(node), err)
}
for _, pinnedPackage := range pinnedPackages {
packages = append(packages, pinnedPackage)
log.Debugf("Found pinned package \"%s=%s\"", pinnedPackage.Name, pinnedPackage.Version)
}
}
}
}
return true
})
return packages, nil
}

106
internal/parser/dockerfile/dockerfile.go
View File

@ -25,60 +25,56 @@ import (
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
buildkitDockerfileInstructions "github.com/moby/buildkit/frontend/dockerfile/instructions"
buildkitDockerfileParser "github.com/moby/buildkit/frontend/dockerfile/parser"
buildkitInstructions "github.com/moby/buildkit/frontend/dockerfile/instructions"
buildkitParser "github.com/moby/buildkit/frontend/dockerfile/parser"
"sothr.com/warricksothr/pinned-package-updater/internal/parser" "sothr.com/warricksothr/pinned-package-updater/internal/parser"
) )
// Parse reads a Dockerfile, interprets the AST and returns information about the image(s) and package(s) defined // Parse reads a Dockerfile, interprets the AST and returns information about the image(s) and package(s) defined
func Parse(dockerfilePath string) (parser.ParseResult, error) { func Parse(dockerfilePath string) (parser.ParseResult, error) {
dockerfile, err := os.Open(dockerfilePath)
if err != nil {
log.Fatalf("Unexpected error reading file %s: %s", dockerfilePath, err)
return parser.ParseResult{}, err
dockerfile, dockerfileOpenErr := os.Open(dockerfilePath)
if dockerfileOpenErr != nil {
log.Fatalf("Unexpected error reading file %s: %s", dockerfilePath, dockerfileOpenErr)
return parser.ParseResult{}, dockerfileOpenErr
} }
defer func(dockerfile *os.File) { defer func(dockerfile *os.File) {
err := dockerfile.Close()
if err != nil {
log.Error("Unexpected error closing file %s: %s", dockerfilePath, err)
dockerfileCloseErr := dockerfile.Close()
if dockerfileCloseErr != nil {
log.Error("Unexpected error closing file %s: %s", dockerfilePath, dockerfileCloseErr)
} }
}(dockerfile) }(dockerfile)
dockerfileParseResults, err := buildkitDockerfileParser.Parse(dockerfile)
if err != nil {
log.Fatalf("Unexpected error parsing Dockerfile %s: %s", dockerfilePath, err)
return parser.ParseResult{}, err
parsedASTResult, ASTParseErr := buildkitParser.Parse(dockerfile)
if ASTParseErr != nil {
log.Fatalf("Unexpected error parsing Dockerfile %s: %s", dockerfilePath, ASTParseErr)
return parser.ParseResult{}, ASTParseErr
} }
dockerfileParseResult, err := parseDockerfileAST(dockerfileParseResults.AST)
if err != nil {
log.Fatalf("Unexpected error while parsing AST for %s: %s", dockerfilePath, err)
return parser.ParseResult{}, err
parseResult, parseErr := parseDockerfileAST(parsedASTResult.AST)
if parseErr != nil {
log.Fatalf("Unexpected error while parsing AST for %s: %s", dockerfilePath, parseErr)
return parser.ParseResult{}, parseErr
} }
return dockerfileParseResult, nil
}
type ASTStage struct {
children []*buildkitDockerfileParser.Node
return parseResult, nil
} }
// parseDockerfileAST Read the parsed AST and extract the required information from each stage // parseDockerfileAST Read the parsed AST and extract the required information from each stage
func parseDockerfileAST(dockerfileAST *buildkitDockerfileParser.Node) (parser.ParseResult, error) {
func parseDockerfileAST(dockerfileAST *buildkitParser.Node) (parser.ParseResult, error) {
dockerfileStages, _, err := buildkitDockerfileInstructions.Parse(dockerfileAST)
if err != nil {
log.Fatal("Unexpected error while parsing Dockerfile Instructions")
return parser.ParseResult{}, err
dockerfileStages, _, stageParsingErr := buildkitInstructions.Parse(dockerfileAST)
if stageParsingErr != nil {
log.Fatalf("Unexpected error while parsing Dockerfile Instructions: %s", stageParsingErr)
return parser.ParseResult{}, stageParsingErr
} }
var stages []*parser.Stage var stages []*parser.Stage
for stageIndex, stage := range dockerfileStages { for stageIndex, stage := range dockerfileStages {
stage, err := parseDockerfileStage(stage)
if err != nil {
stage, stageErr := parseDockerfileStage(stage)
if stageErr != nil {
log.Fatal("Unexpected error while parsing stage %d", stageIndex) log.Fatal("Unexpected error while parsing stage %d", stageIndex)
return parser.ParseResult{}, err
return parser.ParseResult{}, stageErr
} }
stages = append(stages, &stage) stages = append(stages, &stage)
} }
@ -86,7 +82,7 @@ func parseDockerfileAST(dockerfileAST *buildkitDockerfileParser.Node) (parser.Pa
return parser.ParseResult{Stages: stages}, nil return parser.ParseResult{Stages: stages}, nil
} }
func parseDockerfileStage(dockerfileStage buildkitDockerfileInstructions.Stage) (parser.Stage, error) {
func parseDockerfileStage(dockerfileStage buildkitInstructions.Stage) (parser.Stage, error) {
imageParts := strings.Split(dockerfileStage.BaseName, ":") imageParts := strings.Split(dockerfileStage.BaseName, ":")
@ -102,22 +98,22 @@ func parseDockerfileStage(dockerfileStage buildkitDockerfileInstructions.Stage)
Tag: imageParts[1], Tag: imageParts[1],
} }
commandParser, err := parser.GetCommandParser(image)
if err != nil {
log.Fatalf("Unexpected error while determining command parser for image %s", image)
return parser.Stage{}, err
commandParser, commandParserRetrievalErr := parser.GetCommandParser(image)
if commandParserRetrievalErr != nil {
log.Fatalf("Unexpected error while determining command parser for image \"%s\": %s", image, commandParserRetrievalErr)
return parser.Stage{}, commandParserRetrievalErr
} }
repositories, err := parseRepositoriesFromDockerfileStage(dockerfileStage, commandParser)
if err != nil {
message := fmt.Sprintf("Unexpected error while parsing repositories from stage")
repositories, repositoryCommandParseErr := parseRepositoriesFromDockerfileStage(dockerfileStage, commandParser)
if repositoryCommandParseErr != nil {
message := fmt.Sprintf("Unexpected error while parsing repositories from stage: %s", repositoryCommandParseErr)
log.Fatal(message) log.Fatal(message)
return parser.Stage{}, errors.New(message) return parser.Stage{}, errors.New(message)
} }
packages, err := parsePackagesFromDockerfileStage(dockerfileStage, commandParser)
if err != nil {
message := fmt.Sprintf("Unexpected error while parsing packages from stage")
packages, packageCommandParseErr := parsePackagesFromDockerfileStage(dockerfileStage, commandParser)
if packageCommandParseErr != nil {
message := fmt.Sprintf("Unexpected error while parsing packages from stage: %s", packageCommandParseErr)
log.Fatal(message) log.Fatal(message)
return parser.Stage{}, errors.New(message) return parser.Stage{}, errors.New(message)
} }
@ -130,21 +126,21 @@ func parseDockerfileStage(dockerfileStage buildkitDockerfileInstructions.Stage)
}, nil }, nil
} }
func parseRepositoriesFromDockerfileStage(dockerfileStage buildkitDockerfileInstructions.Stage, commandParser *parser.CommandParser) ([]*parser.Repository, error) {
func parseRepositoriesFromDockerfileStage(dockerfileStage buildkitInstructions.Stage, commandParser *parser.CommandParser) ([]*parser.Repository, error) {
var repositories []*parser.Repository var repositories []*parser.Repository
typedCommandParser := *commandParser typedCommandParser := *commandParser
for _, command := range dockerfileStage.Commands { for _, command := range dockerfileStage.Commands {
switch command.(type) { switch command.(type) {
case *buildkitDockerfileInstructions.RunCommand:
runCommand := command.(*buildkitDockerfileInstructions.RunCommand)
case *buildkitInstructions.RunCommand:
runCommand := command.(*buildkitInstructions.RunCommand)
log.Tracef("Parsing RunCommand \"%s\" for repositories", runCommand.CmdLine) log.Tracef("Parsing RunCommand \"%s\" for repositories", runCommand.CmdLine)
parsedRepositories, err := typedCommandParser.GetRepositories(runCommand.CmdLine[0])
if err != nil {
log.Fatalf("Unexpected error while parsing repositories: %s", err)
return nil, err
parsedRepositories, repositoryParseErr := typedCommandParser.GetRepositories(runCommand.CmdLine[0])
if repositoryParseErr != nil {
log.Fatalf("Unexpected error while parsing repositories: %s", repositoryParseErr)
return nil, repositoryParseErr
} }
for _, parsedRepository := range parsedRepositories { for _, parsedRepository := range parsedRepositories {
repositories = append(repositories, parsedRepository) repositories = append(repositories, parsedRepository)
@ -155,21 +151,21 @@ func parseRepositoriesFromDockerfileStage(dockerfileStage buildkitDockerfileInst
return repositories, nil return repositories, nil
} }
func parsePackagesFromDockerfileStage(dockerfileStage buildkitDockerfileInstructions.Stage, commandParser *parser.CommandParser) ([]*parser.Package, error) {
func parsePackagesFromDockerfileStage(dockerfileStage buildkitInstructions.Stage, commandParser *parser.CommandParser) ([]*parser.Package, error) {
var packages []*parser.Package var packages []*parser.Package
typedCommandParser := *commandParser typedCommandParser := *commandParser
for _, command := range dockerfileStage.Commands { for _, command := range dockerfileStage.Commands {
switch command.(type) { switch command.(type) {
case *buildkitDockerfileInstructions.RunCommand:
runCommand := command.(*buildkitDockerfileInstructions.RunCommand)
case *buildkitInstructions.RunCommand:
runCommand := command.(*buildkitInstructions.RunCommand)
log.Tracef("Parsing RunCommand \"%s\" for packages", runCommand.CmdLine) log.Tracef("Parsing RunCommand \"%s\" for packages", runCommand.CmdLine)
parsedPinnedPackages, err := typedCommandParser.GetPinnedPackages(runCommand.CmdLine[0])
if err != nil {
log.Fatalf("Unexpected error while parsing pinned packages: %s", err)
return nil, err
parsedPinnedPackages, packageParseErr := typedCommandParser.GetPinnedPackages(runCommand.CmdLine[0])
if packageParseErr != nil {
log.Fatalf("Unexpected error while parsing pinned packages: %s", packageParseErr)
return nil, packageParseErr
} }
for _, parsedPinnedPackage := range parsedPinnedPackages { for _, parsedPinnedPackage := range parsedPinnedPackages {
packages = append(packages, parsedPinnedPackage) packages = append(packages, parsedPinnedPackage)

8
internal/parser/parser.go
View File

@ -92,10 +92,10 @@ func InitCommandParsers() error {
} }
func GetCommandParser(image Image) (*CommandParser, error) { func GetCommandParser(image Image) (*CommandParser, error) {
parserType, err := determineParserForImage(image)
if err != nil {
log.Fatalf("Failed to determine a matching CommandParser for %s: %s", image, err)
return nil, err
parserType, determineParserErr := determineParserForImage(image)
if determineParserErr != nil {
log.Fatalf("Failed to determine a matching CommandParser for %s: %s", image, determineParserErr)
return nil, determineParserErr
} }
if requestedCommandParser, ok := availableCommandParsers[parserType]; ok { if requestedCommandParser, ok := availableCommandParsers[parserType]; ok {

Write Preview
Loading…
Cancel
Save