248 lines
6.6 KiB
Go
248 lines
6.6 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"flag"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
)
|
|
|
|
type FileInfo struct {
|
|
FileName string
|
|
FilePath string
|
|
FileSize int64
|
|
//ModTime string
|
|
}
|
|
|
|
var (
|
|
dbg bool = false
|
|
aodType string = ""
|
|
aodPath string = ""
|
|
modPath string = ""
|
|
aodInfoList []FileInfo
|
|
moduleInfoList []FileInfo
|
|
criList = make([]string, 0)
|
|
moduleList = make([]string, 0)
|
|
distinctCriList = make([]string, 0)
|
|
distinctModuleList = make([]string, 0)
|
|
needlessModuleList = make([]string, 0)
|
|
missingModuleList = make([]string, 0)
|
|
errAOD = make([]string, 0)
|
|
errCRI = make([]string, 0)
|
|
)
|
|
|
|
var regFilter = `.*`
|
|
var regLNB = `(?i)\S{10,}\.[0-9]{3}`
|
|
var regTNB = `(?i)SSW\S{7}\.SSW\S{7}`
|
|
var regSBID = `(?i)\S{8,}\.DAT`
|
|
|
|
func init() {
|
|
flag.BoolVar(&dbg, "v", false, "Show Verbose Debug Messages")
|
|
flag.StringVar(&aodPath, "a", `D:\MfgTest\PRELOAD\AOD`, "Path Of AODs")
|
|
flag.StringVar(&modPath, "m", `D:\Common`, "Path Of Modules")
|
|
flag.StringVar(&aodType, "t", "*", "Type Of AODs, LNB/TNB/SBID/*")
|
|
flag.Parse()
|
|
}
|
|
|
|
func main() {
|
|
_, err := os.Stat(aodPath)
|
|
if err != nil {
|
|
log.Printf("[ERR] Path Of AODs Not Exists.\r\n")
|
|
os.Exit(1)
|
|
}
|
|
_, err = os.Stat(modPath)
|
|
if err != nil {
|
|
log.Printf("[ERR] Path Of Modules Not Exists.\r\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
log.Printf("[MSG] Summary Loacal AODs ...\r\n")
|
|
aodInfoList, err = _SummaryFiles(aodPath, aodType)
|
|
if err != nil {
|
|
log.Printf("[ERR] Get AOD List Failed: %s\r\n", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
log.Printf("[MSG] Total Local AODs: %d\r\n", len(aodInfoList))
|
|
|
|
log.Printf("[MSG] Summary Local Modules ...\r\n")
|
|
moduleInfoList, err = _SummaryFiles(modPath, "*")
|
|
if err != nil {
|
|
log.Printf("[ERR] Get Module List Failed: %s\r\n", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
log.Printf("[MSG] Total Local Modules: %d\r\n", len(moduleInfoList))
|
|
|
|
regCRI, err := regexp.Compile(`(?i).*File=(.{1,}.CRI)`)
|
|
if err != nil {
|
|
log.Printf("[ERR] RegExp - CRI Compile Error: %s\r\n", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
log.Printf("[MSG] Summary CRIs From AODs ...\r\n")
|
|
for _, aod := range aodInfoList {
|
|
rdr, err := os.Open(aod.FilePath)
|
|
if err != nil {
|
|
errAOD = append(errAOD, aod.FilePath)
|
|
}
|
|
buf := bufio.NewScanner(rdr)
|
|
for buf.Scan() {
|
|
if buf.Err() != nil {
|
|
break
|
|
}
|
|
rst := regCRI.FindStringSubmatch(buf.Text())
|
|
if len(rst) != 2 {
|
|
continue
|
|
}
|
|
criList = append(criList, strings.TrimSpace(rst[1]))
|
|
}
|
|
}
|
|
log.Printf("[MSG] Total CRIs From AODs: %d\r\n", len(criList))
|
|
distinctCriList = _RemoveDuplicateElementOfSlice(criList)
|
|
log.Printf("[MSG] Distinct CRIs From AODs: %d\r\n", len(distinctCriList))
|
|
|
|
regModuleName, err := regexp.Compile(`(?i)(ModuleName[0-9]{0,}|ModuleThis[0-9]{0,})=(.{1,})`)
|
|
if err != nil {
|
|
log.Printf("[ERR] RegExp - ModuleName Compile Error: %s\r\n", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
log.Printf("[MSG] Summary Modules From CRIs ...\r\n")
|
|
for _, cri := range distinctCriList {
|
|
rdr, err := os.Open(modPath + "\\" + cri)
|
|
if err != nil {
|
|
errCRI = append(errCRI, modPath+"\\"+cri)
|
|
}
|
|
buf := bufio.NewScanner(rdr)
|
|
for buf.Scan() {
|
|
if buf.Err() != nil {
|
|
break
|
|
}
|
|
rst := regModuleName.FindStringSubmatch(buf.Text())
|
|
if len(rst) != 3 {
|
|
continue
|
|
}
|
|
moduleList = append(moduleList, strings.TrimSpace(rst[2]))
|
|
}
|
|
}
|
|
log.Printf("[MSG] Total Modules From CRIs: %d\r\n", len(moduleList))
|
|
distinctModuleList = _RemoveDuplicateElementOfSlice(moduleList)
|
|
log.Printf("[MSG] Distinct Modules From CRIs: %d\r\n", len(distinctModuleList))
|
|
|
|
log.Printf("[MSG] Checking Missing Modules ...\r\n")
|
|
for _, m := range distinctModuleList {
|
|
exist := false
|
|
for _, l := range moduleInfoList {
|
|
if strings.EqualFold(m, l.FileName) {
|
|
exist = true
|
|
break
|
|
}
|
|
}
|
|
if !exist {
|
|
missingModuleList = append(missingModuleList, m)
|
|
}
|
|
}
|
|
|
|
log.Printf("[MSG] Checking Needless Modules ...\r\n")
|
|
for _, l := range moduleInfoList {
|
|
needless := true
|
|
for _, m := range distinctModuleList {
|
|
if strings.EqualFold(l.FileName, m) {
|
|
needless = false
|
|
break
|
|
}
|
|
}
|
|
if needless {
|
|
needlessModuleList = append(needlessModuleList, l.FileName)
|
|
}
|
|
}
|
|
|
|
log.Printf("***** Error AODs: %d\r\n", len(errAOD))
|
|
_WriteFileFromStringSlice(".\\errAOD.txt", errAOD)
|
|
|
|
log.Printf("***** Error CRIs: %d\r\n", len(errCRI))
|
|
_WriteFileFromStringSlice(".\\errCRI.txt", errCRI)
|
|
|
|
log.Printf("##### Missing Modules: %d\r\n", len(missingModuleList))
|
|
_WriteFileFromStringSlice(".\\MissingModules.txt", missingModuleList)
|
|
|
|
log.Printf("##### Needless Modules: %d\r\n", len(needlessModuleList))
|
|
_WriteFileFromStringSlice(".\\NeedlessModules.txt", needlessModuleList)
|
|
}
|
|
|
|
func _SummaryFiles(basePath, filter string) ([]FileInfo, error) {
|
|
var err error
|
|
sortInfoList := make([]FileInfo, 0)
|
|
fileInfoList := make([]FileInfo, 0)
|
|
|
|
err = filepath.Walk(basePath, func(path string, info os.FileInfo, err error) error {
|
|
if !info.IsDir() {
|
|
var fileInfo FileInfo
|
|
fileInfo.FileName = info.Name()
|
|
fileInfo.FilePath = path
|
|
fileInfo.FileSize = info.Size()
|
|
//fileInfo.ModTime = info.ModTime().Format("2006-01-02 15:04:05")
|
|
if !strings.Contains(fileInfo.FilePath, ".svn") {
|
|
fileInfoList = append(fileInfoList, fileInfo)
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
log.Printf("[ERR] Get File List Failed: %s\r\n", err.Error())
|
|
return nil, err
|
|
}
|
|
|
|
switch filter {
|
|
case "LNB":
|
|
regFilter = regLNB
|
|
case "TNB":
|
|
regFilter = regTNB
|
|
case "SBID":
|
|
regFilter = regSBID
|
|
default:
|
|
return fileInfoList, nil
|
|
}
|
|
|
|
for _, i := range fileInfoList {
|
|
reg := regexp.MustCompile(regFilter)
|
|
rst := reg.FindStringSubmatch(i.FileName)
|
|
if len(rst) != 1 {
|
|
continue
|
|
}
|
|
sortInfoList = append(sortInfoList, i)
|
|
}
|
|
return sortInfoList, nil
|
|
}
|
|
|
|
func _RemoveDuplicateElementOfSlice(src []string) []string {
|
|
dst := make([]string, 0, len(src))
|
|
tmp := map[string]struct{}{}
|
|
for _, s := range src {
|
|
if _, ok := tmp[s]; !ok {
|
|
tmp[s] = struct{}{}
|
|
dst = append(dst, s)
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
func _WriteFileFromStringSlice(fileName string, dataSlice []string) {
|
|
obj, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
|
|
if err != nil {
|
|
log.Printf("[ERR] Open File Error: %s\r\n", err.Error())
|
|
return
|
|
}
|
|
defer obj.Close()
|
|
|
|
var builder strings.Builder
|
|
for _, s := range dataSlice {
|
|
builder.WriteString(s + "\r\n")
|
|
}
|
|
obj.WriteString(builder.String())
|
|
if err != nil {
|
|
log.Printf("[ERR] Write File Error: %s\r\n", err.Error())
|
|
return
|
|
}
|
|
}
|