cmd

Documentation

Index

• Variables
• func BindEnvs(iface interface{}, parts ...string)
• func Execute()
• func RenameInDB(from, to string, tx *sql.Tx) error

Variables

var ActivateCmd = &cobra.Command{
	Use: "activate",
	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := config.Server{}

		err := viper.Unmarshal(&cfg)
		if err != nil {
			return err
		}

		s := web.Server{Server: cfg}

		s.SetupEnvironment()
		s.ConnectToDB()
		_, err = models.Users(qm.Where("name = ?", ActivateCmdArgs.Name)).UpdateAll(context.Background(), s.DB, models.M{"activation_key": nil})

		return err
	},
}

var ActivateCmdArgs struct {
	Name string
}

var GlueCmd = &cobra.Command{
	Use:   "glue",
	Short: "",
	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
		BindEnvs(glue.Config{})
		viper.SetEnvPrefix("njudge")

		viper.SetConfigName("glue")
		viper.AddConfigPath(".")
		viper.AutomaticEnv()
		return viper.MergeInConfig()
	},

	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := glue.Config{}

		err := viper.Unmarshal(&cfg)
		if err != nil {
			return err
		}

		s := glue.Server{Config: cfg}
		s.Run()

		return nil
	},
}

var JudgeCmd = &cobra.Command{
	Use:   "judge",
	Short: "start judge server",
	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
		BindEnvs(judge.HTTPServer{})
		viper.SetEnvPrefix("njudge")

		viper.SetConfigName("judge")
		viper.AddConfigPath(".")
		viper.AutomaticEnv()
		return viper.MergeInConfig()
	},

	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := judge.ServerConfig{}
		if err := viper.Unmarshal(&cfg); err != nil {
			return err
		}

		s, err := judge.NewServer(cfg)
		if err != nil {
			return err
		}

		s.Run()
		return nil
	},
}

var MigrateCmd = &cobra.Command{
	Use: "migrate",
	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := config.Server{}

		err := viper.Unmarshal(&cfg)
		if err != nil {
			return err
		}

		server := web.Server{Server: cfg}
		server.ConnectToDB()
		driver, err := postgres.WithInstance(server.DB.DB, &postgres.Config{})
		if err != nil {
			return err
		}

		d, err := iofs.New(migrations.FS, ".")
		if err != nil {
			return err
		}

		m, err := migrate.NewWithInstance("iofs", d, "postgres", driver)
		if err != nil {
			return err
		}

		m.Log = &migrateLogger{log.New(os.Stdout, "[migrate]", 0), false}

		if MigrateCmdArgs.Up {
			err = m.Up()
			if err != nil {
				return err
			}
		} else if MigrateCmdArgs.Down {
			err = m.Down()
			if err != nil {
				return err
			}
		} else if MigrateCmdArgs.Steps != 0 {
			err = m.Steps(MigrateCmdArgs.Steps)
			if err != nil {
				return err
			}
		}

		return nil
	},
}

var MigrateCmdArgs struct {
	Up    bool
	Down  bool
	Steps int
}

var PrefixCmd = &cobra.Command{
	Use: "prefix_problems",
	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := config.Server{}

		err := viper.Unmarshal(&cfg)
		if err != nil {
			return err
		}
		server := web.Server{Server: cfg}
		server.ConnectToDB()

		withoutPrefixes := problems.NewFsStore(cfg.ProblemsDir, problems.FsStoreIgnorePrefix())
		err = withoutPrefixes.Update()
		if err != nil {
			return nil
		}

		withPrefixes := problems.NewFsStore(cfg.ProblemsDir)
		err = withPrefixes.Update()
		if err != nil {
			return nil
		}

		if PrefixCmdArgs.Reset {
			withPrefixes, withoutPrefixes = withoutPrefixes, withPrefixes
		}

		tx, err := server.DB.Begin()
		if err != nil {
			return err
		}

		for path, id := range withPrefixes.ByPath {
			if withoutPrefixes.ByPath[path] != id {
				if err := RenameInDB(withoutPrefixes.ByPath[path], id, tx); err != nil {
					return err
				}
			}
		}

		if PrefixCmdArgs.DryRun {
			return tx.Rollback()
		}

		return tx.Commit()
	},
}

var PrefixCmdArgs struct {
	DryRun bool
	Reset  bool
}

var PrefixRunCmd = &cobra.Command{
	Use: "run",
}

var RootCmd = &cobra.Command{
	Use:     "njudge",
	Version: "v0.1.0",
	Long:    "cli tool to manage njudge instance",
}

var SubmitCmd = &cobra.Command{
	Use: "submit",
	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := config.Server{}

		err := viper.Unmarshal(&cfg)
		if err != nil {
			return err
		}

		s := web.Server{Server: cfg}
		src, err := ioutil.ReadFile(SubmitCmdArgs.File)
		if err != nil {
			return err
		}

		s.SetupEnvironment()
		if err := s.ProblemStore.Update(); err != nil {
			return err
		}

		id, err := s.Submit(SubmitCmdArgs.User, SubmitCmdArgs.Problemset, SubmitCmdArgs.Problem, SubmitCmdArgs.Language, src)
		if err != nil {
			return err
		}

		log.Print("submission received with id ", id)
		return nil
	},
}

var SubmitCmdArgs struct {
	File       string
	Problemset string
	Problem    string
	Language   string
	User       int
}

var TestProblemArgs struct {
	ProblemDir   string
	Language     string
	SolutionPath string
	Verbose      int
}

var TestProblemCmd = &cobra.Command{
	Use: "testproblem",
	RunE: func(cmd *cobra.Command, args []string) error {
		sp := language.NewSandboxProvider()
		sp.Put(sandbox.NewIsolate(50))
		sp.Put(sandbox.NewIsolate(51))
		w := judge.NewWorker(1, sp)

		logger, err := zap.NewDevelopment()
		if err != nil {
			return err
		}
		p, err := problems.Parse(TestProblemArgs.ProblemDir)
		if err != nil {
			return err
		}

		l := language.DefaultStore.Get(TestProblemArgs.Language)
		src, err := os.ReadFile(TestProblemArgs.SolutionPath)
		if err != nil {
			return err
		}

		st, err := w.Judge(context.Background(), logger, p, src, l, judge.NewWriterCallback(io.Discard, func() {}))
		for _, test := range st.Feedback[0].Testcases() {
			fmt.Println(test.Group, test.Index, test.VerdictName, test.Score, test.MaxScore)
		}
		fmt.Println(st.Feedback[0].Verdict(), st.Feedback[0].Score(), "/", st.Feedback[0].MaxScore())
		fmt.Println(st.FeedbackType.String())

		if TestProblemArgs.Verbose > 0 {
			res, err := json.Marshal(st)
			if err != nil {
				return err
			}

			fmt.Println(string(res))
		}

		return err
	},
}

var WebCmd = &cobra.Command{
	Use:   "web",
	Short: "manage web related parts, for example start webserver, run migrations etc.",
	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
		BindEnvs(config.Server{})
		viper.SetEnvPrefix("njudge")

		viper.SetConfigName("web")
		viper.AddConfigPath(".")
		viper.AutomaticEnv()
		return viper.MergeInConfig()
	},

	RunE: func(cmd *cobra.Command, args []string) error {
		cfg := config.Server{}

		err := viper.Unmarshal(&cfg)
		if err != nil {
			return err
		}

		s := web.Server{Server: cfg}
		s.Run()

		return nil
	},
}

Functions

func BindEnvs

func BindEnvs(iface interface{}, parts ...string)

func Execute

func Execute()

func RenameInDB

func RenameInDB(from, to string, tx *sql.Tx) error