Merge Go frontend (apiserver + xcecli) into meson build
This commit is contained in:
parent
43dc12a36c
commit
c9dc8c4676
205 changed files with 30793 additions and 328 deletions
734
src/frontend/xcecli/cmd/jobs/submit.go
Executable file
734
src/frontend/xcecli/cmd/jobs/submit.go
Executable file
|
|
@ -0,0 +1,734 @@
|
|||
package jobs
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"os/exec"
|
||||
"regexp"
|
||||
"runtime"
|
||||
"strings"
|
||||
"time"
|
||||
"xcecli/common/request"
|
||||
"xcecli/common/utils"
|
||||
"xcecli/config"
|
||||
logger "xcecli/config"
|
||||
"xcecli/models"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
"github.com/spf13/pflag"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
// JobSubmitter structure for managing job submission from the CLI parameters and operations
|
||||
type JobSubmitter struct {
|
||||
configManager *config.ConfigManager
|
||||
queue string
|
||||
resReq string
|
||||
beginTime string
|
||||
termTime string
|
||||
jobName string
|
||||
jobDescription string
|
||||
cpuLimit string
|
||||
command string
|
||||
runLimit string
|
||||
coreLimit string
|
||||
fileLimit string
|
||||
memLimit string
|
||||
swapLimit string
|
||||
dataLimit string
|
||||
processLimit string
|
||||
stackLimit string
|
||||
threadLimit string
|
||||
useShellLimit bool
|
||||
useSystemEnv bool
|
||||
subEnvVars []string
|
||||
cwd string
|
||||
uploadFiles []string
|
||||
processorRange string
|
||||
infile string
|
||||
outfile string
|
||||
errfile string
|
||||
outdir string
|
||||
configFile string
|
||||
interactive bool
|
||||
useTTY bool
|
||||
useXJob bool
|
||||
projectName string
|
||||
askedHosts string
|
||||
launchType string
|
||||
preExecCmd string
|
||||
postExecCmd string
|
||||
}
|
||||
|
||||
// NewJobSubmitter creates a new JobSubmitter instance
|
||||
func NewJobSubmitter(configManager *config.ConfigManager) *JobSubmitter {
|
||||
return &JobSubmitter{
|
||||
configManager: configManager,
|
||||
}
|
||||
}
|
||||
|
||||
// Parse parses command line arguments into JobSubmitter struct
|
||||
func (js *JobSubmitter) ParseCmdArgs(cmd *cobra.Command, args []string) error {
|
||||
// check if the -R flag is used more than once
|
||||
if cmd.Flags().Changed("resreq") {
|
||||
count := 0
|
||||
cmd.Flags().Visit(func(f *pflag.Flag) {
|
||||
if f.Name == "resreq" {
|
||||
count++
|
||||
}
|
||||
})
|
||||
if count > 1 {
|
||||
return fmt.Errorf("error: the -R/--resreq flag can only be used once")
|
||||
}
|
||||
}
|
||||
|
||||
if js.interactive {
|
||||
if js.useTTY && js.useXJob {
|
||||
return fmt.Errorf("error: cannot use both --tty and --xjob")
|
||||
}
|
||||
}
|
||||
|
||||
// check if there is standard input redirection
|
||||
fileInfo, err := os.Stdin.Stat()
|
||||
if err == nil && (fileInfo.Mode()&os.ModeCharDevice) == 0 {
|
||||
if tmpFileName, err := js.handleStdin(); err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return fmt.Errorf("error reading from stdin: [%s]", errMsg)
|
||||
} else if tmpFileName != "" {
|
||||
defer os.Remove(tmpFileName)
|
||||
}
|
||||
}
|
||||
|
||||
// if the config file is specified, parse the config file first
|
||||
if js.configFile != "" {
|
||||
return js.parseConfigFile()
|
||||
}
|
||||
|
||||
// command line parameters will override the settings in the config file
|
||||
if len(args) > 0 {
|
||||
js.command = strings.Join(args, " ")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (js *JobSubmitter) handleStdin() (string, error) {
|
||||
content, err := io.ReadAll(os.Stdin)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if len(content) == 0 {
|
||||
return "", nil
|
||||
}
|
||||
tmpFile, err := os.CreateTemp("", "xcecli_stdin_*.xce")
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return "", fmt.Errorf("failed to create temporary file: [%s]", errMsg)
|
||||
}
|
||||
defer tmpFile.Close()
|
||||
if _, err := tmpFile.Write(content); err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return "", fmt.Errorf("failed to write to temporary file: [%s]", errMsg)
|
||||
}
|
||||
js.configFile = tmpFile.Name()
|
||||
return js.configFile, nil
|
||||
}
|
||||
|
||||
// parseConfigFile parse the parameters in the config file
|
||||
func (js *JobSubmitter) parseConfigFile() error {
|
||||
// check if the file exists
|
||||
fileInfo, err := os.Stat(js.configFile)
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return fmt.Errorf("config file %s does not exist or cannot be accessed: [%s]", js.configFile, errMsg)
|
||||
}
|
||||
|
||||
if fileInfo.IsDir() {
|
||||
return fmt.Errorf("%s is a directory, not a valid config file", js.configFile)
|
||||
}
|
||||
|
||||
// if the file is a temporary file, delete it when the function ends
|
||||
if strings.Contains(js.configFile, "xcecli_stdin_") {
|
||||
defer os.Remove(js.configFile)
|
||||
}
|
||||
|
||||
// read the config file content
|
||||
content, err := os.ReadFile(js.configFile)
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return fmt.Errorf("failed to read the config file: %s", errMsg)
|
||||
}
|
||||
|
||||
lines := strings.Split(string(content), "\n")
|
||||
fmt.Printf("config file %s contains %d lines of commands\n", js.configFile, len(lines))
|
||||
|
||||
// create the main command
|
||||
rootCmd := NewSubmitJobsCmd(js.configManager)
|
||||
|
||||
// collect all parameters and commands
|
||||
var allParams []string
|
||||
var allCmdParts []string
|
||||
|
||||
// process each line
|
||||
for _, line := range lines {
|
||||
line = strings.TrimSpace(line)
|
||||
if line == "" {
|
||||
continue // skip empty lines
|
||||
}
|
||||
|
||||
if strings.HasPrefix(line, "#xce job submit") {
|
||||
// process the parameters in the comment line
|
||||
paramLine := strings.TrimPrefix(line, "#xce job submit")
|
||||
paramLine = strings.TrimSpace(paramLine)
|
||||
|
||||
if paramLine != "" {
|
||||
parts := strings.Fields(paramLine)
|
||||
|
||||
// separate the parameters and command parts
|
||||
for j := 0; j < len(parts); j++ {
|
||||
if strings.HasPrefix(parts[j], "-") {
|
||||
allParams = append(allParams, parts[j])
|
||||
|
||||
// if the parameter has a value and is not a -
|
||||
if j+1 < len(parts) && !strings.HasPrefix(parts[j+1], "-") {
|
||||
allParams = append(allParams, parts[j+1])
|
||||
j++
|
||||
}
|
||||
} else {
|
||||
// non-parameter part as command
|
||||
cmdPart := strings.Join(parts[j:], " ")
|
||||
if cmdPart != "" {
|
||||
allCmdParts = append(allCmdParts, cmdPart)
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// non-comment line as command part
|
||||
allCmdParts = append(allCmdParts, line)
|
||||
}
|
||||
}
|
||||
|
||||
// merge all command parts
|
||||
fullCommand := strings.Join(allCmdParts, " ")
|
||||
|
||||
// merge all parameters
|
||||
fullArgs := append(allParams, strings.Fields(fullCommand)...)
|
||||
|
||||
fmt.Println("merged full command:")
|
||||
fmt.Printf("xce jobs submit %s\n", strings.Join(fullArgs, " "))
|
||||
|
||||
// execute the merged command
|
||||
rootCmd.SetArgs(fullArgs)
|
||||
if err := rootCmd.Execute(); err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return fmt.Errorf("failed to execute the command: [%s]", errMsg)
|
||||
}
|
||||
os.Exit(0)
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// BuildJobRequest
|
||||
func (js *JobSubmitter) BuildJobRequest() (*models.JobSubmitRequest, error) {
|
||||
// create the job request with only required fields
|
||||
jobReq := &models.JobSubmitRequest{
|
||||
Command: js.command,
|
||||
}
|
||||
|
||||
if js.interactive {
|
||||
if js.useTTY {
|
||||
jobReq.Interactive = 1 // TTY mode
|
||||
} else if js.useXJob {
|
||||
jobReq.Interactive = 2 // XJob mode
|
||||
} else {
|
||||
jobReq.Interactive = 3 // only interactive, no special mode
|
||||
}
|
||||
} else {
|
||||
jobReq.Interactive = 0 // default value
|
||||
}
|
||||
|
||||
// Helper function to format limit values with space
|
||||
formatLimit := func(value string) string {
|
||||
if value == "" {
|
||||
return ""
|
||||
}
|
||||
re := regexp.MustCompile(`^(\d+)(MB|GB|TB|PB|[MGTP])$`)
|
||||
matches := re.FindStringSubmatch(strings.ToUpper(value))
|
||||
if matches != nil {
|
||||
return matches[1] + " " + matches[2]
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
// Set resource limits
|
||||
jobReq.SwapLimit = formatLimit(js.swapLimit)
|
||||
jobReq.DataLimit = formatLimit(js.dataLimit)
|
||||
jobReq.MemLimit = formatLimit(js.memLimit)
|
||||
jobReq.FileLimit = formatLimit(js.fileLimit)
|
||||
jobReq.CoreLimit = formatLimit(js.coreLimit)
|
||||
jobReq.ProcessLimit = formatLimit(js.processLimit)
|
||||
jobReq.StackLimit = formatLimit(js.stackLimit)
|
||||
jobReq.ThreadLimit = formatLimit(js.threadLimit)
|
||||
jobReq.CPULimit = formatLimit(js.cpuLimit)
|
||||
jobReq.RunLimit = formatLimit(js.runLimit)
|
||||
|
||||
// Set other fields if explicitly set
|
||||
jobReq.QueueName = js.queue
|
||||
jobReq.Resreq = js.resReq
|
||||
jobReq.JobName = js.jobName
|
||||
jobReq.JobDescription = js.jobDescription
|
||||
|
||||
// Parse processor range if specified
|
||||
if js.processorRange != "" {
|
||||
parts := strings.Split(js.processorRange, ",")
|
||||
if len(parts) == 2 {
|
||||
// Try to parse min and max processors
|
||||
minProc, err := utils.ParseInt(parts[0])
|
||||
if err != nil {
|
||||
return nil, errors.New("invalid min processor value")
|
||||
}
|
||||
maxProc, err := utils.ParseInt(parts[1])
|
||||
if err != nil {
|
||||
return nil, errors.New("invalid max processor value")
|
||||
}
|
||||
jobReq.NumProcessors = minProc
|
||||
jobReq.MaxNumProcessors = maxProc
|
||||
} else {
|
||||
// Single value case
|
||||
numProc, err := utils.ParseInt(js.processorRange)
|
||||
if err != nil {
|
||||
return nil, errors.New("invalid processor value")
|
||||
}
|
||||
jobReq.NumProcessors = numProc
|
||||
}
|
||||
}
|
||||
|
||||
// parse the begin time
|
||||
if js.beginTime != "" {
|
||||
// Parse the time in local timezone
|
||||
parsedTime, err := utils.ParseTime(js.beginTime)
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return nil, fmt.Errorf("invalid begin time value and %s", errMsg)
|
||||
}
|
||||
jobReq.BeginTime = parsedTime
|
||||
}
|
||||
// If the date is in the past, add appropriate time
|
||||
|
||||
// parse the end time
|
||||
if js.termTime != "" {
|
||||
parsedTime, err := utils.ParseTime(js.termTime)
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return nil, fmt.Errorf("invalid end time value and %s", errMsg)
|
||||
}
|
||||
jobReq.TermTime = parsedTime
|
||||
}
|
||||
|
||||
// if shell limit is enabled, get the system limits
|
||||
if js.useShellLimit {
|
||||
limits := utils.NewSystemLimits()
|
||||
|
||||
// set the limits in the job request
|
||||
if val, err := limits.GetCPULimit(); err == nil && val > 0 {
|
||||
jobReq.CPULimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetFileLimit(); err == nil && val > 0 {
|
||||
jobReq.FileLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetDataLimit(); err == nil && val > 0 {
|
||||
jobReq.DataLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetStackLimit(); err == nil && val > 0 {
|
||||
jobReq.StackLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetCoreLimit(); err == nil && val > 0 {
|
||||
jobReq.CoreLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetProcessLimit(); err == nil && val > 0 {
|
||||
jobReq.ProcessLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetThreadLimit(); err == nil && val > 0 {
|
||||
jobReq.ThreadLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetMemLimit(); err == nil && val > 0 {
|
||||
jobReq.MemLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
if val, err := limits.GetSwapLimit(); err == nil && val > 0 {
|
||||
jobReq.SwapLimit = fmt.Sprintf("%d", val)
|
||||
}
|
||||
}
|
||||
|
||||
// if system environment variables are enabled, get and set them
|
||||
if js.useSystemEnv {
|
||||
systemEnv := utils.GetSystemEnv()
|
||||
filteredEnv := []string{}
|
||||
filteredEnv = append(filteredEnv, systemEnv...)
|
||||
jobReq.Env = filteredEnv
|
||||
}
|
||||
|
||||
// Add submitted environment variables
|
||||
if len(js.subEnvVars) > 0 {
|
||||
jobReq.Env = append(jobReq.Env, js.getEnvironmentVariables()...)
|
||||
}
|
||||
|
||||
if js.infile != "" {
|
||||
jobReq.InFile = js.infile
|
||||
}
|
||||
if js.outfile != "" {
|
||||
jobReq.OutFile = js.outfile
|
||||
}
|
||||
if js.errfile != "" {
|
||||
jobReq.ErrFile = js.errfile
|
||||
}
|
||||
if js.outdir != "" {
|
||||
jobReq.OutDir = js.outdir
|
||||
}
|
||||
|
||||
if js.projectName != "" {
|
||||
jobReq.ProjectName = js.projectName
|
||||
}
|
||||
if js.cwd != "" {
|
||||
jobReq.CWD = js.cwd
|
||||
} else {
|
||||
cwd, _ := os.Getwd()
|
||||
jobReq.CWD = cwd
|
||||
}
|
||||
|
||||
if js.askedHosts != "" {
|
||||
jobReq.AskedHosts = js.askedHosts
|
||||
}
|
||||
if js.launchType != "" {
|
||||
jobReq.LaunchType = js.launchType
|
||||
}
|
||||
if js.preExecCmd != "" {
|
||||
jobReq.PreExecCmd = js.preExecCmd
|
||||
}
|
||||
if js.postExecCmd != "" {
|
||||
jobReq.PostExecCmd = js.postExecCmd
|
||||
}
|
||||
return jobReq, nil
|
||||
}
|
||||
|
||||
// Run executes the job submission operation
|
||||
func (js *JobSubmitter) RunJobsSubmit() error {
|
||||
// Get server info and validate authentication
|
||||
serverInfo, _ := js.configManager.GetServerInfo()
|
||||
if js.command == "" {
|
||||
return fmt.Errorf("please provide the command to execute")
|
||||
}
|
||||
|
||||
if js.infile != "" {
|
||||
js.uploadFiles = append(js.uploadFiles, fmt.Sprintf("%s > %s", js.infile, js.infile))
|
||||
}
|
||||
if js.outfile != "" {
|
||||
js.uploadFiles = append(js.uploadFiles, fmt.Sprintf("%s < %s", js.outfile, js.outfile))
|
||||
}
|
||||
if js.errfile != "" {
|
||||
js.uploadFiles = append(js.uploadFiles, fmt.Sprintf("%s < %s", js.errfile, js.errfile))
|
||||
}
|
||||
|
||||
fileExists := func(path string) error {
|
||||
info, err := os.Stat(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error: the file %s does not exist, please check the file name or path", path)
|
||||
}
|
||||
if info.IsDir() {
|
||||
return fmt.Errorf("error: the file %s is a directory, please check the file name or path", path)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
if js.infile != "" {
|
||||
if err := fileExists(js.infile); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
if js.outdir != "" {
|
||||
info, err := os.Stat(js.outdir)
|
||||
if os.IsNotExist(err) {
|
||||
return fmt.Errorf("error: the output directory %s does not exist", js.outdir)
|
||||
}
|
||||
if !info.IsDir() {
|
||||
return fmt.Errorf("error: the output directory %s is not a directory", js.outdir)
|
||||
}
|
||||
}
|
||||
|
||||
// create the API client and submit the job
|
||||
apiClient := request.NewAPIClient(serverInfo.URL)
|
||||
apiClient.SetRootCAs(serverInfo.CACert)
|
||||
|
||||
var transferFile []string
|
||||
if len(js.uploadFiles) > 0 {
|
||||
fileTrans := newFileTransfer(js.uploadFiles)
|
||||
err := fileTrans.uploadFiles(func(s []string) (*models.UploadResponse, error) {
|
||||
return apiClient.PostFile("Bearer "+serverInfo.Token, s)
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
transferFile = fileTrans.buildTransferFileList()
|
||||
}
|
||||
// build the job request
|
||||
jobReq, err := js.BuildJobRequest()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
jobReq.TransferFiles = transferFile
|
||||
jobResp, err := apiClient.SubmitJob("Bearer "+serverInfo.Token, jobReq)
|
||||
logger.Debug("jobResp", zap.Any("jobResp", jobResp), zap.Error(err))
|
||||
logger.Info("jobResp", zap.Any("jobResp", jobResp), zap.Error(err))
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
fmt.Printf("%s\n", jobResp.Data.Message)
|
||||
logger.Debug("job submitted successfully", zap.String("message", jobResp.Data.Message))
|
||||
logger.Info("job submitted successfully", zap.String("message", jobResp.Data.Message))
|
||||
|
||||
if js.interactive {
|
||||
fmt.Println("<<waiting for dispatch ...>>")
|
||||
url, err := js.waitForInteractiveURL(apiClient, serverInfo.Token, fmt.Sprintf("%d", jobResp.Data.JobID))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("interactive session URL: %s\n", url)
|
||||
|
||||
// automatically open the browser
|
||||
if err := openBrowser(url); err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
fmt.Printf("warning: failed to open browser: [%s]\n", errMsg)
|
||||
fmt.Println("Please manually open the URL in your browser.")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (js *JobSubmitter) checkJobStatus(apiClient *request.APIClient, token string, jobID string) (string, error) {
|
||||
var resp models.JobsResponse
|
||||
err := apiClient.GetRequestFromAPIServer(
|
||||
"Bearer "+token,
|
||||
"",
|
||||
"",
|
||||
fmt.Sprintf("/xce/v1/jobs/%s", jobID),
|
||||
&resp,
|
||||
map[string]string{ /*"fields": "interactive_job_url"*/ },
|
||||
)
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return "", fmt.Errorf("failed to get job details: [%s]", errMsg)
|
||||
}
|
||||
for _, row := range resp.Data.Rows {
|
||||
switch row.JobStatus {
|
||||
case "PEND":
|
||||
return row.JobStatus, nil
|
||||
case "RUN":
|
||||
var execHosts models.ExecHosts
|
||||
if err := json.Unmarshal([]byte(row.ExecHosts.String()), &execHosts); err == nil && len(execHosts.HostSlots) > 0 {
|
||||
fmt.Println("<<Starting on", execHosts.HostSlots[0].HostName, ">>")
|
||||
}
|
||||
return row.JobStatus, nil
|
||||
default:
|
||||
return "", fmt.Errorf("job %s is in state %s, please check the job status", jobID, row.JobStatus)
|
||||
}
|
||||
}
|
||||
return "", fmt.Errorf("timeout waiting for job status")
|
||||
}
|
||||
|
||||
func (js *JobSubmitter) checkExtendData(apiClient *request.APIClient, token string, jobID string) (string, error) {
|
||||
var resp models.JobsResponse
|
||||
err := apiClient.GetRequestFromAPIServer(
|
||||
"Bearer "+token,
|
||||
"",
|
||||
"",
|
||||
fmt.Sprintf("/xce/v1/jobs/%s", jobID),
|
||||
&resp,
|
||||
map[string]string{"fields": "interactive_job_url"},
|
||||
)
|
||||
if err != nil {
|
||||
errMsg := request.ExtractErrorMessage(err)
|
||||
return "", fmt.Errorf("failed to get job details: [%s]", errMsg)
|
||||
}
|
||||
for _, row := range resp.Data.Rows {
|
||||
//fmt.Println(row)
|
||||
if row.InteractiveJobURL != "" {
|
||||
return row.InteractiveJobURL, nil
|
||||
}
|
||||
}
|
||||
return "", fmt.Errorf("no interactive job URL found")
|
||||
}
|
||||
|
||||
func (js *JobSubmitter) waitForInteractiveURL(apiClient *request.APIClient, token string, jobID string) (string, error) {
|
||||
timeout := time.After(24 * time.Hour)
|
||||
|
||||
timer := time.NewTimer(0)
|
||||
defer timer.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-timeout:
|
||||
return "", fmt.Errorf("timeout waiting for interactive URL")
|
||||
case <-timer.C:
|
||||
status, err := js.checkJobStatus(apiClient, token, jobID)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if status == "PEND" {
|
||||
timer.Reset(5 * time.Second)
|
||||
continue
|
||||
}
|
||||
if status == "RUN" {
|
||||
//time.Sleep(45 * time.Second)
|
||||
return js.checkExtendData(apiClient, token, jobID)
|
||||
}
|
||||
return "", fmt.Errorf("job %s is in state %s, please check the job status", jobID, status)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func openBrowser(url string) error {
|
||||
var err error
|
||||
switch runtime.GOOS {
|
||||
case "linux":
|
||||
err = exec.Command("xdg-open", url).Start()
|
||||
case "windows":
|
||||
err = exec.Command("cmd", "/c", "start", url).Start()
|
||||
case "darwin":
|
||||
err = exec.Command("open", url).Start()
|
||||
default:
|
||||
err = fmt.Errorf("unsupported platform")
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// NewSubCmd creates a command for submitting jobs
|
||||
func NewSubmitJobsCmd(configManager *config.ConfigManager) *cobra.Command {
|
||||
jobSubmitter := NewJobSubmitter(configManager)
|
||||
|
||||
cmd := &cobra.Command{
|
||||
Use: "submit",
|
||||
Short: "Submit job to API Server",
|
||||
Long: `Submit job to API Server.
|
||||
Example:
|
||||
xce jobs submit -q queue_name sleep 10 # submit job to queue queue_name with command "sleep 10"
|
||||
xce jobs submit -R "select(!mg)" sleep 10 # submit job with resource requirement "select(!mg)"
|
||||
xce jobs submit -c 10 sleep 10 # submit job with cpu limit 10
|
||||
xce jobs submit -C 10 sleep 10 # submit job with core limit 10
|
||||
xce jobs submit -b "2025-03-20 10:00" sleep 10 # submit job with begin time "2025-03-20 10:00"
|
||||
xce jobs submit -t "2025-03-20 10:00" sleep 10 # submit job with termination time "2025-03-20 10:00"
|
||||
xce jobs submit -J "test" sleep 10 # submit job with job name "test"
|
||||
xce jobs submit --Jd "test" sleep 10 # submit job with job description "test"
|
||||
xce jobs submit -F 1024 sleep 10 # submit job with file limit 1024
|
||||
xce jobs submit -W 10 sleep 10 # sets the runtime limit of the job
|
||||
xce jobs submit -M 1024 sleep 10 # sets the memory limit of the job
|
||||
xce jobs submit -v 1024 sleep 10 # sets the swap limit of the job
|
||||
xce jobs submit -D 1024 sleep 10 # sets the data limit of the job
|
||||
xce jobs submit -p 10 sleep 10 # sets the process limit of the job
|
||||
xce jobs submit -S 1024 sleep 10 # sets the stack limit of the job
|
||||
xce jobs submit -T 1024 sleep 10 # sets the thread limit of the job
|
||||
xce jobs submit --ul sleep 10 # use current shell limits
|
||||
xce jobs submit --env sleep 10 # use system environment variables
|
||||
xce jobs submit --cwd "/tmp/" sleep 10 # use current working directory for job execution
|
||||
xce jobs submit -f "t1.txt > t2.txt" sleep 10 # submit job with file "t1.txt" and redirect the output to "t2.txt"
|
||||
xce jobs submit -q "normal" sleep 10 # submit job to queue "normal" and "priority"
|
||||
xce jobs submit -n 4,6 sleep 10 # submit job with processor range 4-6
|
||||
xce jobs submit -P project_name sleep 10 # submit job with project name
|
||||
xce jobs submit --configfile job.xce # submit job using parameters from a configuration file
|
||||
xce jobs submit -m "host1 host2" sleep 10 # submit job into host1 host2
|
||||
xce jobs submit -I --tty sleep 10 # submit interactive job with tty
|
||||
xce jobs submit -I --xjob sleep 10 # submit interactive job with xjob`,
|
||||
|
||||
SilenceUsage: true,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if err := jobSubmitter.ParseCmdArgs(cmd, args); err != nil {
|
||||
fmt.Println(strings.ToLower(err.Error()))
|
||||
return
|
||||
}
|
||||
if err := jobSubmitter.RunJobsSubmit(); err != nil {
|
||||
fmt.Println(strings.ToLower(err.Error()))
|
||||
return
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
// add the flags
|
||||
flags := cmd.Flags()
|
||||
|
||||
// modify the resreq flag
|
||||
resReqFlag := &pflag.Flag{
|
||||
Name: "resreq",
|
||||
Shorthand: "R",
|
||||
Usage: "specify the resource requirement (can only be used once)",
|
||||
Value: (*stringValue)(&jobSubmitter.resReq),
|
||||
NoOptDefVal: "",
|
||||
}
|
||||
flags.AddFlag(resReqFlag)
|
||||
|
||||
//modify the flags
|
||||
flags.StringVarP(&jobSubmitter.beginTime, "begin_time", "b", "", "specify the begin time")
|
||||
flags.StringVarP(&jobSubmitter.coreLimit, "core_limit", "C", "", "specify the core number")
|
||||
flags.StringVarP(&jobSubmitter.jobName, "job_name", "J", "", "specify the job name")
|
||||
flags.StringVarP(&jobSubmitter.jobDescription, "Jd", "", "", "specify the job description")
|
||||
flags.StringVarP(&jobSubmitter.termTime, "term_time", "t", "", "specify the termination time")
|
||||
flags.StringVarP(&jobSubmitter.cpuLimit, "cpu_limit", "c", "", "specify the cpu limit")
|
||||
flags.StringVarP(&jobSubmitter.runLimit, "run_limit", "W", "", "specify the run time")
|
||||
flags.StringVarP(&jobSubmitter.fileLimit, "file_limit", "F", "", "specify the file limit")
|
||||
flags.StringVarP(&jobSubmitter.memLimit, "mem_limit", "M", "", "specify the memory limit")
|
||||
flags.StringVarP(&jobSubmitter.swapLimit, "swap_limit", "v", "", "specify the swap limit")
|
||||
flags.StringVarP(&jobSubmitter.dataLimit, "data_limit", "D", "", "specify the data limit")
|
||||
flags.StringVarP(&jobSubmitter.processLimit, "process_limit", "p", "", "specify the process limit")
|
||||
flags.StringVarP(&jobSubmitter.stackLimit, "stack_limit", "S", "", "specify the stack limit")
|
||||
flags.StringVarP(&jobSubmitter.threadLimit, "thread_limit", "T", "", "specify the thread limit")
|
||||
flags.BoolVarP(&jobSubmitter.useShellLimit, "ul", "", false, "use current shell limits")
|
||||
flags.BoolVarP(&jobSubmitter.useSystemEnv, "env", "", false, "use system environment variables")
|
||||
flags.StringVarP(&jobSubmitter.cwd, "cwd", "", "", "current working directory")
|
||||
flags.StringArrayVarP(&jobSubmitter.uploadFiles, "file", "f", []string{}, "specify the files to upload")
|
||||
flags.StringVarP(&jobSubmitter.queue, "queue_name", "q", "", "specify the job queue")
|
||||
flags.StringVarP(&jobSubmitter.processorRange, "processor_range", "n", "", "specify processor range in format min,max (e.g. 4,6)")
|
||||
flags.StringVarP(&jobSubmitter.infile, "infile", "i", "", "specify the input file")
|
||||
flags.StringVarP(&jobSubmitter.outfile, "outfile", "o", "", "specify the output file")
|
||||
flags.StringVarP(&jobSubmitter.errfile, "errfile", "e", "", "specify the error file")
|
||||
flags.StringVarP(&jobSubmitter.outdir, "outdir", "d", "", "specify the output directory")
|
||||
flags.StringVarP(&jobSubmitter.projectName, "project_name", "P", "", "specify the project name")
|
||||
flags.StringVar(&jobSubmitter.configFile, "configfile", "", "specify the configuration file for job submission")
|
||||
flags.BoolVarP(&jobSubmitter.interactive, "interactive", "I", false, "submit interactive job")
|
||||
flags.BoolVar(&jobSubmitter.useTTY, "tty", false, "use TTY for interactive job")
|
||||
flags.BoolVar(&jobSubmitter.useXJob, "xjob", false, "use XJob for interactive job")
|
||||
flags.StringVarP(&jobSubmitter.askedHosts, "m", "m", "", "specify the running hosts, with space for multiple values")
|
||||
flags.StringVarP(&jobSubmitter.launchType, "launch_type", "", "", "specify the launch type")
|
||||
flags.StringVarP(&jobSubmitter.preExecCmd, "pre_exec", "", "", "specify the pre-execution command")
|
||||
flags.StringVarP(&jobSubmitter.postExecCmd, "post_exec", "", "", "specify the post-execution command")
|
||||
return cmd
|
||||
//
|
||||
}
|
||||
|
||||
// modify the stringValue
|
||||
type stringValue string
|
||||
|
||||
func (s *stringValue) String() string { return string(*s) }
|
||||
func (s *stringValue) Set(val string) error {
|
||||
if *s != "" {
|
||||
return fmt.Errorf("the -R/--resreq flag can only be used once")
|
||||
}
|
||||
*s = stringValue(val)
|
||||
return nil
|
||||
}
|
||||
func (s *stringValue) Type() string { return "string" }
|
||||
|
||||
func (js *JobSubmitter) getEnvironmentVariables() []string {
|
||||
var envVars []string
|
||||
for _, env := range js.subEnvVars {
|
||||
// Skip environment variables with multiple equal signs
|
||||
if strings.Count(env, "=") > 1 {
|
||||
continue
|
||||
}
|
||||
envVars = append(envVars, env)
|
||||
}
|
||||
return envVars
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue