// Check check rule or all rules for some service func Check(target string) error { if target == "" { return errors.New("You must difine mock file or service name") } targetService, targetMock, targetDir := rules.ParsePath(target) serviceDir := path.Join(knf.GetS(DATA_RULE_DIR), targetService) if !fsutil.IsExist(serviceDir) { return fmtc.Errorf("Service %s is not exist", targetService) } var ruleInfoSlice []*RuleInfo if targetMock != "" { ruleInfoSlice = append(ruleInfoSlice, &RuleInfo{targetService, targetMock, targetDir}) } else { mockFiles := fsutil.ListAllFiles(serviceDir, true, &fsutil.ListingFilter{MatchPatterns: []string{"*.mock"}}, ) for _, mockFile := range mockFiles { mockPath := path.Join(targetService, strings.Replace(mockFile, ".mock", "", -1)) _, targetMock, targetDir := rules.ParsePath(mockPath) ruleInfoSlice = append(ruleInfoSlice, &RuleInfo{targetService, targetMock, targetDir}) } } if len(ruleInfoSlice) == 0 { fmtc.Println("\n{y}No mock's were found{!}\n") return nil } var maxProblemType = PROBLEM_NONE for _, rule := range ruleInfoSlice { maxProblemType = mathutil.MaxU8(checkRule(rule), maxProblemType) } if maxProblemType > PROBLEM_NONE { fmtutil.Separator(false) } switch maxProblemType { case PROBLEM_NONE: fmtc.Printf("\n{g}%s{!}\n\n", okMessages[rand.Int(len(okMessages))]) case PROBLEM_WARN: fmtc.Printf("{y}%s{!}\n\n", warnMessages[rand.Int(len(warnMessages))]) case PROBLEM_ERR: fmtc.Printf("{r}%s{!}\n\n", errorMessages[rand.Int(len(errorMessages))]) } return nil }
func setupLog() { var err error if arg.GetB(ARG_DAEMON) { err = log.Set(knf.GetS(LOG_FILE), knf.GetM(LOG_PERMS, 0644)) if err != nil { fmt.Printf("Can't setup logger: %v\n", err) os.Exit(1) } } err = log.MinLevel(knf.GetS(LOG_LEVEL, "info")) if err != nil { fmt.Printf("Can't set log level: %v\n", err) } }
func runServer() { observer := rules.NewObserver(knf.GetS(DATA_RULE_DIR)) observer.AutoHead = knf.GetB(PROCESSING_AUTO_HEAD) observer.Start(knf.GetI(DATA_CHECK_DELAY)) err := server.Start(observer, APP+"/"+VER, arg.GetS(ARG_PORT)) if err != nil { printError(err.Error()) os.Exit(1) } }
func updatePerms(dirPath, mockPath string) { if knf.GetS(ACCESS_USER) != "" || knf.GetS(ACCESS_GROUP) != "" { dirOwnerUID, dirOwnerGID, _ := fsutil.GetOwner(dirPath) mockOwnerUID, mockOwnerGID, _ := fsutil.GetOwner(mockPath) if knf.GetS(ACCESS_USER) != "" { userInfo, err := system.LookupUser(knf.GetS(ACCESS_USER)) if err == nil { dirOwnerUID = userInfo.UID mockOwnerUID = userInfo.UID } } if knf.GetS(ACCESS_GROUP) != "" { groupInfo, err := system.LookupGroup(knf.GetS(ACCESS_GROUP)) if err == nil { dirOwnerGID = groupInfo.GID mockOwnerGID = groupInfo.GID } } os.Chown(dirPath, dirOwnerUID, dirOwnerGID) os.Chown(mockPath, mockOwnerUID, mockOwnerGID) } os.Chmod(dirPath, knf.GetM(ACCESS_MOCK_DIR_PERMS)) os.Chmod(mockPath, knf.GetM(ACCESS_MOCK_PERMS)) }
func showRuleInfo(rule *rules.Rule) { if rule.Desc == "" { fmtc.Printf("\n {*}%s{!} {s}(Description is empty){!}\n", rule.FullName+".mock") } else { fmtc.Printf("\n {*}%s{!} - %s\n", rule.FullName+".mock", rule.Desc) } host := rule.Request.Host if host == "" { if knf.GetS(LISTING_HOST) != "" { host = knf.GetS(LISTING_HOST) } else { host = ip } } if knf.GetS(LISTING_SCHEME) != "" { host = knf.GetS(LISTING_SCHEME) + "://" + host } if knf.GetS(LISTING_PORT) != "" { host = host + ":" + knf.GetS(LISTING_PORT) } fmtc.Printf(" {s}%s %s%s{!}\n", rule.Request.Method, host, rule.Request.URL) }
func Make(name string) error { if !fsutil.IsWritable(knf.GetS(DATA_RULE_DIR)) { return fmt.Errorf("Directory %s must be writable.", knf.GetS(DATA_RULE_DIR)) } if name == "" { return errors.New("You must difine mock file name (service1/mock1 for example)") } if !strings.Contains(name, "/") { return errors.New("You must difine mock file name as <service-id>/<mock-name>.") } template := knf.GetS(TEMPLATE_PATH) ruleDir := knf.GetS(DATA_RULE_DIR) dirName := path.Dir(name) fullPath := path.Join(ruleDir, name) if !strings.Contains(fullPath, ".mock") { fullPath += ".mock" } if fsutil.IsExist(fullPath) { return fmt.Errorf("File %s already exist\n", fullPath) } if template == "" || !fsutil.CheckPerms("FRS", template) { return createMock(MOCK_TEMPLATE, dirName, fullPath) } templData, err := ioutil.ReadFile(template) if err != nil { return fmt.Errorf("Can't read template content from %s: %v", template, err) } return createMock(string(templData), dirName, fullPath) }
func listMocks(args []string) { var service = "" // Suppress observer logging log.Set(os.DevNull, 0) if len(args) != 0 { service = args[0] } observer := rules.NewObserver(knf.GetS(DATA_RULE_DIR)) err := listing.List(observer, service) if err != nil { printError(err.Error()) os.Exit(1) } }
// checkRule parse rule, run validators and print check results func checkRule(ruleInfo *RuleInfo) uint8 { var problems []*Problem rule, err := rules.Parse(knf.GetS(DATA_RULE_DIR), ruleInfo.Service, ruleInfo.Dir, ruleInfo.Name) if err != nil { problems = append(problems, &Problem{ Type: PROBLEM_ERR, Info: "Parsing error", Desc: err.Error(), }, ) } else { validators := []Validator{ checkDescription, checkWildcard, checkMethod, checkStatusCode, checkContent, } problems = append(problems, execValidators(validators, rule)...) } if len(problems) == 0 { return PROBLEM_NONE } fmtutil.Separator(false, path.Join(ruleInfo.Service, ruleInfo.Dir, ruleInfo.Name)) renderProblems(problems) var maxProblemType = PROBLEM_NONE for _, problem := range problems { maxProblemType = mathutil.MaxU8(problem.Type, maxProblemType) } return maxProblemType }
func createMock(content, dirName, fullPath string) error { serviceDir := path.Join(knf.GetS(DATA_RULE_DIR), dirName) err := os.MkdirAll(serviceDir, 0755) if err != nil { return fmt.Errorf("Can't create directory %s", serviceDir) } mf, err := os.OpenFile(fullPath, os.O_WRONLY|os.O_CREATE, 0644) if err != nil { return fmt.Errorf("Can't create file %s", fullPath) } defer mf.Close() mf.WriteString(content) updatePerms(serviceDir, fullPath) return nil }